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 "postmaster/proctypelist.h"

Include dependency graph for launch_backend.c:

Go to the source code of this file.

Data Structures
struct	child_process_kind

Macros
#define	PG_PROCTYPE(bktype, description, main_func, shmem_attach)    [bktype] = {description, main_func, shmem_attach},

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

Variables
static child_process_kind	child_process_kinds []

Macro Definition Documentation

PG_PROCTYPE

#define PG_PROCTYPE	(		bktype,
			description,
			main_func,
			shmem_attach
	)		[bktype] = {description, main_func, shmem_attach},

Function Documentation

postmaster_child_launch()

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

Definition at line 207 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 189 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:

= {
#define PG_PROCTYPE(bktype, description, main_func, shmem_attach) 
                                                      
 
}

Definition at line 181 of file launch_backend.c.

Referenced by postmaster_child_launch(), and PostmasterChildName().