PG服务进程（Postgres）——PG进程拥有的私有资源

朱雀 2022-09-12 13:44 227阅读 0赞

## Postmaster创建postgres子进程 ##

Postmaster拥有BackendList后端列表，用于存放标识postgres子进程的Backend。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6IKl5Y-U6I-M_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

static dlist_head BackendList = DLIST_STATIC_INIT(BackendList);
    /* BackendStartup -- start backend process returns: STATUS_ERROR if the fork failed, STATUS_OK otherwise. * Note: if you change this code, also consider StartAutovacuumWorker. */
    static int BackendStartup(Port *port) { 
    	Backend    *bn; /* for backend cleanup */ pid_t		pid;
    	/* Create backend data structure. Better before the fork() so we can handle failure cleanly. */
    	bn = (Backend *) malloc(sizeof(Backend)); if (!bn){  ereport(LOG,(errcode(ERRCODE_OUT_OF_MEMORY),errmsg("out of memory"))); return STATUS_ERROR; }
    	/* Compute the cancel key that will be assigned to this backend. The backend will have its own copy in the forked-off process' value of MyCancelKey, so that it can transmit the key to the frontend. */
    	if (!RandomCancelKey(&MyCancelKey)){  free(bn); ereport(LOG,(errcode(ERRCODE_INTERNAL_ERROR),errmsg("could not generate random cancel key"))); return STATUS_ERROR; }
    	bn->cancel_key = MyCancelKey;
    	/* Pass down canAcceptConnections state */
    	port->canAcceptConnections = canAcceptConnections(BACKEND_TYPE_NORMAL);
    	bn->dead_end = (port->canAcceptConnections != CAC_OK && port->canAcceptConnections != CAC_SUPERUSER);
    	/* Unless it's a dead_end child, assign it a child slot number */
    	if (!bn->dead_end) bn->child_slot = MyPMChildSlot = AssignPostmasterChildSlot();
    	else bn->child_slot = 0;
    	/* Hasn't asked to be notified about any bgworkers yet */
    	bn->bgworker_notify = false;
    #ifdef EXEC_BACKEND
    	pid = backend_forkexec(port);
    #else /* !EXEC_BACKEND */
    	pid = fork_process();
    	if (pid == 0) { 				/* child */
    		free(bn);
    		/* Detangle from postmaster */
    		InitPostmasterChild();
    		/* Close the postmaster's sockets */
    		ClosePostmasterPorts(false);
    		/* Perform additional initialization and collect startup packet */
    		BackendInitialize(port);
    		/* And run the backend */
    		BackendRun(port);
    	}
    #endif /* EXEC_BACKEND */
    	if (pid < 0) { 
    		/* in parent, fork failed */
    		int			save_errno = errno;
    		if (!bn->dead_end) (void) ReleasePostmasterChildSlot(bn->child_slot);
    		free(bn);
    		errno = save_errno;
    		ereport(LOG, (errmsg("could not fork new process for connection: %m")));
    		report_fork_failure_to_client(port, save_errno);
    		return STATUS_ERROR;
    	}
    	/* in parent, successful fork */
    	ereport(DEBUG2,(errmsg_internal("forked new backend, pid=%d socket=%d",(int) pid, (int) port->sock)));
    	/* Everything's been successful, it's safe to add this backend to our list of backends. */
    	bn->pid = pid;
    	bn->bkend_type = BACKEND_TYPE_NORMAL;	/* Can change later to WALSND */
    	dlist_push_head(&BackendList, &bn->elem);
    #ifdef EXEC_BACKEND
    	if (!bn->dead_end) ShmemBackendArrayAdd(bn);
    #endif
    	return STATUS_OK;
    }

AssignPostmasterChildSlot函数为新的postmaster子进程选择未使用的slot，并将其状态设置为ASSIGNED，返回slot number。

/* AssignPostmasterChildSlot - select an unused slot for a new postmaster child process, and set its state to ASSIGNED. Returns a slot number (one to N). * Only the postmaster is allowed to execute this routine, so we need no special locking. */
    int AssignPostmasterChildSlot(void) { 
    	int			slot = PMSignalState->next_child_flag;
    	/* Scan for a free slot. We track the last slot assigned so as not to waste time repeatedly rescanning low-numbered slots. */
    	for (int n = PMSignalState->num_child_flags; n > 0; n--) { 
    		if (--slot < 0) slot = PMSignalState->num_child_flags - 1;
    		if (PMSignalState->PMChildFlags[slot] == PM_CHILD_UNUSED) { 
    			PMSignalState->PMChildFlags[slot] = PM_CHILD_ASSIGNED;
    			PMSignalState->next_child_flag = slot;
    			return slot + 1;
    		}
    	}
    	/* Out of slots ... should never happen, else postmaster.c messed up */
    	elog(FATAL, "no free slots in PMChildFlags array");
    	return 0;					/* keep compiler quiet */
    }

如果PMSignalState->next\_child\_flag为0，进入for循环从PMSignalState->num\_child\_flags数组尾部遍历，–slot为-1小于0，slot更新为PMSignalState->num\_child\_flags数组元素数量-1。如果该slot未使用则使用PM\_CHILD\_ASSIGNED，将PMSignalState->next\_child\_flag赋值为slot，并返回slot+1。  
如果PMSignalState->next\_child\_flag不为0，进入for循环从PMSignalState->num\_child\_flags数组尾部遍历，–slot不小于0。如果该slot未使用则使用PM\_CHILD\_ASSIGNED，将PMSignalState->next\_child\_flag赋值为slot，并返回slot+1。

#### ProcGlobal ####

`PROC_HDR *ProcGlobal`在postmaster已经建立好，后端从fork或EXEC\_BACKEND mechanism中继承出来。

typedef struct PROC_HDR { 
    	/* Array of PGPROC structures (not including dummies for prepared txns) */
    	PGPROC	   *allProcs;
    	/* Array of PGXACT structures (not including dummies for prepared txns) */
    	PGXACT	   *allPgXact;
    	/* Length of allProcs array */
    	uint32		allProcCount;
    	/* Head of list of free PGPROC structures */
    	PGPROC	   *freeProcs;
    	/* Head of list of autovacuum's free PGPROC structures */
    	PGPROC	   *autovacFreeProcs;
    	/* Head of list of bgworker free PGPROC structures */
    	PGPROC	   *bgworkerFreeProcs;
    	/* Head of list of walsender free PGPROC structures */
    	PGPROC	   *walsenderFreeProcs;
    	/* First pgproc waiting for group XID clear */
    	pg_atomic_uint32 procArrayGroupFirst;
    	/* First pgproc waiting for group transaction status update */
    	pg_atomic_uint32 clogGroupFirst;
    	/* WALWriter process's latch */
    	Latch	   *walwriterLatch;
    	/* Checkpointer process's latch */
    	Latch	   *checkpointerLatch;
    	/* Current shared estimate of appropriate spins_per_delay value */
    	int			spins_per_delay;
    	/* The proc of the Startup process, since not in ProcArray */
    	PGPROC	   *startupProc;
    	int			startupProcPid;
    	/* Buffer id of the buffer that Startup process waits for pin on, or -1 */
    	int			startupBufferPinWaitBufId;
    } PROC_HDR;

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6IKl5Y-U6I-M_size_20_color_FFFFFF_t_70_g_se_x_16]

## postgres子进程拥有的资源 ##

### postgres子进程启动 ###

postgres子进程启动流程如下所示：

/* Detangle from postmaster */
    		InitPostmasterChild();
    		/* Close the postmaster's sockets */
    		ClosePostmasterPorts(false);
    		/* Perform additional initialization and collect startup packet */
    		BackendInitialize(port);
    		/* And run the backend */
    		BackendRun(port);

InitPostmasterChild函数用户初始化postmaster子进程的基本环境。将IsUnderPostmaster赋值为true，说明我们是Postmaster子进程。InitProcessGlobals函数设置MyProcPid，MyStartTime\[stamp\], random seeds

/* Initialize the basic environment for a postmaster child Should be called as early as possible after the child's startup. */
    void InitPostmasterChild(void) { 
    	IsUnderPostmaster = true;	/* we are a postmaster subprocess now */
    	InitProcessGlobals();
    	/* make sure stderr is in binary mode before anything can possibly be written to it, in case it's actually the syslogger pipe, so the pipe chunking protocol isn't disturbed. Non-logpipe data gets translated on redirection (e.g. via pg_ctl -l) anyway. */
    #ifdef WIN32
    	_setmode(fileno(stderr), _O_BINARY);
    #endif
    	/* We don't want the postmaster's proc_exit() handlers */
    	on_exit_reset();
    	/* Initialize process-local latch support */
    	InitializeLatchSupport();
    	MyLatch = &LocalLatchData;
    	InitLatch(MyLatch);
    	/* If possible, make this process a group leader, so that the postmaster can signal any child processes too. Not all processes will have children, but for consistency we make all postmaster child processes do this. */
    #ifdef HAVE_SETSID
    	if (setsid() < 0) elog(FATAL, "setsid() failed: %m");
    #endif
    	/* Request a signal if the postmaster dies, if possible. */
    	PostmasterDeathSignalInit();
    }

BackendInitialize函数初始化一个interactive后端进程，并收集客户初始数据包。初始化libpq，使能向客户端report错误信息。Initialize libpq and enable reporting of ereport errors to the client。建立信号处理函数SIGTERM、SIGQUIT和SIGALRM。

/* BackendInitialize -- initialize an interactive (postmaster-child) backend process, and collect the client's startup packet. returns: nothing. Will not return at all if there's any failure. * Note: this code does not depend on having any access to shared memory. * In the EXEC_BACKEND case, we are physically attached to shared memory * but have not yet set up most of our local pointers to shmem structures. */
    static void BackendInitialize(Port *port) { 
    	int			status;
    	int			ret;
    	char		remote_host[NI_MAXHOST];
    	char		remote_port[NI_MAXSERV];
    	char		remote_ps_data[NI_MAXHOST];
    	
    	MyProcPort = port; /* Save port etc. for ps status */
    	/* PreAuthDelay is a debugging aid for investigating problems in the authentication cycle: it can be set in postgresql.conf to allow time to attach to the newly-forked backend with a debugger. (See also PostAuthDelay, which we allow clients to pass through PGOPTIONS, but it is not honored until after authentication.) */
    	if (PreAuthDelay > 0) pg_usleep(PreAuthDelay * 1000000L);
    	/* This flag will remain set until InitPostgres finishes authentication */
    	ClientAuthInProgress = true;	/* limit visibility of log messages */
    	/* set these to empty in case they are needed before we set them up */
    	port->remote_host = "";
    	port->remote_port = "";
    
    	/* Initialize libpq and enable reporting of ereport errors to the client. Must do this now because authentication uses libpq to send messages. */
    	pq_init();					/* initialize libpq to talk to client */
    	whereToSendOutput = DestRemote; /* now safe to ereport to client */
    
    	/* We arrange to do proc_exit(1) if we receive SIGTERM or timeout while trying to collect the startup packet; while SIGQUIT results in _exit(2). Otherwise the postmaster cannot shutdown the database FAST or IMMED cleanly if a buggy client fails to send the packet promptly. * XXX this is pretty dangerous; signal handlers should not call anything as complex as proc_exit() directly. We minimize the hazard by not keeping these handlers active for longer than we must. However, it seems necessary to be able to escape out of DNS lookups as well as the startup packet reception proper, so we can't narrow the scope further than is done here. * XXX it follows that the remainder of this function must tolerate losing control at any instant. Likewise, any pg_on_exit_callback registered before or during this function must be prepared to execute at any instant between here and the end of this function. Furthermore, affected callbacks execute partially or not at all when a second exit-inducing signal arrives after proc_exit_prepare() decrements on_proc_exit_index. (Thanks to that mechanic, callbacks need not anticipate more than one call.) This is fragile; it ought to instead follow the norm of handling interrupts at selected, safe opportunities. */
    	pqsignal(SIGTERM, process_startup_packet_die);
    	pqsignal(SIGQUIT, process_startup_packet_quickdie);
    	InitializeTimeouts();		/* establishes SIGALRM handler */
    	PG_SETMASK(&StartupBlockSig);
    
    	/* Get the remote host name and port for logging and status display. */
    	remote_host[0] = '\0';
    	remote_port[0] = '\0';
    	if ((ret = pg_getnameinfo_all(&port->raddr.addr, port->raddr.salen, remote_host, sizeof(remote_host), remote_port, sizeof(remote_port), (log_hostname ? 0 : NI_NUMERICHOST) | NI_NUMERICSERV)) != 0) ereport(WARNING, (errmsg_internal("pg_getnameinfo_all() failed: %s", gai_strerror(ret))));
    	if (remote_port[0] == '\0') snprintf(remote_ps_data, sizeof(remote_ps_data), "%s", remote_host);
    	else snprintf(remote_ps_data, sizeof(remote_ps_data), "%s(%s)", remote_host, remote_port);
    	/* Save remote_host and remote_port in port structure (after this, they will appear in log_line_prefix data for log messages). */
    	port->remote_host = strdup(remote_host);
    	port->remote_port = strdup(remote_port);
    
    	/* And now we can issue the Log_connections message, if wanted */
    	if (Log_connections) { 
    		if (remote_port[0]) ereport(LOG, (errmsg("connection received: host=%s port=%s", remote_host, remote_port)));
    		else ereport(LOG, (errmsg("connection received: host=%s", remote_host)));
    	}
    
    	/* If we did a reverse lookup to name, we might as well save the results * rather than possibly repeating the lookup during authentication. * Note that we don't want to specify NI_NAMEREQD above, because then we'd * get nothing useful for a client without an rDNS entry. Therefore, we * must check whether we got a numeric IPv4 or IPv6 address, and not save * it into remote_hostname if so. (This test is conservative and might * sometimes classify a hostname as numeric, but an error in that * direction is safe; it only results in a possible extra lookup.) */
    	if (log_hostname && ret == 0 && strspn(remote_host, "0123456789.") < strlen(remote_host) && strspn(remote_host, "0123456789ABCDEFabcdef:") < strlen(remote_host)) port->remote_hostname = strdup(remote_host);

开始客户端交互，接收客户端启动数据包，如果status不为STATUS\_OK，则需要退出。显示PS的信息：

*  对于walsender来说 `postgres: walsender <user> <host> <activity>` To achieve that, we pass “walsender” as username and username as dbname
 *  其他 `port->user_name, port->database_name, remote_ps_data, <activity>`

/* Ready to begin client interaction. We will give up and proc_exit(1) * after a time delay, so that a broken client can't hog a connection * indefinitely. PreAuthDelay and any DNS interactions above don't count * against the time limit. * Note: AuthenticationTimeout is applied here while waiting for the * startup packet, and then again in InitPostgres for the duration of any * authentication operations. So a hostile client could tie up the * process for nearly twice AuthenticationTimeout before we kick him off. * Note: because PostgresMain will call InitializeTimeouts again, the * registration of STARTUP_PACKET_TIMEOUT will be lost. This is okay * since we never use it again after this function. */
    	RegisterTimeout(STARTUP_PACKET_TIMEOUT, StartupPacketTimeoutHandler);
    	enable_timeout_after(STARTUP_PACKET_TIMEOUT, AuthenticationTimeout * 1000);
    	/* Receive the startup packet (which might turn out to be a cancel request packet). */
    	status = ProcessStartupPacket(port, false, false);
    	/* Disable the timeout, and prevent SIGTERM/SIGQUIT again. */
    	disable_timeout(STARTUP_PACKET_TIMEOUT, false);
    	PG_SETMASK(&BlockSig);
    	/* Stop here if it was bad or a cancel packet. ProcessStartupPacket already did any appropriate error reporting. */
    	if (status != STATUS_OK) proc_exit(0);
    
    	/* Now that we have the user and database name, we can set the process title for ps. It's good to do this as early as possible in startup. For a walsender, the ps display is set in the following form: * postgres: walsender <user> <host> <activity> * To achieve that, we pass "walsender" as username and username as dbname * to init_ps_display(). XXX: should add a new variant of * init_ps_display() to avoid abusing the parameters like this. */
    	if (am_walsender) init_ps_display(pgstat_get_backend_desc(B_WAL_SENDER), port->user_name, remote_ps_data, update_process_title ? "authentication" : "");
    	else init_ps_display(port->user_name, port->database_name, remote_ps_data, update_process_title ? "authentication" : "");
    }

BackendRun函数先建立argv数组（\[“postgres”, ExtraOptions\]），ExtraOptions是postmaster设置的，子进程fork时拷贝一份。ExtraOptions一般不会有选项。

static void BackendRun(Port *port) { 
    	char	  **av;
    	int			maxac;
    	int			ac;
    	int			i;
    	/* Now, build the argv vector that will be given to PostgresMain. The maximum possible number of commandline arguments that could come from ExtraOptions is (strlen(ExtraOptions) + 1) / 2; see pg_split_opts(). */
    	maxac = 2;					/* for fixed args supplied below */
    	maxac += (strlen(ExtraOptions) + 1) / 2;
    	av = (char **) MemoryContextAlloc(TopMemoryContext,maxac * sizeof(char *));
    	ac = 0;
    	av[ac++] = "postgres";
    	/* Pass any backend switches specified with -o on the postmaster's own command line. We assume these are secure. */
    	pg_split_opts(av, &ac, ExtraOptions);
    	av[ac] = NULL;
    	Assert(ac < maxac);
    	/* Debug: print arguments being passed to backend */
    	ereport(DEBUG3,(errmsg_internal("%s child[%d]: starting with (",progname, (int) getpid())));
    	for (i = 0; i < ac; ++i)
    		ereport(DEBUG3,(errmsg_internal("\t%s", av[i])));
    	ereport(DEBUG3,(errmsg_internal(")")));
    	/* Make sure we aren't in PostmasterContext anymore. (We can't delete it just yet, though, because InitPostgres will need the HBA data.) */
    	MemoryContextSwitchTo(TopMemoryContext);
    	PostgresMain(ac, av, port->database_name, port->user_name);
    }
    
    postmaster支持的-o选项，存放于ExtraOptions中
    			case 'o':
    				/* Other options to pass to the backend on the command line */
    				snprintf(ExtraOptions + strlen(ExtraOptions), sizeof(ExtraOptions) - strlen(ExtraOptions), " %s", optarg);
    				break;

#### MyCancelKey ####

`int32 MyCancelKey;` MyCancelKey是定义在src/backend/utils/init/globals.c中的全局变量。是由postmaster计算出来cancel key，并将其赋值给后端（后端forked-off进程拥有自己的一份MyCancelKey拷贝）。

#### MyProcPid ####

`int MyProcPid;` MyProcPid是定义在src/backend/utils/init/globals.c中的全局变量。是在InitProcessGlobals函数设置为子进程的pid。

#### MyStartTimestamp ####

`TimestampTz MyStartTimestamp;` MyStartTimestamp是定义在src/backend/utils/init/globals.c中的全局变量。是在InitProcessGlobals函数设置为GetCurrentTimestamp()

#### MyStartTime ####

`pg_time_t MyStartTime;` MyStartTime是定义在src/backend/utils/init/globals.c中的全局变量。是在InitProcessGlobals函数设置为timestamptz\_to\_time\_t(MyStartTimestamp)

#### MyLatch ####

Unix实现使用self-pipe trick来克服调用poll（或epoll\_wait）产生的竞争条件并且在信号处理函数中设置全局标志。当一个latch被设置并且当前进程等待它，**通过向pipe中写入一个字节，信号处理函数唤醒WaitLatch中的poll**。信号本身不会中断poll。在poll之前到达的信号不会阻止poll进入sleep状态。pipe上到达的字节会中断poll进入sleep状态，并且会导致poll立刻返回即使信号在poll之前到达。  
当拥有latch的自身进程调用SetLatch，SetLatch会向pipe中写入一个字节。如果其他进程拥有latch，会发生SIGUSR1信号，等待的进程的信号处理函数会向pipe中写入一个字节。

struct Latch *MyLatch = &LocalLatchData; // src/backend/utils/init/globals.c
    static Latch LocalLatchData; // src/backend/utils/init/miscinit.c
    /* Latch structure should be treated as opaque and only accessed through the public functions. It is defined here to allow embedding Latches as part of bigger structs. */
    typedef struct Latch { 
    	sig_atomic_t is_set;
    	bool		is_shared;
    	int			owner_pid;
    } Latch;

InitializeLatchSupport函数初始化process-local latch设施

void InitPostmasterChild(void) { 
    	IsUnderPostmaster = true;	/* we are a postmaster subprocess now */
    	InitProcessGlobals();
    	on_exit_reset(); /* We don't want the postmaster's proc_exit() handlers */
    	/* Initialize process-local latch support */
    	InitializeLatchSupport();
    	MyLatch = &LocalLatchData;
    	InitLatch(MyLatch);
    	PostmasterDeathSignalInit(); /* Request a signal if the postmaster dies, if possible. */
    }
    
    /* Initialize a process-local latch. */
    void InitLatch(Latch *latch) { 
    	latch->is_set = false;
    	latch->owner_pid = MyProcPid;
    	latch->is_shared = false;
    	/* Assert InitializeLatchSupport has been called in this process */
    	Assert(selfpipe_readfd >= 0 && selfpipe_owner_pid == MyProcPid);
    }

#### Port ####

MyProcPort是定义在src/backend/utils/init/globals.c中的全局变量。会在fork出来服务客户端的子进程调用的BackendInitialize函数中使用postmaster父进程创建的port进行初始化。（PostmasterMain–>ServerLoop–>BackendStartup(Port \*port)–>子进程BackendInitialize）

struct Port *MyProcPort;
    static void BackendInitialize(Port *port) { 
    	int			status;
    	int			ret;
    	char		remote_host[NI_MAXHOST];
    	char		remote_port[NI_MAXSERV];
    	char		remote_ps_data[NI_MAXHOST];
    	/* Save port etc. for ps status */
    	MyProcPort = port;

### PostgresMain运行 ###

将PMSignalState->PMChildFlags\[slot\]设置为PM\_CHILD\_ACTIVE，这个结构体在postmaster中能够看到，也就是该后台进程将自己标记位激活状态。

void MarkPostmasterChildActive(void) { 
    	int			slot = MyPMChildSlot;
    	Assert(slot > 0 && slot <= PMSignalState->num_child_flags);
    	slot--;
    	Assert(PMSignalState->PMChildFlags[slot] == PM_CHILD_ASSIGNED);
    	PMSignalState->PMChildFlags[slot] = PM_CHILD_ACTIVE;
    }

#### MyProc ####

在InitProcess中向&ProcGlobal->freeProcs获取procgloballist，并取值赋给MyProc。

PGPROC	   *volatile *procgloballist;
    procgloballist = &ProcGlobal->freeProcs;
    MyProc = *procgloballist;
    if (MyProc != NULL){ 
    		*procgloballist = (PGPROC *) MyProc->links.next;
    ...
    	SHMQueueElemInit(&(MyProc->links));
    	MyProc->waitStatus = STATUS_OK;
    	MyProc->lxid = InvalidLocalTransactionId;
    	MyProc->fpVXIDLock = false;
    	MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
    	MyPgXact->xid = InvalidTransactionId;
    	MyPgXact->xmin = InvalidTransactionId;
    	MyProc->pid = MyProcPid;
    	/* backendId, databaseId and roleId will be filled in later */
    	MyProc->backendId = InvalidBackendId;
    	MyProc->databaseId = InvalidOid;
    	MyProc->roleId = InvalidOid;
    	MyProc->tempNamespaceId = InvalidOid;
    	MyProc->isBackgroundWorker = IsBackgroundWorker;
    	MyPgXact->delayChkpt = false;
    	MyPgXact->vacuumFlags = 0;
    	MyProc->lwWaiting = false;
    	MyProc->lwWaitMode = 0;
    	MyProc->waitLock = NULL;
    	MyProc->waitProcLock = NULL;
    	MyProc->recoveryConflictPending = false;
    	/* Initialize fields for sync rep */
    	MyProc->waitLSN = 0;
    	MyProc->syncRepState = SYNC_REP_NOT_WAITING;
    	SHMQueueElemInit(&(MyProc->syncRepLinks));
    	/* Initialize fields for group XID clearing. */
    	MyProc->procArrayGroupMember = false;
    	MyProc->procArrayGroupMemberXid = InvalidTransactionId;	
    	/* Initialize wait event information. */
    	MyProc->wait_event_info = 0;
    	/* Initialize fields for group transaction status update. */
    	MyProc->clogGroupMember = false;
    	MyProc->clogGroupMemberXid = InvalidTransactionId;
    	MyProc->clogGroupMemberXidStatus = TRANSACTION_STATUS_IN_PROGRESS;
    	MyProc->clogGroupMemberPage = -1;
    	MyProc->clogGroupMemberLsn = InvalidXLogRecPtr;	
    	PGSemaphoreReset(MyProc->sem);
    `

[PostgreSQL数据库并发事务——PROCARRAY创建][PostgreSQL_PROCARRAY]

##### MyPgXact #####

在InitProcess中向&ProcGlobal->allPgXact\[MyProc->pgprocno\]获取PGXACT，并赋值给MyPgXact。

typedef struct PGXACT { 
    	TransactionId xid;			/* id of top-level transaction currently being executed by this proc, if running and XID is assigned; else InvalidTransactionId */
    	TransactionId xmin;			/* minimal running XID as it was when we were starting our xact, excluding LAZY VACUUM: vacuum must not remove tuples deleted by xid >= xmin ! */
    	uint8		vacuumFlags;	/* vacuum-related flags, see above */
    	bool		overflowed;
    	bool		delayChkpt;		/* true if this proc delays checkpoint start; previously called InCommit */
    	uint8		nxids;
    } PGXACT;
    MyPgXact = &ProcGlobal->allPgXact[MyProc->pgprocno];

#### MyBackendId ####

`BackendId MyBackendId = InvalidBackendId;` MyBackendId是定义在src/backend/utils/init/globals.c中的全局变量，用于后端标识。SharedInvalBackendInit函数用于在sinval buffer上操作初始化新的bakcend。

/* Shared cache invalidation memory segment */
    typedef struct SISeg { 
    	/* General state information */
    	int			minMsgNum;		/* oldest message still needed */
    	int			maxMsgNum;		/* next message number to be assigned */
    	int			nextThreshold;	/* # of messages to call SICleanupQueue */
    	int			lastBackend;	/* index of last active procState entry, +1 */
    	int			maxBackends;	/* size of procState array */
    	slock_t		msgnumLock;		/* spinlock protecting maxMsgNum */
    	/* Circular buffer holding shared-inval messages */
    	SharedInvalidationMessage buffer[MAXNUMMESSAGES];
    	/* Per-backend invalidation state info (has MaxBackends entries). */
    	ProcState	procState[FLEXIBLE_ARRAY_MEMBER];
    } SISeg;
    static SISeg *shmInvalBuffer;	/* pointer to the shared inval buffer */
    void SharedInvalBackendInit(bool sendOnly) { 
    	int			index;
    	ProcState  *stateP = NULL;
    	SISeg	   *segP = shmInvalBuffer;
    	/* This can run in parallel with read operations, but not with write operations, since SIInsertDataEntries relies on lastBackend to set hasMessages appropriately. */
    	LWLockAcquire(SInvalWriteLock, LW_EXCLUSIVE);
    	/* Look for a free entry in the procState array */
    	for (index = 0; index < segP->lastBackend; index++){ 
    		if (segP->procState[index].procPid == 0)	/* inactive slot? */{ 
    			stateP = &segP->procState[index];
    			break;
    		}
    	}
    	if (stateP == NULL){ 
    		if (segP->lastBackend < segP->maxBackends){ 
    			stateP = &segP->procState[segP->lastBackend];
    			Assert(stateP->procPid == 0);
    			segP->lastBackend++;
    		}else{ 
    			/* out of procState slots: MaxBackends exceeded -- report normally */
    			MyBackendId = InvalidBackendId;
    			LWLockRelease(SInvalWriteLock);
    			ereport(FATAL,(errcode(ERRCODE_TOO_MANY_CONNECTIONS),errmsg("sorry, too many clients already")));
    		}
    	}
    	MyBackendId = (stateP - &segP->procState[0]) + 1;
    	/* Advertise assigned backend ID in MyProc */
    	MyProc->backendId = MyBackendId;
    	/* Fetch next local transaction ID into local memory */
    	nextLocalTransactionId = stateP->nextLXID;
    	/* mark myself active, with all extant messages already read */
    	stateP->procPid = MyProcPid;
    	stateP->proc = MyProc;
    	stateP->nextMsgNum = segP->maxMsgNum;
    	stateP->resetState = false;
    	stateP->signaled = false;
    	stateP->hasMessages = false;
    	stateP->sendOnly = sendOnly;
    	LWLockRelease(SInvalWriteLock);
    	/* register exit routine to mark my entry inactive at exit */
    	on_shmem_exit(CleanupInvalidationState, PointerGetDatum(segP));
    	elog(DEBUG4, "my backend ID is %d", MyBackendId);
    }

#### MyProcSignalSlot ####

通过传入MyBackendId获取ProcSignalSlots数组中的对应的元素槽，将信号槽中的pss\_pid设置为MyProcPid，最后将该槽的指针赋值给MyProcSignalSlot。

typedef struct { 
    	pid_t		pss_pid;
    	sig_atomic_t pss_signalFlags[NUM_PROCSIGNALS];
    } ProcSignalSlot;
    static ProcSignalSlot *ProcSignalSlots = NULL;
    void ProcSignalInit(int pss_idx) { 
    	volatile ProcSignalSlot *slot;
    	Assert(pss_idx >= 1 && pss_idx <= NumProcSignalSlots);
    	slot = &ProcSignalSlots[pss_idx - 1];
    	/* sanity check */
    	if (slot->pss_pid != 0)
    		elog(LOG, "process %d taking over ProcSignal slot %d, but it's not empty",MyProcPid, pss_idx);
    	/* Clear out any leftover signal reasons */
    	MemSet(slot->pss_signalFlags, 0, NUM_PROCSIGNALS * sizeof(sig_atomic_t));
    	/* Mark slot with my PID */
    	slot->pss_pid = MyProcPid;
    	/* Remember slot location for CheckProcSignal */
    	MyProcSignalSlot = slot;
    	/* Set up to release the slot on process exit */
    	on_shmem_exit(CleanupProcSignalState, Int32GetDatum(pss_idx));
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6IKl5Y-U6I-M_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220828/012471caee5848a1aff0271b70b55b2c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6IKl5Y-U6I-M_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/920d3167c72c4051a601156c2ec0a283.png
[PostgreSQL_PROCARRAY]: https://feishujun.blog.csdn.net/article/details/120007258