docs: def _thread_multi_return(cls, minion_instance, opts, data):
          '''
          This method should be used as a threading target, start the actual
          minion side execution.
          '''
          fn_ = os.path.join(minion_instance.proc_dir, data['jid'])
  
          if opts['multiprocessing'] and not salt.utils.platform.is_windows():
              # Shutdown the multiprocessing before daemonizing
              salt.log.setup.shutdown_multiprocessing_logging()
  
              salt.utils.process.daemonize_if(opts)
  
              # Reconfigure multiprocessing logging after daemonizing
              salt.log.setup.setup_multiprocessing_logging()
  
          salt.utils.process.appendproctitle('{0}._thread_multi_return {1}'.format(cls.__name__, data['jid']))
  
          sdata = {'pid': os.getpid()}
          sdata.update(data)
          log.info('Starting a new job with PID %s', sdata['pid'])
          with salt.utils.files.fopen(fn_, 'w+b') as fp_:
              fp_.write(minion_instance.serial.dumps(sdata))
  
          multifunc_ordered = opts.get('multifunc_ordered', False)
          num_funcs = len(data['fun'])
          if multifunc_ordered:
              ret = {
                  'return': [None] * num_funcs,
                  'retcode': [None] * num_funcs,
                  'success': [False] * num_funcs
              }
          else:
              ret = {
                  'return': {},
                  'retcode': {},
                  'success': {}
              }
  
          for ind in range(0, num_funcs):
              if not multifunc_ordered:
                  ret['success'][data['fun'][ind]] = False
              try:
                  minion_blackout_violation = False
                  if minion_instance.connected and minion_instance.opts['pillar'].get('minion_blackout', False):
                      whitelist = minion_instance.opts['pillar'].get('minion_blackout_whitelist', [])
                      # this minion is blacked out. Only allow saltutil.refresh_pillar and the whitelist
                      if data['fun'][ind] != 'saltutil.refresh_pillar' and data['fun'][ind] not in whitelist:
                          minion_blackout_violation = True
                  elif minion_instance.opts['grains'].get('minion_blackout', False):
                      whitelist = minion_instance.opts['grains'].get('minion_blackout_whitelist', [])
                      if data['fun'][ind] != 'saltutil.refresh_pillar' and data['fun'][ind] not in whitelist:
                          minion_blackout_violation = True
                  if minion_blackout_violation:
                      raise SaltInvocationError('Minion in blackout mode. Set \'minion_blackout\' '
                                               'to False in pillar or grains to resume operations. Only '
                                               'saltutil.refresh_pillar allowed in blackout mode.')
  
                  func = minion_instance.functions[data['fun'][ind]]
  
                  args, kwargs = load_args_and_kwargs(
                      func,
                      data['arg'][ind],
                      data)
                  minion_instance.functions.pack['__context__']['retcode'] = 0
                  key = ind if multifunc_ordered else data['fun'][ind]
                  ret['return'][key] = func(*args, **kwargs)
                  retcode = minion_instance.functions.pack['__context__'].get(
                      'retcode',
                      0
                  )
                  if retcode == 0:
                      # No nonzero retcode in __context__ dunder. Check if return
                      # is a dictionary with a "result" or "success" key.
                      try:
                          func_result = all(ret['return'][key].get(x, True)
                                            for x in ('result', 'success'))
                      except Exception:
                          # return data is not a dict
                          func_result = True
                      if not func_result:
                          retcode = 1
  
                  ret['retcode'][key] = retcode
                  ret['success'][key] = retcode == 0
              except Exception as exc:
                  trb = traceback.format_exc()
                  log.warning('The minion function caused an exception: %s', exc)
                  if multifunc_ordered:
                      ret['return'][ind] = trb
                  else:
                      ret['return'][data['fun'][ind]] = trb
              ret['jid'] = data['jid']
              ret['fun'] = data['fun']
              ret['fun_args'] = data['arg']
          if 'metadata' in data:
              ret['metadata'] = data['metadata']
          if minion_instance.connected:
              minion_instance._return_pub(
                  ret,
                  timeout=minion_instance._return_retry_timer()
              )
          if data['ret']:
              if 'ret_config' in data:
                  ret['ret_config'] = data['ret_config']
              if 'ret_kwargs' in data:
                  ret['ret_kwargs'] = data['ret_kwargs']
              for returner in set(data['ret'].split(',')):
                  ret['id'] = opts['id']
                  try:
                      minion_instance.returners['{0}.returner'.format(
                          returner
                      )](ret)
                  except Exception as exc:
                      log.error(
                          'The return failed for job %s: %s',
                          data['jid'], exc
                      )