fork_process.c File Reference

#include "postgres.h"
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <sys/stat.h>
#include <unistd.h>
#include "libpq/pqsignal.h"
#include "miscadmin.h"
#include "postmaster/fork_process.h"

Include dependency graph for fork_process.c:

Go to the source code of this file.

Functions
pid_t	fork_process (void)

Function Documentation

fork_process()

pid_t fork_process

(

void

)

Definition at line 33 of file fork_process.c.

{
    pid_t       result;
    const char *oomfilename;
    sigset_t    save_mask;
 
#ifdef LINUX_PROFILE
    struct itimerval prof_itimer;
#endif
 
    /*
     * Flush stdio channels just before fork, to avoid double-output problems.
     */
    fflush(NULL);
 
#ifdef LINUX_PROFILE
 
    /*
     * Linux's fork() resets the profiling timer in the child process. If we
     * want to profile child processes then we need to save and restore the
     * timer setting.  This is a waste of time if not profiling, however, so
     * only do it if commanded by specific -DLINUX_PROFILE switch.
     */
    getitimer(ITIMER_PROF, &prof_itimer);
#endif
 
    /*
     * We start postmaster children with signals blocked.  This allows them to
     * install their own handlers before unblocking, to avoid races where they
     * might run the postmaster's handler and miss an important control
     * signal. With more analysis this could potentially be relaxed.
     */
    sigprocmask(SIG_SETMASK, &BlockSig, &save_mask);
    result = fork();
    if (result == 0)
    {
        /* fork succeeded, in child */
        MyProcPid = getpid();
#ifdef LINUX_PROFILE
        setitimer(ITIMER_PROF, &prof_itimer, NULL);
#endif
 
        /*
         * By default, Linux tends to kill the postmaster in out-of-memory
         * situations, because it blames the postmaster for the sum of child
         * process sizes *including shared memory*.  (This is unbelievably
         * stupid, but the kernel hackers seem uninterested in improving it.)
         * Therefore it's often a good idea to protect the postmaster by
         * setting its OOM score adjustment negative (which has to be done in
         * a root-owned startup script).  Since the adjustment is inherited by
         * child processes, this would ordinarily mean that all the
         * postmaster's children are equally protected against OOM kill, which
         * is not such a good idea.  So we provide this code to allow the
         * children to change their OOM score adjustments again.  Both the
         * file name to write to and the value to write are controlled by
         * environment variables, which can be set by the same startup script
         * that did the original adjustment.
         */
        oomfilename = getenv("PG_OOM_ADJUST_FILE");
 
        if (oomfilename != NULL)
        {
            /*
             * Use open() not stdio, to ensure we control the open flags. Some
             * Linux security environments reject anything but O_WRONLY.
             */
            int         fd = open(oomfilename, O_WRONLY, 0);
 
            /* We ignore all errors */
            if (fd >= 0)
            {
                const char *oomvalue = getenv("PG_OOM_ADJUST_VALUE");
                int         rc;
 
                if (oomvalue == NULL)   /* supply a useful default */
                    oomvalue = "0";
 
                rc = write(fd, oomvalue, strlen(oomvalue));
                (void) rc;
                close(fd);
            }
        }
 
        /* do post-fork initialization for random number generation */
        pg_strong_random_init();
    }
    else
    {
        /* in parent, restore signal mask */
        sigprocmask(SIG_SETMASK, &save_mask, NULL);
    }
 
    return result;
}

References BlockSig, close, fb(), fd(), MyProcPid, pg_strong_random_init(), setitimer(), and write.

Referenced by postmaster_child_launch().