#include "postgres.h"
#include "miscadmin.h"
#include "postmaster/autovacuum.h"
#include "postmaster/postmaster.h"
#include "replication/walsender.h"
#include "storage/pmsignal.h"
#include "storage/proc.h"

Include dependency graph for pmchild.c:

Data Structures
struct	PMChildPool

Typedefs
typedef struct PMChildPool	PMChildPool

Functions
int	MaxLivePostmasterChildren (void)

void	InitPostmasterChildSlots (void)

PMChild *	AssignPostmasterChildSlot (BackendType btype)

PMChild *	AllocDeadEndChild (void)

bool	ReleasePostmasterChildSlot (PMChild *pmchild)

PMChild *	FindPostmasterChildByPid (int pid)

Variables
static PMChildPool	pmchild_pools [BACKEND_NUM_TYPES]

NON_EXEC_STATIC int	num_pmchild_slots = 0

dlist_head	ActiveChildList

Typedef Documentation

◆ PMChildPool

typedef struct PMChildPool PMChildPool

Function Documentation

◆ AllocDeadEndChild()

PMChild * AllocDeadEndChild ( void )

Definition at line 224 of file pmchild.c.

{
    PMChild    *pmchild;
 
    elog(DEBUG2, "allocating dead-end child");
 
    pmchild = (PMChild *) palloc_extended(sizeof(PMChild), MCXT_ALLOC_NO_OOM);
    if (pmchild)
    {
        pmchild->pid = 0;
        pmchild->child_slot = 0;
        pmchild->bkend_type = B_DEAD_END_BACKEND;
        pmchild->rw = NULL;
        pmchild->bgworker_notify = false;
 
        dlist_push_head(&ActiveChildList, &pmchild->elem);
    }
 
    return pmchild;
}

References ActiveChildList, B_DEAD_END_BACKEND, DEBUG2, dlist_push_head(), elog, fb(), MCXT_ALLOC_NO_OOM, and palloc_extended().

Referenced by BackendStartup().

◆ AssignPostmasterChildSlot()

PMChild * AssignPostmasterChildSlot ( BackendType btype )

Definition at line 178 of file pmchild.c.

{
    dlist_head *freelist;
    PMChild    *pmchild;
 
    if (pmchild_pools[btype].size == 0)
        elog(ERROR, "cannot allocate a PMChild slot for backend type %d", btype);
 
    freelist = &pmchild_pools[btype].freelist;
    if (dlist_is_empty(freelist))
        return NULL;
 
    pmchild = dlist_container(PMChild, elem, dlist_pop_head_node(freelist));
    pmchild->pid = 0;
    pmchild->bkend_type = btype;
    pmchild->rw = NULL;
    pmchild->bgworker_notify = true;
 
    /*
     * pmchild->child_slot for each entry was initialized when the array of
     * slots was allocated.  Sanity check it.
     */
    if (!(pmchild->child_slot >= pmchild_pools[btype].first_slotno &&
          pmchild->child_slot < pmchild_pools[btype].first_slotno + pmchild_pools[btype].size))
    {
        elog(ERROR, "pmchild freelist for backend type %d is corrupt",
             pmchild->bkend_type);
    }
 
    dlist_push_head(&ActiveChildList, &pmchild->elem);
 
    /* Update the status in the shared memory array */
    MarkPostmasterChildSlotAssigned(pmchild->child_slot);
 
    elog(DEBUG2, "assigned pm child slot %d for %s",
         pmchild->child_slot, PostmasterChildName(btype));
 
    return pmchild;
}

References ActiveChildList, DEBUG2, dlist_container, dlist_is_empty(), dlist_pop_head_node(), dlist_push_head(), elog, ERROR, fb(), PMChildPool::first_slotno, PMChildPool::freelist, MarkPostmasterChildSlotAssigned(), pmchild_pools, PostmasterChildName(), and PMChildPool::size.

Referenced by BackendStartup(), StartBackgroundWorker(), StartChildProcess(), and StartSysLogger().

◆ FindPostmasterChildByPid()

PMChild * FindPostmasterChildByPid ( int pid )

Definition at line 290 of file pmchild.c.

{
    dlist_iter  iter;
 
    dlist_foreach(iter, &ActiveChildList)
    {
        PMChild    *bp = dlist_container(PMChild, elem, iter.cur);
 
        if (bp->pid == pid)
            return bp;
    }
    return NULL;
}

References ActiveChildList, dlist_iter::cur, dlist_container, dlist_foreach, and fb().

Referenced by process_pm_child_exit().

◆ InitPostmasterChildSlots()

void InitPostmasterChildSlots ( void )

Definition at line 97 of file pmchild.c.

{
    int         slotno;
    PMChild    *slots;
 
    /*
     * We allow more connections here than we can have backends because some
     * might still be authenticating; they might fail auth, or some existing
     * backend might exit before the auth cycle is completed.  The exact
     * MaxConnections limit is enforced when a new backend tries to join the
     * PGPROC array.
     *
     * WAL senders start out as regular backends, so they share the same pool.
     */
    pmchild_pools[B_BACKEND].size = 2 * (MaxConnections + max_wal_senders);
 
    pmchild_pools[B_AUTOVAC_WORKER].size = autovacuum_worker_slots;
    pmchild_pools[B_BG_WORKER].size = max_worker_processes;
    pmchild_pools[B_IO_WORKER].size = MAX_IO_WORKERS;
 
    /*
     * There can be only one of each of these running at a time.  They each
     * get their own pool of just one entry.
     */
    pmchild_pools[B_AUTOVAC_LAUNCHER].size = 1;
    pmchild_pools[B_SLOTSYNC_WORKER].size = 1;
    pmchild_pools[B_ARCHIVER].size = 1;
    pmchild_pools[B_BG_WRITER].size = 1;
    pmchild_pools[B_CHECKPOINTER].size = 1;
    pmchild_pools[B_STARTUP].size = 1;
    pmchild_pools[B_WAL_RECEIVER].size = 1;
    pmchild_pools[B_WAL_SUMMARIZER].size = 1;
    pmchild_pools[B_WAL_WRITER].size = 1;
    pmchild_pools[B_LOGGER].size = 1;
 
    /* The rest of the pmchild_pools are left at zero size */
 
    /* Count the total number of slots */
    num_pmchild_slots = 0;
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
        num_pmchild_slots += pmchild_pools[i].size;
 
    /* Allocate enough slots, and make sure Valgrind doesn't complain */
    slots = palloc(num_pmchild_slots * sizeof(PMChild));
#ifdef USE_VALGRIND
    pmchild_array = slots;
#endif
 
    /* Initialize them */
    slotno = 0;
    for (int btype = 0; btype < BACKEND_NUM_TYPES; btype++)
    {
        pmchild_pools[btype].first_slotno = slotno + 1;
        dlist_init(&pmchild_pools[btype].freelist);
 
        for (int j = 0; j < pmchild_pools[btype].size; j++)
        {
            slots[slotno].pid = 0;
            slots[slotno].child_slot = slotno + 1;
            slots[slotno].bkend_type = B_INVALID;
            slots[slotno].rw = NULL;
            slots[slotno].bgworker_notify = false;
            dlist_push_tail(&pmchild_pools[btype].freelist, &slots[slotno].elem);
            slotno++;
        }
    }
    Assert(slotno == num_pmchild_slots);
 
    /* Initialize other structures */
    dlist_init(&ActiveChildList);
}

References ActiveChildList, Assert, autovacuum_worker_slots, B_ARCHIVER, B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_INVALID, B_IO_WORKER, B_LOGGER, B_SLOTSYNC_WORKER, B_STARTUP, B_WAL_RECEIVER, B_WAL_SUMMARIZER, B_WAL_WRITER, BACKEND_NUM_TYPES, PMChild::bgworker_notify, PMChild::bkend_type, PMChild::child_slot, dlist_init(), dlist_push_tail(), fb(), PMChildPool::first_slotno, i, j, MAX_IO_WORKERS, max_wal_senders, max_worker_processes, MaxConnections, num_pmchild_slots, palloc(), PMChild::pid, pmchild_pools, PMChild::rw, and PMChildPool::size.

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ MaxLivePostmasterChildren()

int MaxLivePostmasterChildren ( void )

Definition at line 81 of file pmchild.c.

{
    if (num_pmchild_slots == 0)
        elog(ERROR, "PM child array not initialized yet");
    return num_pmchild_slots;
}

References elog, ERROR, and num_pmchild_slots.

Referenced by PMSignalShmemInit(), and PMSignalShmemSize().

◆ ReleasePostmasterChildSlot()

bool ReleasePostmasterChildSlot ( PMChild * pmchild )

Definition at line 252 of file pmchild.c.

{
    dlist_delete(&pmchild->elem);
    if (pmchild->bkend_type == B_DEAD_END_BACKEND)
    {
        elog(DEBUG2, "releasing dead-end backend");
        pfree(pmchild);
        return true;
    }
    else
    {
        PMChildPool *pool;
 
        elog(DEBUG2, "releasing pm child slot %d", pmchild->child_slot);
 
        /* WAL senders start out as regular backends, and share the pool */
        if (pmchild->bkend_type == B_WAL_SENDER)
            pool = &pmchild_pools[B_BACKEND];
        else
            pool = &pmchild_pools[pmchild->bkend_type];
 
        /* sanity check that we return the entry to the right pool */
        if (!(pmchild->child_slot >= pool->first_slotno &&
              pmchild->child_slot < pool->first_slotno + pool->size))
        {
            elog(ERROR, "pmchild freelist for backend type %d is corrupt",
                 pmchild->bkend_type);
        }
 
        dlist_push_head(&pool->freelist, &pmchild->elem);
        return MarkPostmasterChildSlotUnassigned(pmchild->child_slot);
    }
}