docs: def setup_multiprocessing_logging(queue=None):
      '''
      This code should be called from within a running multiprocessing
      process instance.
      '''
      from salt.utils.platform import is_windows
  
      global __MP_LOGGING_CONFIGURED
      global __MP_LOGGING_QUEUE_HANDLER
  
      if __MP_IN_MAINPROCESS is True and not is_windows():
          # We're in the MainProcess, return! No multiprocessing logging setup shall happen
          # Windows is the exception where we want to set up multiprocessing
          # logging in the MainProcess.
          return
  
      try:
          logging._acquireLock()  # pylint: disable=protected-access
  
          if __MP_LOGGING_CONFIGURED is True:
              return
  
          # Let's set it to true as fast as possible
          __MP_LOGGING_CONFIGURED = True
  
          if __MP_LOGGING_QUEUE_HANDLER is not None:
              return
  
          # The temp null and temp queue logging handlers will store messages.
          # Since noone will process them, memory usage will grow. If they
          # exist, remove them.
          __remove_null_logging_handler()
          __remove_queue_logging_handler()
  
          # Let's add a queue handler to the logging root handlers
          __MP_LOGGING_QUEUE_HANDLER = SaltLogQueueHandler(queue or get_multiprocessing_logging_queue())
          logging.root.addHandler(__MP_LOGGING_QUEUE_HANDLER)
          # Set the logging root level to the lowest needed level to get all
          # desired messages.
          log_level = get_multiprocessing_logging_level()
          logging.root.setLevel(log_level)
          logging.getLogger(__name__).debug(
              'Multiprocessing queue logging configured for the process running '
              'under PID: %s at log level %s', os.getpid(), log_level
          )
          # The above logging call will create, in some situations, a futex wait
          # lock condition, probably due to the multiprocessing Queue's internal
          # lock and semaphore mechanisms.
          # A small sleep will allow us not to hit that futex wait lock condition.
          time.sleep(0.0001)
      finally:
          logging._releaseLock()