// gtm.h
#define TopMemoryContext (GetMyThreadInfo->thr_thread_context)
#define ThreadTopContext (GetMyThreadInfo->thr_thread_context)
#define MessageContext (GetMyThreadInfo->thr_message_context)
#define CurrentMemoryContext (GetMyThreadInfo->thr_current_context)
#define ErrorContext (GetMyThreadInfo->thr_error_context)

struct config_generic {
    /* constant fields, must be set correctly in initial value: */
    const char* name;       /* name of variable - MUST BE FIRST */
    GtmOptContext context;  /* context required to set the variable */
    const char* short_desc; /* short desc. of this variable's purpose */
    const char* long_desc;  /* long desc. of this variable's purpose */
    int flags;              /* flag bits, see below */
    /* variable fields, initialized at runtime: */
    enum config_type vartype;  /* type of variable (set only at startup) */
    int status;                /* status bits, see below */
    GtmOptSource reset_source; /* source of the reset_value */
    GtmOptSource source;       /* source of the current actual value */
    GtmOptStack* stack;        /* stacked prior values */
    void* extra;               /* "extra" pointer for current actual value */
    char* sourcefile;          /* file current setting is from (NULL if not
                                * file) */
    int sourceline;            /* line in source file */
};

struct config_int {
    struct config_generic gen;
    /* constant fields, must be set correctly in initial value: */
    int* variable;
    int boot_val;
    int min;
    int max;
    GtmOptIntCheckHook check_hook;
    GtmOptIntAssignHook assign_hook;
    /* variable fields, initialized at runtime: */
    int reset_val;
    void* reset_extra;
};

// 服务器IP地址
extern char* ListenAddresses;
// 与服务器某个IP地址绑定的监听套接字描述符
extern int ServerListenSocket[MAXLISTEN];
// 使用`getaddrinfo`系统函数返回与协议无关的套接字时需要关心的信息
struct addrinfo {
    int ai_flags;
    int ai_family;
    int ai_socktype;
    int ai_protocol;
    size_t ai_addrlen; // 地址结构长度
    char* ai_canonname;
    struct sockaddr* ai_addr; // 地址指针
    struct addrinfo* ai_next;
};

typedef struct List {
    NodeTag type; /* T_List, T_IntList, or T_OidList */
    int length;
    ListCell* head;
    ListCell* tail;
} List;

struct ListCell {
    union {
        void* ptr_value;
        int int_value;
        Oid oid_value;
    } data;
    ListCell* next;
};

// 不希望屏蔽的信号集、要屏蔽的信号集、进行用户连接认证时需要屏蔽的信号集
extern THR_LOCAL sigset_t UnBlockSig, BlockSig, AuthBlockSig;

// 配置文件改变产生`SIGHUP`信号
static void SIGHUP_handler(SIGNAL_ARGS);
    (void)gspqsignal(SIGHUP, SIGHUP_handler); /* reread config file and have

// 处理`SIGINT`/`SIGQUIT`/`SIGTERM`
static void pmdie(SIGNAL_ARGS);
    (void)gspqsignal(SIGINT, pmdie);          /* send SIGTERM and shut down */
    (void)gspqsignal(SIGQUIT, pmdie);         /* send SIGQUIT and die */
    (void)gspqsignal(SIGTERM, pmdie);         /* wait for children and shut down */

// 用于清除退出子进程的资源
    (void)gspqsignal(SIGCHLD, reaper);          /* handle child termination */

/*
 * Postmaster subroutine to start a syslogger subprocess.
 * 收集所有的stderr输出，并写入到日志文件
 */
ThreadId SysLogger_Start(void)

/* ----------
 * pgstat_init() -
 *
 *	Called from postmaster at startup. Create the resources required
 *	by the statistics collector process.  If unable to do so, do not
 *	fail --- better to let the postmaster start with stats collection
 *	disabled.
 * ----------
 */
void pgstat_init(void)

/*
 * Main loop for the autovacuum launcher process.
 */
NON_EXEC_STATIC void AutoVacLauncherMain()

typedef struct Port {
    int sock;                  /* File descriptor */
    CMSockAddr laddr;          /* local addr (postmaster) */
    CMSockAddr raddr;          /* remote addr (client) */
    char* remote_host;         /* name (or ip addr) of remote host */
    char* remote_port;         /* text rep of remote port */
    CM_PortLastCall last_call; /* Last syscall to this port */
    int last_errno;            /* Last errno. zero if the last call succeeds */

    char* user_name;
    …………
} Port;

/*
 * Main idle loop of postmaster
 */
static int ServerLoop(void) {
    // 初始化读文件描述符集
    nSockets = initMasks(&readmask);
    // 等待客户端提出连接请求
    selres = select(nSockets, &rmask, NULL, NULL, &timeout);
    // 如果发现该套接字上有用户提出连接请求，调用`ConnCreate`创建一个`Port`结构体
    if (FD_ISSET(t_thrd.postmaster_cxt.ListenSocket[i], &rmask)) {
        Port* port = NULL;
        ufds[i].revents = 0;
        if (IS_FD_TO_RECV_GSSOCK(ufds[i].fd)) {
            port = ConnCreateToRecvGssock(ufds, i, &nSockets);
        } else {
            port = ConnCreate(ufds[i].fd);
        }

        if (port != NULL) {
            /*
             * Since at present, HA only uses TCP sockets, we can directly compare
             * the corresponding enty in t_thrd.postmaster_cxt.listen_sock_type, even
             * though ufds are not one-to-one mapped to tcp and sctp socket array.
             * If HA adopts STCP sockets later, we will need to maintain socket type
             * array for ufds in initPollfd.
             */
            if (threadPoolActivated && !isConnectHaPort) {
                result = g_threadPoolControler->DispatchSession(port);
            } else {
                // 启动后台进程接替`Postmaster`与客户进行连接
                result = BackendStartup(port, isConnectHaPort); 
                    // 根据Port结构体来启动一个`Postgres`服务进程
                    static int BackendStartup(Port* port, bool isConnectHaPort)
                    {
                        Backend* bn = NULL; /* for backend cleanup */
                        ThreadId pid;
                        pid = initialize_worker_thread(WORKER, port);
                            ThreadId initialize_thread(ThreadArg* thr_argv)
                                int error_code = gs_thread_create(&thread, InternalThreadFunc, 1, (void*)thr_argv);
                                    static void* InternalThreadFunc(void* args)
                                    {
                                        gs_thread_exit((GetThreadEntry(thr_argv->role))(thr_argv));
                                            static int BackendRun(Port* port) {
                                                // 进入`PostgresMain`的执行入口
                                                return PostgresMain(ac, av, port->database_name, port->user_name);
                                            }
                                        return (void*)NULL;
                                    }

                        /*
                         * Everything's been successful, it's safe to add this backend to our list
                         * of backends.
                         */
                        bn->pid = pid;
                        bn->is_autovacuum = false;
                        bn->cancel_key = t_thrd.proc_cxt.MyCancelKey;
                        DLInitElem(&bn->elem, bn);
                        // 将该`bn`结构体加入到`backend_list`链表中。
                        DLAddHead(g_instance.backend_list, &bn->elem);
                    }
        }
    }
}

typedef struct knl_g_pid_context {
    ThreadId StartupPID;
    ThreadId TwoPhaseCleanerPID;
    ThreadId FaultMonitorPID;
    ThreadId BgWriterPID;
    ThreadId* CkptBgWriterPID;
    ThreadId* PageWriterPID;
    ThreadId CheckpointerPID;
    ThreadId WalWriterPID;
    ThreadId WalReceiverPID;
    ThreadId WalRcvWriterPID;
    ThreadId DataReceiverPID;
    ThreadId DataRcvWriterPID;
    ThreadId AutoVacPID;
    ThreadId PgJobSchdPID;
    ThreadId PgArchPID;
    ThreadId PgStatPID;
    ThreadId PercentilePID;
    ThreadId PgAuditPID;
    ThreadId SysLoggerPID;
    ThreadId CatchupPID;
    ThreadId WLMCollectPID;
    ThreadId WLMCalSpaceInfoPID;
    ThreadId WLMMonitorPID;
    ThreadId WLMArbiterPID;
    ThreadId CPMonitorPID;
    ThreadId AlarmCheckerPID;
    ThreadId CBMWriterPID;
    ThreadId RemoteServicePID;
    ThreadId AioCompleterStarted;
    ThreadId HeartbeatPID;
    ThreadId CsnminSyncPID;
    ThreadId BarrierCreatorPID;
    volatile ThreadId ReaperBackendPID;
    volatile ThreadId SnapshotPID;
    ThreadId AshPID;
    ThreadId StatementPID;
    ThreadId CommSenderFlowPID;
    ThreadId CommReceiverFlowPID;
    ThreadId CommAuxiliaryPID;
    ThreadId CommPoolerCleanPID;
    ThreadId* CommReceiverPIDS;
    ThreadId TsCompactionPID;
    ThreadId TsCompactionAuxiliaryPID;
} knl_g_pid_context;

/*
 * Postmaster subroutine to start a syslogger subprocess.
 */
ThreadId SysLogger_Start(void) {
    // 创建管道用于接收stderr的输出
    if (!CreatePipe(&t_thrd.postmaster_cxt.syslogPipe[0], &t_thrd.postmaster_cxt.syslogPipe[1], &sa, 32768));
    
    // 创建线程来运行`SYSLOGGER`
    sysloggerPid = initialize_util_thread(SYSLOGGER);
        /*
         * Main entry point for syslogger process
         * argc/argv parameters are valid only in EXEC_BACKEND case.
         */
        NON_EXEC_STATIC void SysLoggerMain(int fd)


    /* success, in postmaster */
    if (sysloggerPid != 0) {
        // 使用`dump2`系统函数将`stdout`和`stderr`重定向到日志的写入端
        fflush(stdout);
        if (dup2(t_thrd.postmaster_cxt.syslogPipe[1], fileno(stdout)) < 0);
        fflush(stderr);
        if (dup2(t_thrd.postmaster_cxt.syslogPipe[1], fileno(stderr)) < 0);
}

#define MessageContext (GetMyThreadInfo->thr_message_context)

    // 用来接收服务器发送给客户端的消息的缓冲区
    char PqSendBuffer[PQ_BUFFER_SIZE];
    int PqSendPointer; /* Next index to store a byte in PqSendBuffer */

    // 用来接收客户端发送给服务器的消息的缓冲区
    char PqRecvBuffer[PQ_BUFFER_SIZE];
    int PqRecvPointer; /* Next index to read a byte from PqRecvBuffer */
    int PqRecvLength;  /* End of data available in PqRecvBuffer */

    for (;;) {
        /* 释放上次查询时的内存
         * Release storage left over from prior query cycle, and create a new
         * query input buffer in the cleared t_thrd.mem_cxt.msg_mem_cxt.
         */

        /*
         * (1) If we've reached idle state, tell the frontend we're ready for
         * a new query.
         *
         * Note: this includes fflush()'ing the last of the prior output.
         *
         * This is also a good time to send collected statistics to the
         * collector, and to update the PS stats display.  We avoid doing
         * those every time through the message loop because it'd slow down
         * processing of batched messages, and because we don't want to report
         * uncommitted updates (that confuses autovacuum).	The notification
         * processor wants a call too, if we are not in a transaction block.
         */

        if (send_ready_for_query) {
            if (IS_CLIENT_CONN_VALID(u_sess->proc_cxt.MyProcPort))
                // 告诉客户端它已经准备好接收查询了
                ReadyForQuery((CommandDest)t_thrd.postgres_cxt.whereToSendOutput);
        }

        /*
         * (2) Allow asynchronous signals to be executed immediately if they
         * come in while we are waiting for client input. (This must be
         * conditional since we don't want, say, reads on behalf of COPY FROM
         * STDIN doing the same thing.)
         */
        t_thrd.postgres_cxt.DoingCommandRead = true;

        /*
         * (3) read a command (loop blocks here)
         */
        if (saved_whereToSendOutput != DestNone)
            t_thrd.postgres_cxt.whereToSendOutput = saved_whereToSendOutput;

        firstchar = ReadCommand(&input_message);
            static int ReadCommand(StringInfo inBuf) {
                // 客户端通过网络连接
                if (t_thrd.postgres_cxt.whereToSendOutput == DestRemote)
                    result = SocketBackend(inBuf);  
                // 客户端和服务器在同一台服务器上
                else if (t_thrd.postgres_cxt.whereToSendOutput == DestDebug)
                    result = InteractiveBackend(inBuf);
            }
    }