#include "datatype/timestamp.h"
#include "lib/ilist.h"
#include "postmaster/bgworker.h"

Include dependency graph for bgworker_internals.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	RegisteredBgWorker

Macros
#define	MAX_PARALLEL_WORKER_LIMIT 1024

Typedefs
typedef struct RegisteredBgWorker	RegisteredBgWorker

Functions
Size	BackgroundWorkerShmemSize (void)

void	BackgroundWorkerShmemInit (void)

void	BackgroundWorkerStateChange (bool allow_new_workers)

void	ForgetBackgroundWorker (slist_mutable_iter *cur)

void	ReportBackgroundWorkerPID (RegisteredBgWorker *)

void	ReportBackgroundWorkerExit (slist_mutable_iter *cur)

void	BackgroundWorkerStopNotifications (pid_t pid)

void	ForgetUnstartedBackgroundWorkers (void)

void	ResetBackgroundWorkerCrashTimes (void)

void	StartBackgroundWorker (void) pg_attribute_noreturn()

Variables
PGDLLIMPORT slist_head	BackgroundWorkerList

Macro Definition Documentation

◆ MAX_PARALLEL_WORKER_LIMIT

#define MAX_PARALLEL_WORKER_LIMIT 1024

Definition at line 24 of file bgworker_internals.h.

Typedef Documentation

◆ RegisteredBgWorker

typedef struct RegisteredBgWorker RegisteredBgWorker

Function Documentation

◆ BackgroundWorkerShmemInit()

void BackgroundWorkerShmemInit ( void )

Definition at line 161 of file bgworker.c.

 {
     bool        found;
  
     BackgroundWorkerData = ShmemInitStruct("Background Worker Data",
                                            BackgroundWorkerShmemSize(),
                                            &found);
     if (!IsUnderPostmaster)
     {
         slist_iter  siter;
         int         slotno = 0;
  
         BackgroundWorkerData->total_slots = max_worker_processes;
         BackgroundWorkerData->parallel_register_count = 0;
         BackgroundWorkerData->parallel_terminate_count = 0;
  
         /*
          * Copy contents of worker list into shared memory.  Record the shared
          * memory slot assigned to each worker.  This ensures a 1-to-1
          * correspondence between the postmaster's private list and the array
          * in shared memory.
          */
         slist_foreach(siter, &BackgroundWorkerList)
         {
             BackgroundWorkerSlot *slot = &BackgroundWorkerData->slot[slotno];
             RegisteredBgWorker *rw;
  
             rw = slist_container(RegisteredBgWorker, rw_lnode, siter.cur);
             Assert(slotno < max_worker_processes);
             slot->in_use = true;
             slot->terminate = false;
             slot->pid = InvalidPid;
             slot->generation = 0;
             rw->rw_shmem_slot = slotno;
             rw->rw_worker.bgw_notify_pid = 0;   /* might be reinit after crash */
             memcpy(&slot->worker, &rw->rw_worker, sizeof(BackgroundWorker));
             ++slotno;
         }
  
         /*
          * Mark any remaining slots as not in use.
          */
         while (slotno < max_worker_processes)
         {
             BackgroundWorkerSlot *slot = &BackgroundWorkerData->slot[slotno];
  
             slot->in_use = false;
             ++slotno;
         }
     }
     else
         Assert(found);
 }

References Assert(), BackgroundWorkerData, BackgroundWorkerList, BackgroundWorkerShmemSize(), BackgroundWorker::bgw_notify_pid, slist_iter::cur, BackgroundWorkerSlot::generation, BackgroundWorkerSlot::in_use, InvalidPid, IsUnderPostmaster, max_worker_processes, BackgroundWorkerArray::parallel_register_count, BackgroundWorkerArray::parallel_terminate_count, BackgroundWorkerSlot::pid, RegisteredBgWorker::rw_shmem_slot, RegisteredBgWorker::rw_worker, ShmemInitStruct(), slist_container, slist_foreach, BackgroundWorkerArray::slot, BackgroundWorkerSlot::terminate, BackgroundWorkerArray::total_slots, and BackgroundWorkerSlot::worker.

Referenced by CreateSharedMemoryAndSemaphores().

◆ BackgroundWorkerShmemSize()

Size BackgroundWorkerShmemSize ( void )

Definition at line 145 of file bgworker.c.

 {
     Size        size;
  
     /* Array of workers is variably sized. */
     size = offsetof(BackgroundWorkerArray, slot);
     size = add_size(size, mul_size(max_worker_processes,
                                    sizeof(BackgroundWorkerSlot)));
  
     return size;
 }

References add_size(), max_worker_processes, and mul_size().

Referenced by BackgroundWorkerShmemInit(), and CalculateShmemSize().

◆ BackgroundWorkerStateChange()

void BackgroundWorkerStateChange ( bool allow_new_workers )

Definition at line 245 of file bgworker.c.

 {
     int         slotno;
  
     /*
      * The total number of slots stored in shared memory should match our
      * notion of max_worker_processes.  If it does not, something is very
      * wrong.  Further down, we always refer to this value as
      * max_worker_processes, in case shared memory gets corrupted while we're
      * looping.
      */
     if (max_worker_processes != BackgroundWorkerData->total_slots)
     {
         ereport(LOG,
                 (errmsg("inconsistent background worker state (max_worker_processes=%d, total_slots=%d)",
                         max_worker_processes,
                         BackgroundWorkerData->total_slots)));
         return;
     }
  
     /*
      * Iterate through slots, looking for newly-registered workers or workers
      * who must die.
      */
     for (slotno = 0; slotno < max_worker_processes; ++slotno)
     {
         BackgroundWorkerSlot *slot = &BackgroundWorkerData->slot[slotno];
         RegisteredBgWorker *rw;
  
         if (!slot->in_use)
             continue;
  
         /*
          * Make sure we don't see the in_use flag before the updated slot
          * contents.
          */
         pg_read_barrier();
  
         /* See whether we already know about this worker. */
         rw = FindRegisteredWorkerBySlotNumber(slotno);
         if (rw != NULL)
         {
             /*
              * In general, the worker data can't change after it's initially
              * registered.  However, someone can set the terminate flag.
              */
             if (slot->terminate && !rw->rw_terminate)
             {
                 rw->rw_terminate = true;
                 if (rw->rw_pid != 0)
                     kill(rw->rw_pid, SIGTERM);
                 else
                 {
                     /* Report never-started, now-terminated worker as dead. */
                     ReportBackgroundWorkerPID(rw);
                 }
             }
             continue;
         }
  
         /*
          * If we aren't allowing new workers, then immediately mark it for
          * termination; the next stanza will take care of cleaning it up.
          * Doing this ensures that any process waiting for the worker will get
          * awoken, even though the worker will never be allowed to run.
          */
         if (!allow_new_workers)
             slot->terminate = true;
  
         /*
          * If the worker is marked for termination, we don't need to add it to
          * the registered workers list; we can just free the slot. However, if
          * bgw_notify_pid is set, the process that registered the worker may
          * need to know that we've processed the terminate request, so be sure
          * to signal it.
          */
         if (slot->terminate)
         {
             int         notify_pid;
  
             /*
              * We need a memory barrier here to make sure that the load of
              * bgw_notify_pid and the update of parallel_terminate_count
              * complete before the store to in_use.
              */
             notify_pid = slot->worker.bgw_notify_pid;
             if ((slot->worker.bgw_flags & BGWORKER_CLASS_PARALLEL) != 0)
                 BackgroundWorkerData->parallel_terminate_count++;
             slot->pid = 0;
  
             pg_memory_barrier();
             slot->in_use = false;
  
             if (notify_pid != 0)
                 kill(notify_pid, SIGUSR1);
  
             continue;
         }
  
         /*
          * Copy the registration data into the registered workers list.
          */
         rw = malloc(sizeof(RegisteredBgWorker));
         if (rw == NULL)
         {
             ereport(LOG,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("out of memory")));
             return;
         }
  
         /*
          * Copy strings in a paranoid way.  If shared memory is corrupted, the
          * source data might not even be NUL-terminated.
          */
         ascii_safe_strlcpy(rw->rw_worker.bgw_name,
                            slot->worker.bgw_name, BGW_MAXLEN);
         ascii_safe_strlcpy(rw->rw_worker.bgw_type,
                            slot->worker.bgw_type, BGW_MAXLEN);
         ascii_safe_strlcpy(rw->rw_worker.bgw_library_name,
                            slot->worker.bgw_library_name, BGW_MAXLEN);
         ascii_safe_strlcpy(rw->rw_worker.bgw_function_name,
                            slot->worker.bgw_function_name, BGW_MAXLEN);
  
         /*
          * Copy various fixed-size fields.
          *
          * flags, start_time, and restart_time are examined by the postmaster,
          * but nothing too bad will happen if they are corrupted.  The
          * remaining fields will only be examined by the child process.  It
          * might crash, but we won't.
          */
         rw->rw_worker.bgw_flags = slot->worker.bgw_flags;
         rw->rw_worker.bgw_start_time = slot->worker.bgw_start_time;
         rw->rw_worker.bgw_restart_time = slot->worker.bgw_restart_time;
         rw->rw_worker.bgw_main_arg = slot->worker.bgw_main_arg;
         memcpy(rw->rw_worker.bgw_extra, slot->worker.bgw_extra, BGW_EXTRALEN);
  
         /*
          * Copy the PID to be notified about state changes, but only if the
          * postmaster knows about a backend with that PID.  It isn't an error
          * if the postmaster doesn't know about the PID, because the backend
          * that requested the worker could have died (or been killed) just
          * after doing so.  Nonetheless, at least until we get some experience
          * with how this plays out in the wild, log a message at a relative
          * high debug level.
          */
         rw->rw_worker.bgw_notify_pid = slot->worker.bgw_notify_pid;
         if (!PostmasterMarkPIDForWorkerNotify(rw->rw_worker.bgw_notify_pid))
         {
             elog(DEBUG1, "worker notification PID %d is not valid",
                  (int) rw->rw_worker.bgw_notify_pid);
             rw->rw_worker.bgw_notify_pid = 0;
         }
  
         /* Initialize postmaster bookkeeping. */
         rw->rw_backend = NULL;
         rw->rw_pid = 0;
         rw->rw_child_slot = 0;
         rw->rw_crashed_at = 0;
         rw->rw_shmem_slot = slotno;
         rw->rw_terminate = false;
  
         /* Log it! */
         ereport(DEBUG1,
                 (errmsg_internal("registering background worker \"%s\"",
                                  rw->rw_worker.bgw_name)));
  
         slist_push_head(&BackgroundWorkerList, &rw->rw_lnode);
     }
 }

Referenced by process_pm_pmsignal().

◆ BackgroundWorkerStopNotifications()

void BackgroundWorkerStopNotifications ( pid_t pid )

Definition at line 517 of file bgworker.c.

 {
     slist_iter  siter;
  
     slist_foreach(siter, &BackgroundWorkerList)
     {
         RegisteredBgWorker *rw;
  
         rw = slist_container(RegisteredBgWorker, rw_lnode, siter.cur);
         if (rw->rw_worker.bgw_notify_pid == pid)
             rw->rw_worker.bgw_notify_pid = 0;
     }
 }

References BackgroundWorkerList, BackgroundWorker::bgw_notify_pid, slist_iter::cur, RegisteredBgWorker::rw_worker, slist_container, and slist_foreach.

Referenced by CleanupBackend(), and CleanupBackgroundWorker().

◆ ForgetBackgroundWorker()

void ForgetBackgroundWorker ( slist_mutable_iter * cur )

Definition at line 429 of file bgworker.c.

 {
     RegisteredBgWorker *rw;
     BackgroundWorkerSlot *slot;
  
     rw = slist_container(RegisteredBgWorker, rw_lnode, cur->cur);
  
     Assert(rw->rw_shmem_slot < max_worker_processes);
     slot = &BackgroundWorkerData->slot[rw->rw_shmem_slot];
     Assert(slot->in_use);
  
     /*
      * We need a memory barrier here to make sure that the update of
      * parallel_terminate_count completes before the store to in_use.
      */
     if ((rw->rw_worker.bgw_flags & BGWORKER_CLASS_PARALLEL) != 0)
         BackgroundWorkerData->parallel_terminate_count++;
  
     pg_memory_barrier();
     slot->in_use = false;
  
     ereport(DEBUG1,
             (errmsg_internal("unregistering background worker \"%s\"",
                              rw->rw_worker.bgw_name)));
  
     slist_delete_current(cur);
     free(rw);
 }

References Assert(), BackgroundWorkerData, BackgroundWorker::bgw_flags, BackgroundWorker::bgw_name, BGWORKER_CLASS_PARALLEL, cur, DEBUG1, ereport, errmsg_internal(), free, BackgroundWorkerSlot::in_use, max_worker_processes, BackgroundWorkerArray::parallel_terminate_count, pg_memory_barrier, RegisteredBgWorker::rw_shmem_slot, RegisteredBgWorker::rw_worker, slist_container, slist_delete_current(), and BackgroundWorkerArray::slot.

Referenced by DetermineSleepTime(), ForgetUnstartedBackgroundWorkers(), maybe_start_bgworkers(), ReportBackgroundWorkerExit(), and ResetBackgroundWorkerCrashTimes().

◆ ForgetUnstartedBackgroundWorkers()

void ForgetUnstartedBackgroundWorkers ( void )

Definition at line 544 of file bgworker.c.

 {
     slist_mutable_iter iter;
  
     slist_foreach_modify(iter, &BackgroundWorkerList)
     {
         RegisteredBgWorker *rw;
         BackgroundWorkerSlot *slot;
  
         rw = slist_container(RegisteredBgWorker, rw_lnode, iter.cur);
         Assert(rw->rw_shmem_slot < max_worker_processes);
         slot = &BackgroundWorkerData->slot[rw->rw_shmem_slot];
  
         /* If it's not yet started, and there's someone waiting ... */
         if (slot->pid == InvalidPid &&
             rw->rw_worker.bgw_notify_pid != 0)
         {
             /* ... then zap it, and notify the waiter */
             int         notify_pid = rw->rw_worker.bgw_notify_pid;
  
             ForgetBackgroundWorker(&iter);
             if (notify_pid != 0)
                 kill(notify_pid, SIGUSR1);
         }
     }
 }

References Assert(), BackgroundWorkerData, BackgroundWorkerList, BackgroundWorker::bgw_notify_pid, slist_mutable_iter::cur, ForgetBackgroundWorker(), InvalidPid, kill, max_worker_processes, BackgroundWorkerSlot::pid, RegisteredBgWorker::rw_shmem_slot, RegisteredBgWorker::rw_worker, SIGUSR1, slist_container, slist_foreach_modify, and BackgroundWorkerArray::slot.

Referenced by PostmasterStateMachine().

◆ ReportBackgroundWorkerExit()

void ReportBackgroundWorkerExit ( slist_mutable_iter * cur )

Definition at line 483 of file bgworker.c.

 {
     RegisteredBgWorker *rw;
     BackgroundWorkerSlot *slot;
     int         notify_pid;
  
     rw = slist_container(RegisteredBgWorker, rw_lnode, cur->cur);
  
     Assert(rw->rw_shmem_slot < max_worker_processes);
     slot = &BackgroundWorkerData->slot[rw->rw_shmem_slot];
     slot->pid = rw->rw_pid;
     notify_pid = rw->rw_worker.bgw_notify_pid;
  
     /*
      * If this worker is slated for deregistration, do that before notifying
      * the process which started it.  Otherwise, if that process tries to
      * reuse the slot immediately, it might not be available yet.  In theory
      * that could happen anyway if the process checks slot->pid at just the
      * wrong moment, but this makes the window narrower.
      */
     if (rw->rw_terminate ||
         rw->rw_worker.bgw_restart_time == BGW_NEVER_RESTART)
         ForgetBackgroundWorker(cur);
  
     if (notify_pid != 0)
         kill(notify_pid, SIGUSR1);
 }

References Assert(), BackgroundWorkerData, BGW_NEVER_RESTART, BackgroundWorker::bgw_notify_pid, BackgroundWorker::bgw_restart_time, cur, ForgetBackgroundWorker(), kill, max_worker_processes, BackgroundWorkerSlot::pid, RegisteredBgWorker::rw_pid, RegisteredBgWorker::rw_shmem_slot, RegisteredBgWorker::rw_terminate, RegisteredBgWorker::rw_worker, SIGUSR1, slist_container, and BackgroundWorkerArray::slot.

Referenced by CleanupBackgroundWorker().

◆ ReportBackgroundWorkerPID()

void ReportBackgroundWorkerPID ( RegisteredBgWorker * rw )

Definition at line 464 of file bgworker.c.

 {
     BackgroundWorkerSlot *slot;
  
     Assert(rw->rw_shmem_slot < max_worker_processes);
     slot = &BackgroundWorkerData->slot[rw->rw_shmem_slot];
     slot->pid = rw->rw_pid;
  
     if (rw->rw_worker.bgw_notify_pid != 0)
         kill(rw->rw_worker.bgw_notify_pid, SIGUSR1);
 }

References Assert(), BackgroundWorkerData, BackgroundWorker::bgw_notify_pid, kill, max_worker_processes, BackgroundWorkerSlot::pid, RegisteredBgWorker::rw_pid, RegisteredBgWorker::rw_shmem_slot, RegisteredBgWorker::rw_worker, SIGUSR1, and BackgroundWorkerArray::slot.

Referenced by BackgroundWorkerStateChange(), and do_start_bgworker().

◆ ResetBackgroundWorkerCrashTimes()

void ResetBackgroundWorkerCrashTimes ( void )

Definition at line 582 of file bgworker.c.

 {
     slist_mutable_iter iter;
  
     slist_foreach_modify(iter, &BackgroundWorkerList)
     {
         RegisteredBgWorker *rw;
  
         rw = slist_container(RegisteredBgWorker, rw_lnode, iter.cur);
  
         if (rw->rw_worker.bgw_restart_time == BGW_NEVER_RESTART)
         {
             /*
              * Workers marked BGW_NEVER_RESTART shouldn't get relaunched after
              * the crash, so forget about them.  (If we wait until after the
              * crash to forget about them, and they are parallel workers,
              * parallel_terminate_count will get incremented after we've
              * already zeroed parallel_register_count, which would be bad.)
              */
             ForgetBackgroundWorker(&iter);
         }
         else
         {
             /*
              * The accounting which we do via parallel_register_count and
              * parallel_terminate_count would get messed up if a worker marked
              * parallel could survive a crash and restart cycle. All such
              * workers should be marked BGW_NEVER_RESTART, and thus control
              * should never reach this branch.
              */
             Assert((rw->rw_worker.bgw_flags & BGWORKER_CLASS_PARALLEL) == 0);
  
             /*
              * Allow this worker to be restarted immediately after we finish
              * resetting.
              */
             rw->rw_crashed_at = 0;
  
             /*
              * If there was anyone waiting for it, they're history.
              */
             rw->rw_worker.bgw_notify_pid = 0;
         }
     }
 }

References Assert(), BackgroundWorkerList, BackgroundWorker::bgw_flags, BGW_NEVER_RESTART, BackgroundWorker::bgw_notify_pid, BackgroundWorker::bgw_restart_time, BGWORKER_CLASS_PARALLEL, slist_mutable_iter::cur, ForgetBackgroundWorker(), RegisteredBgWorker::rw_crashed_at, RegisteredBgWorker::rw_worker, slist_container, and slist_foreach_modify.

Referenced by PostmasterStateMachine().

◆ StartBackgroundWorker()

void StartBackgroundWorker ( void )

Definition at line 744 of file bgworker.c.

 {
     sigjmp_buf  local_sigjmp_buf;
     BackgroundWorker *worker = MyBgworkerEntry;
     bgworker_main_type entrypt;
  
     if (worker == NULL)
         elog(FATAL, "unable to find bgworker entry");
  
     IsBackgroundWorker = true;
  
     MyBackendType = B_BG_WORKER;
     init_ps_display(worker->bgw_name);
  
     SetProcessingMode(InitProcessing);
  
     /* Apply PostAuthDelay */
     if (PostAuthDelay > 0)
         pg_usleep(PostAuthDelay * 1000000L);
  
     /*
      * Set up signal handlers.
      */
     if (worker->bgw_flags & BGWORKER_BACKEND_DATABASE_CONNECTION)
     {
         /*
          * SIGINT is used to signal canceling the current action
          */
         pqsignal(SIGINT, StatementCancelHandler);
         pqsignal(SIGUSR1, procsignal_sigusr1_handler);
         pqsignal(SIGFPE, FloatExceptionHandler);
  
         /* XXX Any other handlers needed here? */
     }
     else
     {
         pqsignal(SIGINT, SIG_IGN);
         pqsignal(SIGUSR1, SIG_IGN);
         pqsignal(SIGFPE, SIG_IGN);
     }
     pqsignal(SIGTERM, bgworker_die);
     /* SIGQUIT handler was already set up by InitPostmasterChild */
     pqsignal(SIGHUP, SIG_IGN);
  
     InitializeTimeouts();       /* establishes SIGALRM handler */
  
     pqsignal(SIGPIPE, SIG_IGN);
     pqsignal(SIGUSR2, SIG_IGN);
     pqsignal(SIGCHLD, SIG_DFL);
  
     /*
      * If an exception is encountered, processing resumes here.
      *
      * We just need to clean up, report the error, and go away.
      */
     if (sigsetjmp(local_sigjmp_buf, 1) != 0)
     {
         /* Since not using PG_TRY, must reset error stack by hand */
         error_context_stack = NULL;
  
         /* Prevent interrupts while cleaning up */
         HOLD_INTERRUPTS();
  
         /*
          * sigsetjmp will have blocked all signals, but we may need to accept
          * signals while communicating with our parallel leader.  Once we've
          * done HOLD_INTERRUPTS() it should be safe to unblock signals.
          */
         BackgroundWorkerUnblockSignals();
  
         /* Report the error to the parallel leader and the server log */
         EmitErrorReport();
  
         /*
          * Do we need more cleanup here?  For shmem-connected bgworkers, we
          * will call InitProcess below, which will install ProcKill as exit
          * callback.  That will take care of releasing locks, etc.
          */
  
         /* and go away */
         proc_exit(1);
     }
  
     /* We can now handle ereport(ERROR) */
     PG_exception_stack = &local_sigjmp_buf;
  
     /*
      * Create a per-backend PGPROC struct in shared memory, except in the
      * EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
      * this before we can use LWLocks (and in the EXEC_BACKEND case we already
      * had to do some stuff with LWLocks).
      */
 #ifndef EXEC_BACKEND
     InitProcess();
 #endif
  
     /*
      * Early initialization.
      */
     BaseInit();
  
     /*
      * Look up the entry point function, loading its library if necessary.
      */
     entrypt = LookupBackgroundWorkerFunction(worker->bgw_library_name,
                                              worker->bgw_function_name);
  
     /*
      * Note that in normal processes, we would call InitPostgres here.  For a
      * worker, however, we don't know what database to connect to, yet; so we
      * need to wait until the user code does it via
      * BackgroundWorkerInitializeConnection().
      */
  
     /*
      * Now invoke the user-defined worker code
      */
     entrypt(worker->bgw_main_arg);
  
     /* ... and if it returns, we're done */
     proc_exit(0);
 }

References B_BG_WORKER, BackgroundWorkerUnblockSignals(), BaseInit(), BackgroundWorker::bgw_flags, BackgroundWorker::bgw_function_name, BackgroundWorker::bgw_library_name, BackgroundWorker::bgw_main_arg, BackgroundWorker::bgw_name, BGWORKER_BACKEND_DATABASE_CONNECTION, bgworker_die(), elog(), EmitErrorReport(), error_context_stack, FATAL, FloatExceptionHandler(), HOLD_INTERRUPTS, init_ps_display(), InitializeTimeouts(), InitProcess(), InitProcessing, IsBackgroundWorker, LookupBackgroundWorkerFunction(), MyBackendType, MyBgworkerEntry, PG_exception_stack, pg_usleep(), PostAuthDelay, pqsignal(), proc_exit(), procsignal_sigusr1_handler(), SetProcessingMode, SIG_DFL, SIG_IGN, SIGCHLD, SIGHUP, SIGPIPE, SIGUSR1, SIGUSR2, and StatementCancelHandler().

Referenced by do_start_bgworker().

Variable Documentation

◆ BackgroundWorkerList

PGDLLIMPORT slist_head BackgroundWorkerList

extern

Definition at line 42 of file bgworker.c.

Referenced by BackgroundWorkerShmemInit(), BackgroundWorkerStateChange(), BackgroundWorkerStopNotifications(), CleanupBackgroundWorker(), DetermineSleepTime(), FindRegisteredWorkerBySlotNumber(), ForgetUnstartedBackgroundWorkers(), HandleChildCrash(), maybe_start_bgworkers(), RegisterBackgroundWorker(), and ResetBackgroundWorkerCrashTimes().

Data Structures

Macros

Typedefs

Functions

Variables