launch_backend.c File Reference

#include "postgres.h"
#include <unistd.h>
#include "libpq/libpq-be.h"
#include "miscadmin.h"
#include "postmaster/autovacuum.h"
#include "postmaster/bgworker_internals.h"
#include "postmaster/bgwriter.h"
#include "postmaster/fork_process.h"
#include "postmaster/pgarch.h"
#include "postmaster/postmaster.h"
#include "postmaster/startup.h"
#include "postmaster/syslogger.h"
#include "postmaster/walsummarizer.h"
#include "postmaster/walwriter.h"
#include "replication/slotsync.h"
#include "replication/walreceiver.h"
#include "storage/dsm.h"
#include "storage/io_worker.h"
#include "storage/pg_shmem.h"
#include "tcop/backend_startup.h"
#include "utils/memutils.h"

Include dependency graph for launch_backend.c:

Go to the source code of this file.

Data Structures
struct	child_process_kind

Functions
const char *	PostmasterChildName (BackendType child_type)
pid_t	postmaster_child_launch (BackendType child_type, int child_slot, const void *startup_data, size_t startup_data_len, ClientSocket *client_sock)

Variables
static child_process_kind	child_process_kinds []

Function Documentation

postmaster_child_launch()

pid_t postmaster_child_launch	(	BackendType	child_type,
		int	child_slot,
		const void *	startup_data,
		size_t	startup_data_len,
		ClientSocket *	client_sock
	)

Definition at line 229 of file launch_backend.c.

{
    pid_t       pid;
 
    Assert(IsPostmasterEnvironment && !IsUnderPostmaster);
 
    /* Capture time Postmaster initiates process creation for logging */
    if (IsExternalConnectionBackend(child_type))
        ((BackendStartupData *) startup_data)->fork_started = GetCurrentTimestamp();
 
#ifdef EXEC_BACKEND
    pid = internal_forkexec(child_process_kinds[child_type].name, child_slot,
                            startup_data, startup_data_len, client_sock);
    /* the child process will arrive in SubPostmasterMain */
#else                           /* !EXEC_BACKEND */
    pid = fork_process();
    if (pid == 0)               /* child */
    {
        /* Capture and transfer timings that may be needed for logging */
        if (IsExternalConnectionBackend(child_type))
        {
            conn_timing.socket_create =
                ((BackendStartupData *) startup_data)->socket_created;
            conn_timing.fork_start =
                ((BackendStartupData *) startup_data)->fork_started;
            conn_timing.fork_end = GetCurrentTimestamp();
        }
 
        /* Close the postmaster's sockets */
        ClosePostmasterPorts(child_type == B_LOGGER);
 
        /* Detangle from postmaster */
        InitPostmasterChild();
 
        /* Detach shared memory if not needed. */
        if (!child_process_kinds[child_type].shmem_attach)
        {
            dsm_detach_all();
            PGSharedMemoryDetach();
        }
 
        /*
         * Enter the Main function with TopMemoryContext.  The startup data is
         * allocated in PostmasterContext, so we cannot release it here yet.
         * The Main function will do it after it's done handling the startup
         * data.
         */
        MemoryContextSwitchTo(TopMemoryContext);
 
        MyPMChildSlot = child_slot;
        if (client_sock)
        {
            MyClientSocket = palloc(sizeof(ClientSocket));
            memcpy(MyClientSocket, client_sock, sizeof(ClientSocket));
        }
 
        /*
         * Run the appropriate Main function
         */
        child_process_kinds[child_type].main_fn(startup_data, startup_data_len);
        pg_unreachable();       /* main_fn never returns */
    }
#endif                          /* EXEC_BACKEND */
    return pid;
}

References Assert(), B_LOGGER, child_process_kinds, ClosePostmasterPorts(), conn_timing, dsm_detach_all(), ConnectionTiming::fork_end, fork_process(), ConnectionTiming::fork_start, GetCurrentTimestamp(), InitPostmasterChild(), IsExternalConnectionBackend, IsPostmasterEnvironment, IsUnderPostmaster, child_process_kind::main_fn, MemoryContextSwitchTo(), MyClientSocket, MyPMChildSlot, name, palloc(), pg_unreachable, PGSharedMemoryDetach(), ConnectionTiming::socket_create, and TopMemoryContext.

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

PostmasterChildName()

const char * PostmasterChildName

(

BackendType

child_type

)

Definition at line 211 of file launch_backend.c.

{
    return child_process_kinds[child_type].name;
}

References child_process_kinds, and child_process_kind::name.

Referenced by AssignPostmasterChildSlot(), and StartChildProcess().

Variable Documentation

child_process_kinds

child_process_kind child_process_kinds[]

static

Initial value:

= {
    [B_INVALID] = {"invalid", NULL, false},
 
    [B_BACKEND] = {"backend", BackendMain, true},
    [B_DEAD_END_BACKEND] = {"dead-end backend", BackendMain, true},
    [B_AUTOVAC_LAUNCHER] = {"autovacuum launcher", AutoVacLauncherMain, true},
    [B_AUTOVAC_WORKER] = {"autovacuum worker", AutoVacWorkerMain, true},
    [B_BG_WORKER] = {"bgworker", BackgroundWorkerMain, true},
 
    
    [B_WAL_SENDER] = {"wal sender", NULL, true},
    [B_SLOTSYNC_WORKER] = {"slot sync worker", ReplSlotSyncWorkerMain, true},
 
    [B_STANDALONE_BACKEND] = {"standalone backend", NULL, false},
 
    [B_ARCHIVER] = {"archiver", PgArchiverMain, true},
    [B_BG_WRITER] = {"bgwriter", BackgroundWriterMain, true},
    [B_CHECKPOINTER] = {"checkpointer", CheckpointerMain, true},
    [B_IO_WORKER] = {"io_worker", IoWorkerMain, true},
    [B_STARTUP] = {"startup", StartupProcessMain, true},
    [B_WAL_RECEIVER] = {"wal_receiver", WalReceiverMain, true},
    [B_WAL_SUMMARIZER] = {"wal_summarizer", WalSummarizerMain, true},
    [B_WAL_WRITER] = {"wal_writer", WalWriterMain, true},
 
    [B_LOGGER] = {"syslogger", SysLoggerMain, false},
}

Definition at line 179 of file launch_backend.c.

Referenced by postmaster_child_launch(), and PostmasterChildName().