Greenplum数据库源码学习——BackgroundWorker框架

待我称王封你为后i 2022-09-04 09:53 243阅读 0赞

## BackgroundWorker框架 ##

在Postmaster.c有用于存放BackgroundWorker类型进程信息的结构体PMAuxProcList，其中包含的进程有：ftsprobe process、global deadlock detector process、dtx recovery process、stats sender process、sweeper process、perfmon process、ic proxy process。

Static BackgroundWorker PMAuxProcList[MaxPMAuxProc] = { 
    	{ "ftsprobe process",
    	 BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION,
    	 BgWorkerStart_DtxRecovering, /* no need to wait dtx recovery */
    	 0, /* restart immediately if ftsprobe exits with non-zero code */
    	 FtsProbeMain, { 0}, { 0}, 0, 0,
    	 FtsProbeStartRule},
    	{ "global deadlock detector process",
    	 BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION,
    	 BgWorkerStart_RecoveryFinished,
    	 0, /* restart immediately if gdd exits with non-zero code */
    	 GlobalDeadLockDetectorMain, { 0}, { 0}, 0, 0,
    	 GlobalDeadLockDetectorStartRule},
    	{ "dtx recovery process",
    	 BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION,
    	 BgWorkerStart_DtxRecovering, /* no need to wait dtx recovery */
    	 0, /* restart immediately if dtx recovery process exits with non-zero code */
    	 DtxRecoveryMain, { 0}, { 0}, 0, 0,
    	 DtxRecoveryStartRule},
    	 ...
    }

### BackgroundWorker类型进程信息 ###

我们通过BackgroundWorker结构体来看看其存储了进程哪里信息：1.进程名 2. 后台进程标记 3. 后台进程开始时间 4. 后台进程重启延时 5. 后台进程主函数 6. 后台进程库名 7. 后台进程函数名 8. 后台进程参数 9. 后台进程在启动/停止时需要通知的进程的pid 10. 后台进程启动规则

/* src/include/postmaster/bgworker.h */
    typedef struct BackgroundWorker
    { 
    	char		bgw_name[BGW_MAXLEN];
    	int			bgw_flags;
    	BgWorkerStartTime bgw_start_time;
    	int			bgw_restart_time;		/* in seconds, or BGW_NEVER_RESTART */
    	bgworker_main_type bgw_main;
    	char		bgw_library_name[BGW_MAXLEN];	/* only if bgw_main is NULL */
    	char		bgw_function_name[BGW_MAXLEN];	/* only if bgw_main is NULL */
    	Datum		bgw_main_arg;
    	pid_t		bgw_notify_pid; /* SIGUSR1 this backend on start/stop */
    	bgworker_start_rule bgw_start_rule; /* false: never be started */
    } BackgroundWorker;

以ftsprobe process为例来说明以上信息，FTS(Fault Tolerance Service)是greenplum提供的对于子节点的故障检测与恢复的服务。FTS是一个隶属于master的子进程，通过定期轮询每个primary的状态来获取每个primary-mirror组的状态。该进程只在master上存在，进程名为ftsprobe process。  
![在这里插入图片描述][7798e0140784401391f6306c02bc0de9.png]  
从上面的分析可以看出，FTS的进程名为ftsprobe process，后台进程标记为BGWORKER\_SHMEM\_ACCESS和BGWORKER\_BACKEND\_DATABASE\_CONNECTION，也就是FTS进程可以访问后台进程共享内存，可以连接数据库。

{ "ftsprobe process",
    	 BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION,
    	 BgWorkerStart_DtxRecovering, /* no need to wait dtx recovery */
    	 0, /* restart immediately if ftsprobe exits with non-zero code 如果ftsprobe返回非零值，立刻重启 */
    	 FtsProbeMain, { 0}, { 0}, 0, 0,
    	 FtsProbeStartRule},

后台进程启动时机由下面的枚举类型标识，BgWorkerStart\_DtxRecovering意味着进程可以在postmaster启动后，在分布式事务恢复前启动。这里的FTS的进程就是这样的进程。

typedef enum { 
    	BgWorkerStart_PostmasterStart,
    	BgWorkerStart_DtxRecovering,
    	BgWorkerStart_ConsistentState,
    	BgWorkerStart_RecoveryFinished
    } BgWorkerStartTime;

bgw\_notify\_pid为后台进程在启动/停止时需要通知的进程的pid，这里可以看到FTS进程这一项为0。  
FTS进程后台进程启动规则为FtsProbeStartRule函数，如下所示

bool FtsProbeStartRule(Datum main_arg) { 
    	/* we only start fts probe on master when -E is specified */
    	if (IsUnderMasterDispatchMode())
    		return true;                 // 启动FTS后台进程
    	return false;                    // 不启动FTS后台进程
    }

注册后台进程信息结构体如下所示，注册后台进程时需要将BackgroundWorker信息结构体注册为RegisteredBgWorker信息结构体。

slist_head	BackgroundWorkerList = SLIST_STATIC_INIT(BackgroundWorkerList);
    /* List of background workers, private to postmaster. */
    typedef struct RegisteredBgWorker { 
    	BackgroundWorker rw_worker; /* its registry entry */
    	struct bkend *rw_backend;	/* its BackendList entry, or NULL */
    	pid_t		rw_pid;			/* 0 if not running */
    	int			rw_child_slot;
    	TimestampTz rw_crashed_at;	/* if not 0, time it last crashed */
    	int			rw_shmem_slot;
    	bool		rw_terminate;
    	slist_node	rw_lnode;		/* list link */
    } RegisteredBgWorker;

### 注册后台进程 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70]  
BackgroundWorkerList是私有内存中的postmaster的注册后台进程的列表`slist_head BackgroundWorkerList = SLIST_STATIC_INIT(BackgroundWorkerList)`。postmaster在启动时会调用load\_auxiliary\_libraries注册后台进程。

void load_auxiliary_libraries(void) { 
    	BackgroundWorker *worker;
    	slist_iter iter;
    	int	i;
    	bool registered;
    	/* load all auxiliary workers */
    	for (i = 0; i < MaxPMAuxProc; i++) { 
    		worker = &PMAuxProcList[i];
    		if (worker->bgw_start_rule && !worker->bgw_start_rule(worker->bgw_main_arg))
    			continue;
    		/* skip already registered worker */
    		registered = false;
    		slist_foreach(iter, &BackgroundWorkerList) { 
    			RegisteredBgWorker *rw;
    			rw = slist_container(RegisteredBgWorker, rw_lnode, iter.cur);
    			if (!strcmp(rw->rw_worker.bgw_name, worker->bgw_name) && rw->rw_worker.bgw_main == worker->bgw_main && rw->rw_worker.bgw_start_rule == worker->bgw_start_rule)
    				registered = true;
    		}
    		if (registered)
    			continue;
    		RegisterBackgroundWorker(worker); // 调用RegisterBackgroundWorker函数注册该后台进程任务
    	}
    }

RegisterBackgroundWorker函数将BackgroundWorker信息结构体注册为RegisteredBgWorker信息结构体，就是向BackgroundWorkerList链表中注册。

void RegisterBackgroundWorker(BackgroundWorker *worker) { 
    	RegisteredBgWorker *rw;
    	bool auxworker = false;
    	static int	numworkers = 0;
    	if (!IsUnderPostmaster)
    		ereport(LOG, (errmsg("registering background worker \"%s\"", worker->bgw_name)));
    	auxworker = isAuxiliaryBgWorker(worker);
    	if (!process_shared_preload_libraries_in_progress && !auxworker) { 
    		if (!IsUnderPostmaster)
    			ereport(LOG, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("background worker \"%s\": must be registered in shared_preload_libraries", worker->bgw_name)));
    		return;
    	}
    	if (!SanityCheckBackgroundWorker(worker, LOG))
    		return;
    	if (worker->bgw_notify_pid != 0) { 
    		ereport(LOG, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("background worker \"%s\": only dynamic background workers can request notification", worker->bgw_name)));
    		return;
    	}
    	if (!auxworker && ++numworkers > max_worker_processes - MaxPMAuxProc) { 
    		ereport(LOG,(errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED),errmsg("too many background workers"),errdetail_plural("Up to %d background worker can be registered with the current settings.","Up to %d background workers can be registered with the current settings.",max_worker_processes,max_worker_processes),errhint("Consider increasing the configuration parameter \"max_worker_processes\".")));
    		return;
    	}

注册后台进程时需要将BackgroundWorker信息结构体注册为RegisteredBgWorker信息结构体，如下就是向BackgroundWorkerList链表中注册的过程。

/* 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;
    	}
    	rw->rw_worker = *worker;
    	rw->rw_backend = NULL;
    	rw->rw_pid = 0;
    	rw->rw_child_slot = 0;
    	rw->rw_crashed_at = 0;
    	rw->rw_terminate = false;
    	slist_push_head(&BackgroundWorkerList, &rw->rw_lnode);
    }

### 后台进程共享内存初始化 ###

共享内存中的BackgroundWorkerSlots可以通过BackgroundWorkerArray由postmaster和常规backend访问。

static BackgroundWorkerArray *BackgroundWorkerData;
    typedef struct BackgroundWorkerArray { 
    	int			total_slots;
    	BackgroundWorkerSlot slot[FLEXIBLE_ARRAY_MEMBER];
    } BackgroundWorkerArray;
    typedef struct BackgroundWorkerSlot { 
    	bool		in_use;
    	bool		terminate;
    	pid_t		pid;			/* InvalidPid = not started yet; 0 = dead */
    	uint64		generation;		/* incremented when slot is recycled */
    	BackgroundWorker worker;
    } BackgroundWorkerSlot;

in\_use标识符用于在postmaster和其他backend移交访问权。当in\_use是false，postmaster会忽略整个slot，但是postmaster还是会去读in\_use字段，在这种情况下，常规backend可能会修复该slot。一旦backend将in\_use设置为true，slot将由postmaster管理了。因此，backend必须在将in\_use标识为true之前完全初始化slot，并插入write memory barrier。但是，由postmaster访问时，不能使用锁，甚至是spinlock，因为如果共享内存corrupted，可能会让其crash或wedged，这种后果是不被允许的。所以，我们需要无锁协议来协调对共享内存中的BackgroundWorkerSlots的访问。  
作为异常情况，即使slot是设置为true，常规backend可能设置slot的terminate标识符，告诉postmaster不去重启该后端进程。一旦后端worker不再运行，slot可以释放。  
backend之间对BackgroundWorkerSlots的访问也需要协调。任何需要修复slot的backend需要以排他模式获取BackgroundWorkerLock。backend需要读取数据则需要以共享模式获取BackgroundWorkerLock。

BackgroundWorkerShmemInit后台进程共享内存初始化函数首先调用ShmemInitStruct获取共享内存区域，然后将BackgroundeList中注册后台进程信息拷贝到共享内存BackgroundWorkerData。

void BackgroundWorkerShmemInit(void) { 
    	bool		found;
    	BackgroundWorkerData = ShmemInitStruct("Background Worker Data", BackgroundWorkerShmemSize(), &found);
    	if (!IsUnderPostmaster) { 
    		slist_iter	siter;
    		int			slotno = 0;
    		BackgroundWorkerData->total_slots = max_worker_processes;
    		/* Copy contents of worker list into shared memory. Record the shared * memory slot assigned to each worker. This ensures a 1-to-1 * correspondence betwen the postmaster's private list and the array * in shared memory. */
    		// 将worker list的内容拷贝到共享内存BackgroundWorkerData
    		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);
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70 1]

## BackgroundWorker框架如何启动后台进程 ##

从PostmasterMain函数看起，它是后续fork出来的进程的父进程，在函数执行开始就对postmaster进程的信号处理函数进行了设置，如下代码所示。**SIGCHLD信号是在一个进程终止或者停止时，将SIGCHLD信号发送给其父进程**，按系统默认将忽略此信号，如果父进程希望被告知其子系统的这种状态，则应捕捉此信号。

Postmaster main entry point PostmasterMain
    Pqsignal(SIGCHLD, reaper); // handle child termination

在postmaster进程进入ServerLoop接受业务连接之前，调用了maybe\_start\_bgworker函数将一些后台进程进行了启动。其主要流程如下：

1.  从BackgroundWorkerList取出注册后台进程信息结构体
2.  如果后台进程已经在运行，则继续进行下一次从BackgroundWorkerList取出注册后台进程信息结构体
3.  如果后台进程被标记为death，则进行情况工作，并从BackgroundWorkerList中移除，继续进行下一次从BackgroundWorkerList取出注册后台进程信息结构体
4.  如果后台进程crashed，决策是否将其重启，是否等待一段重启时间，如果使用了通知机制，向需要通知的进程发送SIGUSR1。继续进行下一次从BackgroundWorkerList取出注册后台进程信息结构体
5.  如果后台进程需要启动，则调用do\_start\_bgworker函数启动后台进程。

static void maybe_start_bgworker(void){ 
    	slist_mutable_iter iter;
    	TimestampTz now = 0;
    	/* During crash recovery, we have no need to be called until the state transition out of recovery. */
    	if (FatalError) {   // 如果FatalError为True，则目前数据库处于崩溃恢复状态，暂时不需要启动后台进程
    		StartWorkerNeeded = false;
    		HaveCrashedWorker = false;
    		return;
    	}
    	/* Don't need to be called again unless we find a reason for it below */
    	StartWorkerNeeded = false;
    	HaveCrashedWorker = false;
    	slist_foreach_modify(iter, &BackgroundWorkerList) { 	
    		RegisteredBgWorker *rw;
    		rw = slist_container(RegisteredBgWorker, rw_lnode, iter.cur);
    		/* ignore if already running */
    		if (rw->rw_pid != 0) continue;
    		/* if marked for death, clean up and remove from list */
    		if (rw->rw_terminate) { 
    			ForgetBackgroundWorker(&iter); continue;
    		}
    		/* If this worker has crashed previously, maybe it needs to be restarted (unless on registration it specified it doesn't want to be restarted at all). Check how long ago did a crash last happen. If the last crash is too recent, don't start it right away; let it be restarted once enough time has passed. */
    		if (rw->rw_crashed_at != 0) { 
    			if (rw->rw_worker.bgw_restart_time == BGW_NEVER_RESTART) { 
    				int			notify_pid;
    				notify_pid = rw->rw_worker.bgw_notify_pid;
    				ForgetBackgroundWorker(&iter);
    				/* Report worker is gone now. */
    				if (notify_pid != 0) kill(notify_pid, SIGUSR1);
    				continue;
    			}
    			/* read system time only when needed */
    			if (now == 0)
    				now = GetCurrentTimestamp();
    			if (!TimestampDifferenceExceeds(rw->rw_crashed_at, now, rw->rw_worker.bgw_restart_time * 1000)){ 
    				/* Set flag to remember that we have workers to start later */
    				HaveCrashedWorker = true; continue;
    			}
    		}
    		if (bgworker_should_start_now(rw->rw_worker.bgw_start_time)){ 
    			if (!bgworker_should_start_mpp(&rw->rw_worker))
    				continue;
    			/* reset crash time before trying to start worker */
    			rw->rw_crashed_at = 0;
    			/* Try to start the worker. * On failure, give up processing workers for now, but set StartWorkerNeeded so we'll come back here on the next iteration of ServerLoop to try again. (We don't want to wait, because there might be additional ready-to-run workers.) We could set HaveCrashedWorker as well, since this worker is now marked crashed, but there's no need because the next run of this function will do that. */
    			if (!do_start_bgworker(rw)){ 
    				StartWorkerNeeded = true;
    				return;
    			}
    			/* Quit, but have ServerLoop call us again to look for additional ready-to-run workers. There might not be any, but we'll find out the next time we run. */
    			StartWorkerNeeded = true;
    			return;
    		}
    	}
    }

maybe\_start\_bgworker(postmaster.c) --> do\_start\_bgworker(postmaster.c)  
“starting background worker process ””dtx recovery process”””,0,”postmaster.c”,6147  
“starting background worker process ””ftsprobe process”””,0,”postmaster.c”,6147  
do\_start\_bgworker函数首先如果后台进程设置了BGWORKER\_BACKEND\_DATABASE\_CONNECTION标志，需要调用**assign\_backendlist\_entry函数（该函数分配Backend结构体给需要连接的后台工作进程，但是不将其加入后台进程backend列表）**。如何处理fork的子进程可以参考postmaster fork postgres子进程的过程。

static bool do_start_bgworker(RegisteredBgWorker *rw) { 
    	pid_t		worker_pid;
    	Assert(rw->rw_pid == 0);
    	/* If necessary, allocate and assign the Backend element. Note we must do this before forking, so that we can handle out of memory properly. Treat failure as though the worker had crashed. That way, the postmaster will wait a bit before attempting to start it again; if it tried again right away, most likely it'd find itself repeating the out-of-memory or fork failure condition. If not connected, we don't need a Backend element, but we still need a PMChildSlot. */
    	if (rw->rw_worker.bgw_flags & BGWORKER_BACKEND_DATABASE_CONNECTION) { 
    		if (!assign_backendlist_entry(rw)) { 
    			rw->rw_crashed_at = GetCurrentTimestamp();
    			return false;
    		}
    	}
    	else
    		rw->rw_child_slot = MyPMChildSlot = AssignPostmasterChildSlot();
    	ereport(LOG,(errmsg("starting background worker process \"%s\"",rw->rw_worker.bgw_name)));
    #ifdef EXEC_BACKEND
    	switch ((worker_pid = bgworker_forkexec(rw->rw_shmem_slot)))
    #else
    	switch ((worker_pid = fork_process()))
    #endif
    	{ 
    		case -1:
    			/* in postmaster, fork failed ... */
    			ereport(LOG, (errmsg("could not fork worker process: %m")));
    			/* undo what assign_backendlist_entry did */
    			ReleasePostmasterChildSlot(rw->rw_child_slot);
    			rw->rw_child_slot = 0;
    			if (rw->rw_backend) free(rw->rw_backend);
    			rw->rw_backend = NULL;
    			/* mark entry as crashed, so we'll try again later */
    			rw->rw_crashed_at = GetCurrentTimestamp();
    			break;
    #ifndef EXEC_BACKEND
    		case 0:
    			/* in postmaster child ... */   // 子进程中
    			/* Close the postmaster's sockets */
    			ClosePostmasterPorts(false);
    			/* Lose the postmaster's on-exit routines */
    			on_exit_reset();
    			/* Do NOT release postmaster's working memory context */
    			MyBgworkerEntry = &rw->rw_worker;
    			StartBackgroundWorker();
    			exit(1);			/* should not get here */
    			break;
    #endif
    		default:
    			/* in postmaster, fork successful ... */  // postmaster进程中
    			rw->rw_pid = worker_pid;
    			if (rw->rw_backend) rw->rw_backend->pid = rw->rw_pid;
    			ReportBackgroundWorkerPID(rw);
    			if (rw->rw_backend){ 
    				/* add new worker to lists of backends */
    				dlist_push_head(&BackendList, &rw->rw_backend->elem);
    #ifdef EXEC_BACKEND
    				ShmemBackendArrayAdd(rw->rw_backend);
    #endif
    			}
    			return true;
    	}
    	return false;
    }

StartBackgroundWorker函数用于启动后台进程

void StartBackgroundWorker(void) { 
    	sigjmp_buf	local_sigjmp_buf;
    	char		buf[MAXPGPATH];
    	BackgroundWorker *worker = MyBgworkerEntry;
    	bgworker_main_type entrypt;
    	if (worker == NULL) elog(FATAL, "unable to find bgworker entry");
    	/* we are a postmaster subprocess now */
    	IsUnderPostmaster = true;
    	IsBackgroundWorker = true;
    	/* reset MyProcPid */
    	MyProcPid = getpid();
    	/* record Start Time for logging */
    	MyStartTime = time(NULL);
    	/* Identify myself via ps */
    	snprintf(buf, MAXPGPATH, "bgworker: %s", worker->bgw_name);
    	init_ps_display(buf, "", "", "");
    	/* If we're not supposed to have shared memory access, then detach from shared memory. If we didn't request shared memory access, the postmaster won't force a cluster-wide restart if we exit unexpectedly, so we'd better make sure that we don't mess anything up that would require that sort of cleanup. */
    	if ((worker->bgw_flags & BGWORKER_SHMEM_ACCESS) == 0){ 
    		dsm_detach_all();
    		PGSharedMemoryDetach();
    	}
    	SetProcessingMode(InitProcessing);
    	/* Apply PostAuthDelay */
    	if (PostAuthDelay > 0) pg_usleep(PostAuthDelay * 1000000L);
    	/* If possible, make this process a group leader, so that the postmaster can signal any child processes too. */
    #ifdef HAVE_SETSID
    	if (setsid() < 0)
    		elog(FATAL, "setsid() failed: %m");
    #endif
    	/* 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, bgworker_sigusr1_handler);
    		pqsignal(SIGFPE, SIG_IGN);
    	}
    	pqsignal(SIGTERM, bgworker_die);
    	pqsignal(SIGHUP, SIG_IGN);
    	pqsignal(SIGQUIT, bgworker_quickdie);
    	InitializeTimeouts();		/* establishes SIGALRM handler */
    	pqsignal(SIGPIPE, SIG_IGN);
    	pqsignal(SIGUSR2, SIG_IGN);
    	pqsignal(SIGCHLD, SIG_DFL);
    
    	/* If an exception is encountered, processing resumes here. See notes in postgres.c about the design of this coding. */
    	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();
    		/* Report the error to 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;
    	/* If the background worker request shared memory access, set that up now; else, detach all shared memory segments. */
    	if (worker->bgw_flags & BGWORKER_SHMEM_ACCESS){ 
    		/* Early initialization. Some of this could be useful even for background workers that aren't using shared memory, but they can call the individual startup routines for those subsystems if needed. */
    		BaseInit();
    		/* 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
    	}
    
        // 调用后台进程需要执行的函数
    	/* If bgw_main is set, we use that value as the initial entrypoint. * However, if the library containing the entrypoint wasn't loaded at * postmaster startup time, passing it as a direct function pointer is not * possible. To work around that, we allow callers for whom a function * pointer is not available to pass a library name (which will be loaded, * if necessary) and a function name (which will be looked up in the named * library). */
    	if (worker->bgw_main != NULL)
    		entrypt = worker->bgw_main;
    	else
    		entrypt = (bgworker_main_type) load_external_function(worker->bgw_library_name, worker->bgw_function_name, true, NULL);
    
    	/* 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);
    }

### reaper处理后台进程终止或者停止 ###

Reaper signal handler to cleanup after a child process dies.  
“DEBUG4”,”00000”,”reaping dead processes”,0,”postmaster.c”,3170

static void reaper(SIGNAL_ARGS) { 
    	int			save_errno = errno;
    	int			pid;			/* process id of dead child process */
    	int			exitstatus;		/* its exit status */
    	PG_SETMASK(&BlockSig);
    	ereport(DEBUG4, (errmsg_internal("reaping dead processes")));

waitpid（pid\_t waitpid(pid\_t pid,int \* status,int options)）会暂时停止目前进程的执行，直到有信号来到或子进程结束。如果在调用 waitpid()时子进程已经结束,则 waitpid()会立即返回子进程结束状态值。 子进程的结束状态值会由参数 status 返回,而子进程的进程识别码也会一起返回。如果不在意结束状态值,则参数 status 可以设成 NULL。参数 pid 为欲等待的子进程识别码,其他数值意义如下:

*  pid<-1 等待进程组识别码为 pid 绝对值的任何子进程。
 *  pid=-1 等待任何子进程,相当于 wait()。
 *  pid=0 等待进程组识别码与目前进程相同的任何子进程。
 *  pid>0 等待任何子进程识别码为 pid 的子进程。  
    参数options提供了一些额外的选项来控制waitpid，参数 option 可以为 0 或可以用"|"运算符把它们连接起来使用，比如：  
    ret=waitpid(-1,NULL,WNOHANG | WUNTRACED);如果我们不想使用它们，也可以把options设为0，如ret=waitpid(-1,NULL,0);WNOHANG 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若结束，则返回该子进程的ID。WUNTRACED 若子进程进入暂停状态，则马上返回，但子进程的结束状态不予以理会。WIFSTOPPED(status)宏确定返回值是否对应与一个暂停子进程。  
    子进程的结束状态返回后存于 status,底下有几个宏可判别结束情况:
 *  WIFEXITED(status)如果若为正常结束子进程返回的状态，则为真；对于这种情况可执行WEXITSTATUS(status)，取子进程传给exit或\_eixt的低8位。
 *  WEXITSTATUS(status)取得子进程 exit()返回的结束代码,一般会先用 WIFEXITED 来判断是否正常结束才能使用此宏。
 *  WIFSIGNALED(status)若为异常结束子进程返回的状态，则为真；对于这种情况可执行WTERMSIG(status)，取使子进程结束的信号编号。
 *  WTERMSIG(status) 取得子进程因信号而中止的信号代码,一般会先用 WIFSIGNALED 来判断后才使用此宏。
 *  WIFSTOPPED(status) 若为当前暂停子进程返回的状态，则为真；对于这种情况可执行WSTOPSIG(status)，取使子进程暂停的信号编号。
 *  WSTOPSIG(status) 取得引发子进程暂停的信号代码,一般会先用 WIFSTOPPED 来判断后才使用此宏。  
    如果执行成功则返回子进程识别码(PID) ,如果有错误发生则返回返回值-1。失败原因存于 errno 中。

while ((pid = waitpid(-1, &exitstatus, WNOHANG)) > 0){ 
    		/* Check if this child was a startup process. */
    		if (pid == StartupPID) { 
    			StartupPID = 0;
    			/* Startup process exited in response to a shutdown request (or it completed normally regardless of the shutdown request). */
    			if (Shutdown > NoShutdown && (EXIT_STATUS_0(exitstatus) || EXIT_STATUS_1(exitstatus))){ 
    				StartupStatus = STARTUP_NOT_RUNNING;
    				pmState = PM_WAIT_BACKENDS;
    				/* PostmasterStateMachine logic does the rest */
    				continue;
    			}
    			/* Unexpected exit of startup process (including FATAL exit) during PM_STARTUP is treated as catastrophic. There are no other processes running yet, so we can just exit. */
    			if (pmState == PM_STARTUP && !EXIT_STATUS_0(exitstatus)){ 
    				LogChildExit(LOG, _("startup process"),pid, exitstatus);
    				ereport(LOG,(errmsg("aborting startup due to startup process failure")));
    				ExitPostmaster(1);
    			}
    			/* * After PM_STARTUP, any unexpected exit (including FATAL exit) of * the startup process is catastrophic, so kill other children, * and set StartupStatus so we don't try to reinitialize after * they're gone. Exception: if StartupStatus is STARTUP_SIGNALED, * then we previously sent the startup process a SIGQUIT; so * that's probably the reason it died, and we do want to try to * restart in that case. */
    			if (!EXIT_STATUS_0(exitstatus)){ 
    				if (StartupStatus == STARTUP_SIGNALED)
    					StartupStatus = STARTUP_NOT_RUNNING;
    				else
    					StartupStatus = STARTUP_CRASHED;
    				HandleChildCrash(pid, exitstatus, _("startup process"));
    				continue;
    			}
    
    			/* * Startup succeeded, commence normal operations */
    			StartupStatus = STARTUP_NOT_RUNNING;
    			FatalError = false;
    			Assert(AbortStartTime == 0);
    			ReachedNormalRunning = true;
    			pmState = PM_RUN;
    
    			/* * Crank up the background tasks, if we didn't do that already * when we entered consistent recovery state. It doesn't matter * if this fails, we'll just try again later. */
    			if (CheckpointerPID == 0)
    				CheckpointerPID = StartCheckpointer();
    			if (BgWriterPID == 0)
    				BgWriterPID = StartBackgroundWriter();
    			if (WalWriterPID == 0)
    				WalWriterPID = StartWalWriter();
    
    			/* * Likewise, start other special children as needed. In a restart * situation, some of them may be alive already. */
    			if (!IsBinaryUpgrade && AutoVacuumingActive() && AutoVacPID == 0)
    				AutoVacPID = StartAutoVacLauncher();
    			if (XLogArchivingActive() && PgArchPID == 0)
    				PgArchPID = pgarch_start();
    			if (PgStatPID == 0)
    				PgStatPID = pgstat_start();
    
    			/* workers may be scheduled to start now */
    			maybe_start_bgworker();
    
    			/* at this point we are really open for business */
    			{ 
    				char version[512];
    
    				strlcpy(version, PG_VERSION_STR " compiled on " __DATE__ " " __TIME__,
    						sizeof(version));
    
    #ifdef USE_ASSERT_CHECKING
    				strlcat(version, " (with assert checking)", sizeof(version));
    #endif
    				ereport(LOG,(errmsg("%s", version)));
    
    				ereport(LOG,
    						(errmsg("database system is ready to accept connections"),
    						 errdetail("%s",version)));
    
    				PMAcceptingConnectionsStartTime = (pg_time_t) time(NULL);
    			}
    
    			continue;
    		}
    
    		/* * Was it the bgwriter? Normal exit can be ignored; we'll start a new * one at the next iteration of the postmaster's main loop, if * necessary. Any other exit condition is treated as a crash. */
    		if (pid == BgWriterPID)
    		{ 
    			BgWriterPID = 0;
    			if (!EXIT_STATUS_0(exitstatus))
    				HandleChildCrash(pid, exitstatus,
    								 _("background writer process"));
    			continue;
    		}
    
    		/* * Was it the checkpointer? */
    		if (pid == CheckpointerPID)
    		{ 
    			CheckpointerPID = 0;
    			if (EXIT_STATUS_0(exitstatus) && pmState == PM_SHUTDOWN){ 
    				/* * OK, we saw normal exit of the checkpointer after it's been * told to shut down. We expect that it wrote a shutdown * checkpoint. (If for some reason it didn't, recovery will * occur on next postmaster start.) * * At this point we should have no normal backend children * left (else we'd not be in PM_SHUTDOWN state) but we might * have dead_end children to wait for. * * If we have an archiver subprocess, tell it to do a last * archive cycle and quit. Likewise, if we have walsender * processes, tell them to send any remaining WAL and quit. */
    				Assert(Shutdown > NoShutdown);
    
    				/* Waken archiver for the last time */
    				if (PgArchPID != 0)
    					signal_child(PgArchPID, SIGUSR2);
    
    				/* * Waken walsenders for the last time. No regular backends * should be around anymore. */
    				SignalChildren(SIGUSR2);
    
    				pmState = PM_SHUTDOWN_2;
    
    				/* * We can also shut down the stats collector now; there's * nothing left for it to do. */
    				if (PgStatPID != 0)
    					signal_child(PgStatPID, SIGQUIT);
    			}
    			else
    			{ 
    				/* * Any unexpected exit of the checkpointer (including FATAL * exit) is treated as a crash. */
    				HandleChildCrash(pid, exitstatus,
    								 _("checkpointer process"));
    			}
    
    			continue;
    		}
    
    		/* * Was it the wal writer? Normal exit can be ignored; we'll start a * new one at the next iteration of the postmaster's main loop, if * necessary. Any other exit condition is treated as a crash. */
    		if (pid == WalWriterPID)
    		{ 
    			WalWriterPID = 0;
    			if (!EXIT_STATUS_0(exitstatus))
    				HandleChildCrash(pid, exitstatus,
    								 _("WAL writer process"));
    			continue;
    		}
    
    		/* * Was it the wal receiver? If exit status is zero (normal) or one * (FATAL exit), we assume everything is all right just like normal * backends. (If we need a new wal receiver, we'll start one at the * next iteration of the postmaster's main loop.) */
    		if (pid == WalReceiverPID)
    		{ 
    			WalReceiverPID = 0;
    			if (!EXIT_STATUS_0(exitstatus) && !EXIT_STATUS_1(exitstatus))
    				HandleChildCrash(pid, exitstatus,
    								 _("WAL receiver process"));
    			continue;
    		}
    
    		/* * Was it the autovacuum launcher? Normal exit can be ignored; we'll * start a new one at the next iteration of the postmaster's main * loop, if necessary. Any other exit condition is treated as a * crash. */
    		if (pid == AutoVacPID){ 
    			AutoVacPID = 0;
    			if (!EXIT_STATUS_0(exitstatus) && !EXIT_STATUS_1(exitstatus))
    				HandleChildCrash(pid, exitstatus, _("autovacuum launcher process"));
    			continue;
    		}
    
    		/* * Was it the archiver? If so, just try to start a new one; no need * to force reset of the rest of the system. (If fail, we'll try * again in future cycles of the main loop.). Unless we were waiting * for it to shut down; don't restart it in that case, and * PostmasterStateMachine() will advance to the next shutdown step. */
    		if (pid == PgArchPID){ 
    			PgArchPID = 0;
    			if (!EXIT_STATUS_0(exitstatus))
    				LogChildExit(LOG, _("archiver process"),pid, exitstatus);
    			if (XLogArchivingActive() && pmState == PM_RUN)
    				PgArchPID = pgarch_start();
    			continue;
    		}
    
    		/* * Was it the statistics collector? If so, just try to start a new * one; no need to force reset of the rest of the system. (If fail, * we'll try again in future cycles of the main loop.) */
    		if (pid == PgStatPID){ 
    			PgStatPID = 0;
    			if (!EXIT_STATUS_0(exitstatus))
    				LogChildExit(LOG, _("statistics collector process"),pid, exitstatus);
    			if (pmState == PM_RUN || pmState == PM_HOT_STANDBY)
    				PgStatPID = pgstat_start();
    			continue;
    		}
    		/* Was it the system logger? If so, try to start a new one */
    		if (pid == SysLoggerPID){ 
    			SysLoggerPID = 0;
    			/* for safety's sake, launch new logger *first* */
    			SysLoggerPID = SysLogger_Start();
    			if (!EXIT_STATUS_0(exitstatus))
    				LogChildExit(LOG, _("system logger process"), pid, exitstatus);
    			continue;
    		}
    		/* Was it one of our background workers? */
    		if (CleanupBackgroundWorker(pid, exitstatus)){ 
    			/* have it be restarted */
    			HaveCrashedWorker = true;
    			continue;
    		}
    		/* Else do standard backend child cleanup. */
    		CleanupBackend(pid, exitstatus);
    	}							/* loop over pending child-death reports */
    	/* After cleaning out the SIGCHLD queue, see if we have any state changes or actions to make. */
    	PostmasterStateMachine();
    	/* Done with signal handler */
    	PG_SETMASK(&UnBlockSig);
    	errno = save_errno;
    }

reaper同样也会调用maybe\_start\_bgworker函数处理后台进程

[7798e0140784401391f6306c02bc0de9.png]: /images/20220829/91fe1516d593454c95abe76beac217ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70]: /images/20220829/a0337120378d4adf998c3d3c0aa25f0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70 1]: /images/20220829/3c5616dc623e4d10b8be32823855a529.png