syslogger.h File Reference

#include <limits.h>

Include dependency graph for syslogger.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PipeProtoHeader
union	PipeProtoChunk

Macros
#define	PIPE_CHUNK_SIZE   512
#define	PIPE_HEADER_SIZE   offsetof(PipeProtoHeader, data)
#define	PIPE_MAX_PAYLOAD   ((int) (PIPE_CHUNK_SIZE - PIPE_HEADER_SIZE))
#define	PIPE_PROTO_IS_LAST   0x01 /* last chunk of message? */
#define	PIPE_PROTO_DEST_STDERR   0x10
#define	PIPE_PROTO_DEST_CSVLOG   0x20
#define	PIPE_PROTO_DEST_JSONLOG   0x40
#define	LOG_METAINFO_DATAFILE   "current_logfiles"
#define	LOG_METAINFO_DATAFILE_TMP   LOG_METAINFO_DATAFILE ".tmp"

Functions
int	SysLogger_Start (int child_slot)
void	write_syslogger_file (const char *buffer, int count, int destination)
pg_noreturn void	SysLoggerMain (const void *startup_data, size_t startup_data_len)
bool	CheckLogrotateSignal (void)
void	RemoveLogrotateSignalFiles (void)

Variables
PGDLLIMPORT bool	Logging_collector
PGDLLIMPORT int	Log_RotationAge
PGDLLIMPORT int	Log_RotationSize
PGDLLIMPORT char *	Log_directory
PGDLLIMPORT char *	Log_filename
PGDLLIMPORT bool	Log_truncate_on_rotation
PGDLLIMPORT int	Log_file_mode
PGDLLIMPORT int	syslogPipe [2]

Macro Definition Documentation

LOG_METAINFO_DATAFILE

#define LOG_METAINFO_DATAFILE   "current_logfiles"

Definition at line 102 of file syslogger.h.

LOG_METAINFO_DATAFILE_TMP

#define LOG_METAINFO_DATAFILE_TMP   LOG_METAINFO_DATAFILE ".tmp"

Definition at line 103 of file syslogger.h.

PIPE_CHUNK_SIZE

#define PIPE_CHUNK_SIZE   512

Definition at line 41 of file syslogger.h.

PIPE_HEADER_SIZE

#define PIPE_HEADER_SIZE   offsetof(PipeProtoHeader, data)

Definition at line 59 of file syslogger.h.

PIPE_MAX_PAYLOAD

#define PIPE_MAX_PAYLOAD   ((int) (PIPE_CHUNK_SIZE - PIPE_HEADER_SIZE))

Definition at line 60 of file syslogger.h.

PIPE_PROTO_DEST_CSVLOG

#define PIPE_PROTO_DEST_CSVLOG   0x20

Definition at line 66 of file syslogger.h.

PIPE_PROTO_DEST_JSONLOG

#define PIPE_PROTO_DEST_JSONLOG   0x40

Definition at line 67 of file syslogger.h.

PIPE_PROTO_DEST_STDERR

#define PIPE_PROTO_DEST_STDERR   0x10

Definition at line 65 of file syslogger.h.

PIPE_PROTO_IS_LAST

#define PIPE_PROTO_IS_LAST   0x01 /* last chunk of message? */

Definition at line 63 of file syslogger.h.

Function Documentation

CheckLogrotateSignal()

bool CheckLogrotateSignal ( void  )

extern

Definition at line 1573 of file syslogger.c.

{
    struct stat stat_buf;
 
    if (stat(LOGROTATE_SIGNAL_FILE, &stat_buf) == 0)
        return true;
 
    return false;
}

References fb(), LOGROTATE_SIGNAL_FILE, and stat.

Referenced by process_pm_pmsignal().

RemoveLogrotateSignalFiles()

void RemoveLogrotateSignalFiles ( void  )

extern

Definition at line 1587 of file syslogger.c.

{
    unlink(LOGROTATE_SIGNAL_FILE);
}

References fb(), and LOGROTATE_SIGNAL_FILE.

Referenced by PostmasterMain(), and process_pm_pmsignal().

SysLogger_Start()

int SysLogger_Start ( int  child_slot )

extern

Definition at line 592 of file syslogger.c.

{
    pid_t       sysloggerPid;
    char       *filename;
#ifdef EXEC_BACKEND
    SysloggerStartupData startup_data;
#endif                          /* EXEC_BACKEND */
 
    Assert(Logging_collector);
 
    /*
     * If first time through, create the pipe which will receive stderr
     * output.
     *
     * If the syslogger crashes and needs to be restarted, we continue to use
     * the same pipe (indeed must do so, since extant backends will be writing
     * into that pipe).
     *
     * This means the postmaster must continue to hold the read end of the
     * pipe open, so we can pass it down to the reincarnated syslogger. This
     * is a bit klugy but we have little choice.
     *
     * Also note that we don't bother counting the pipe FDs by calling
     * Reserve/ReleaseExternalFD.  There's no real need to account for them
     * accurately in the postmaster or syslogger process, and both ends of the
     * pipe will wind up closed in all other postmaster children.
     */
#ifndef WIN32
    if (syslogPipe[0] < 0)
    {
        if (pipe(syslogPipe) < 0)
            ereport(FATAL,
                    (errcode_for_socket_access(),
                     errmsg("could not create pipe for syslog: %m")));
    }
#else
    if (!syslogPipe[0])
    {
        SECURITY_ATTRIBUTES sa;
 
        memset(&sa, 0, sizeof(SECURITY_ATTRIBUTES));
        sa.nLength = sizeof(SECURITY_ATTRIBUTES);
        sa.bInheritHandle = TRUE;
 
        if (!CreatePipe(&syslogPipe[0], &syslogPipe[1], &sa, 32768))
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("could not create pipe for syslog: %m")));
    }
#endif
 
    /*
     * Create log directory if not present; ignore errors
     */
    (void) MakePGDirectory(Log_directory);
 
    /*
     * The initial logfile is created right in the postmaster, to verify that
     * the Log_directory is writable.  We save the reference time so that the
     * syslogger child process can recompute this file name.
     *
     * It might look a bit strange to re-do this during a syslogger restart,
     * but we must do so since the postmaster closed syslogFile after the
     * previous fork (and remembering that old file wouldn't be right anyway).
     * Note we always append here, we won't overwrite any existing file.  This
     * is consistent with the normal rules, because by definition this is not
     * a time-based rotation.
     */
    first_syslogger_file_time = time(NULL);
 
    filename = logfile_getname(first_syslogger_file_time, NULL);
 
    syslogFile = logfile_open(filename, "a", false);
 
    pfree(filename);
 
    /*
     * Likewise for the initial CSV log file, if that's enabled.  (Note that
     * we open syslogFile even when only CSV output is nominally enabled,
     * since some code paths will write to syslogFile anyway.)
     */
    if (Log_destination & LOG_DESTINATION_CSVLOG)
    {
        filename = logfile_getname(first_syslogger_file_time, ".csv");
 
        csvlogFile = logfile_open(filename, "a", false);
 
        pfree(filename);
    }
 
    /*
     * Likewise for the initial JSON log file, if that's enabled.  (Note that
     * we open syslogFile even when only JSON output is nominally enabled,
     * since some code paths will write to syslogFile anyway.)
     */
    if (Log_destination & LOG_DESTINATION_JSONLOG)
    {
        filename = logfile_getname(first_syslogger_file_time, ".json");
 
        jsonlogFile = logfile_open(filename, "a", false);
 
        pfree(filename);
    }
 
#ifdef EXEC_BACKEND
    startup_data.syslogFile = syslogger_fdget(syslogFile);
    startup_data.csvlogFile = syslogger_fdget(csvlogFile);
    startup_data.jsonlogFile = syslogger_fdget(jsonlogFile);
    sysloggerPid = postmaster_child_launch(B_LOGGER, child_slot,
                                           &startup_data, sizeof(startup_data), NULL);
#else
    sysloggerPid = postmaster_child_launch(B_LOGGER, child_slot,
                                           NULL, 0, NULL);
#endif                          /* EXEC_BACKEND */
 
    if (sysloggerPid == -1)
    {
        ereport(LOG,
                (errmsg("could not fork system logger: %m")));
        return 0;
    }
 
    /* success, in postmaster */
 
    /* now we redirect stderr, if not done already */
    if (!redirection_done)
    {
#ifdef WIN32
        int         fd;
#endif
 
        /*
         * Leave a breadcrumb trail when redirecting, in case the user forgets
         * that redirection is active and looks only at the original stderr
         * target file.
         */
        ereport(LOG,
                (errmsg("redirecting log output to logging collector process"),
                 errhint("Future log output will appear in directory \"%s\".",
                         Log_directory)));
 
#ifndef WIN32
        fflush(stdout);
        if (dup2(syslogPipe[1], STDOUT_FILENO) < 0)
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("could not redirect stdout: %m")));
        fflush(stderr);
        if (dup2(syslogPipe[1], STDERR_FILENO) < 0)
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("could not redirect stderr: %m")));
        /* Now we are done with the write end of the pipe. */
        close(syslogPipe[1]);
        syslogPipe[1] = -1;
#else
 
        /*
         * open the pipe in binary mode and make sure stderr is binary after
         * it's been dup'ed into, to avoid disturbing the pipe chunking
         * protocol.
         */
        fflush(stderr);
        fd = _open_osfhandle((intptr_t) syslogPipe[1],
                             _O_APPEND | _O_BINARY);
        if (dup2(fd, STDERR_FILENO) < 0)
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("could not redirect stderr: %m")));
        close(fd);
        _setmode(STDERR_FILENO, _O_BINARY);
 
        /*
         * Now we are done with the write end of the pipe.  CloseHandle() must
         * not be called because the preceding close() closes the underlying
         * handle.
         */
        syslogPipe[1] = 0;
#endif
        redirection_done = true;
    }
 
    /* postmaster will never write the file(s); close 'em */
    fclose(syslogFile);
    syslogFile = NULL;
    if (csvlogFile != NULL)
    {
        fclose(csvlogFile);
        csvlogFile = NULL;
    }
    if (jsonlogFile != NULL)
    {
        fclose(jsonlogFile);
        jsonlogFile = NULL;
    }
    return (int) sysloggerPid;
}

References Assert, B_LOGGER, close, csvlogFile, ereport, errcode_for_file_access(), errcode_for_socket_access(), errhint(), errmsg(), FATAL, fb(), fd(), filename, first_syslogger_file_time, jsonlogFile, LOG, Log_destination, LOG_DESTINATION_CSVLOG, LOG_DESTINATION_JSONLOG, Log_directory, logfile_getname(), logfile_open(), Logging_collector, MakePGDirectory(), pfree(), postmaster_child_launch(), redirection_done, STDERR_FILENO, STDOUT_FILENO, syslogFile, and syslogPipe.

Referenced by StartSysLogger().

SysLoggerMain()

pg_noreturn void SysLoggerMain ( const void *  startup_data, size_t  startup_data_len  )

extern

Definition at line 165 of file syslogger.c.

{
#ifndef WIN32
    char        logbuffer[READ_BUF_SIZE];
    int         bytes_in_logbuffer = 0;
#endif
    char       *currentLogDir;
    char       *currentLogFilename;
    int         currentLogRotationAge;
    pg_time_t   now;
    WaitEventSet *wes;
 
    /*
     * Re-open the error output files that were opened by SysLogger_Start().
     *
     * We expect this will always succeed, which is too optimistic, but if it
     * fails there's not a lot we can do to report the problem anyway.  As
     * coded, we'll just crash on a null pointer dereference after failure...
     */
#ifdef EXEC_BACKEND
    {
        const SysloggerStartupData *slsdata = startup_data;
 
        Assert(startup_data_len == sizeof(*slsdata));
        syslogFile = syslogger_fdopen(slsdata->syslogFile);
        csvlogFile = syslogger_fdopen(slsdata->csvlogFile);
        jsonlogFile = syslogger_fdopen(slsdata->jsonlogFile);
    }
#else
    Assert(startup_data_len == 0);
#endif
 
    /*
     * Now that we're done reading the startup data, release postmaster's
     * working memory context.
     */
    if (PostmasterContext)
    {
        MemoryContextDelete(PostmasterContext);
        PostmasterContext = NULL;
    }
 
    now = MyStartTime;
 
    init_ps_display(NULL);
 
    /*
     * If we restarted, our stderr is already redirected into our own input
     * pipe.  This is of course pretty useless, not to mention that it
     * interferes with detecting pipe EOF.  Point stderr to /dev/null. This
     * assumes that all interesting messages generated in the syslogger will
     * come through elog.c and will be sent to write_syslogger_file.
     */
    if (redirection_done)
    {
        int         fd = open(DEVNULL, O_WRONLY, 0);
 
        /*
         * The closes might look redundant, but they are not: we want to be
         * darn sure the pipe gets closed even if the open failed.  We can
         * survive running with stderr pointing nowhere, but we can't afford
         * to have extra pipe input descriptors hanging around.
         *
         * As we're just trying to reset these to go to DEVNULL, there's not
         * much point in checking for failure from the close/dup2 calls here,
         * if they fail then presumably the file descriptors are closed and
         * any writes will go into the bitbucket anyway.
         */
        close(STDOUT_FILENO);
        close(STDERR_FILENO);
        if (fd != -1)
        {
            (void) dup2(fd, STDOUT_FILENO);
            (void) dup2(fd, STDERR_FILENO);
            close(fd);
        }
    }
 
    /*
     * Syslogger's own stderr can't be the syslogPipe, so set it back to text
     * mode if we didn't just close it. (It was set to binary in
     * SubPostmasterMain).
     */
#ifdef WIN32
    else
        _setmode(STDERR_FILENO, _O_TEXT);
#endif
 
    /*
     * Also close our copy of the write end of the pipe.  This is needed to
     * ensure we can detect pipe EOF correctly.  (But note that in the restart
     * case, the postmaster already did this.)
     */
#ifndef WIN32
    if (syslogPipe[1] >= 0)
        close(syslogPipe[1]);
    syslogPipe[1] = -1;
#else
    if (syslogPipe[1])
        CloseHandle(syslogPipe[1]);
    syslogPipe[1] = 0;
#endif
 
    /*
     * Properly accept or ignore signals the postmaster might send us
     *
     * Note: we ignore all termination signals, and instead exit only when all
     * upstream processes are gone, to ensure we don't miss any dying gasps of
     * broken backends...
     */
 
    pqsignal(SIGHUP, SignalHandlerForConfigReload); /* set flag to read config
                                                     * file */
    pqsignal(SIGINT, SIG_IGN);
    pqsignal(SIGTERM, SIG_IGN);
    pqsignal(SIGQUIT, SIG_IGN);
    pqsignal(SIGALRM, SIG_IGN);
    pqsignal(SIGPIPE, SIG_IGN);
    pqsignal(SIGUSR1, sigUsr1Handler);  /* request log rotation */
    pqsignal(SIGUSR2, SIG_IGN);
 
    /*
     * Reset some signals that are accepted by postmaster but not here
     */
    pqsignal(SIGCHLD, SIG_DFL);
 
    sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
 
#ifdef WIN32
    /* Fire up separate data transfer thread */
    InitializeCriticalSection(&sysloggerSection);
    EnterCriticalSection(&sysloggerSection);
 
    threadHandle = (HANDLE) _beginthreadex(NULL, 0, pipeThread, NULL, 0, NULL);
    if (threadHandle == 0)
        elog(FATAL, "could not create syslogger data transfer thread: %m");
#endif                          /* WIN32 */
 
    /*
     * Remember active logfiles' name(s).  We recompute 'em from the reference
     * time because passing down just the pg_time_t is a lot cheaper than
     * passing a whole file path in the EXEC_BACKEND case.
     */
    last_sys_file_name = logfile_getname(first_syslogger_file_time, NULL);
    if (csvlogFile != NULL)
        last_csv_file_name = logfile_getname(first_syslogger_file_time, ".csv");
    if (jsonlogFile != NULL)
        last_json_file_name = logfile_getname(first_syslogger_file_time, ".json");
 
    /* remember active logfile parameters */
    currentLogDir = pstrdup(Log_directory);
    currentLogFilename = pstrdup(Log_filename);
    currentLogRotationAge = Log_RotationAge;
    /* set next planned rotation time */
    set_next_rotation_time();
    update_metainfo_datafile();
 
    /*
     * Reset whereToSendOutput, as the postmaster will do (but hasn't yet, at
     * the point where we forked).  This prevents duplicate output of messages
     * from syslogger itself.
     */
    whereToSendOutput = DestNone;
 
    /*
     * Set up a reusable WaitEventSet object we'll use to wait for our latch,
     * and (except on Windows) our socket.
     *
     * Unlike all other postmaster child processes, we'll ignore postmaster
     * death because we want to collect final log output from all backends and
     * then exit last.  We'll do that by running until we see EOF on the
     * syslog pipe, which implies that all other backends have exited
     * (including the postmaster).
     */
    wes = CreateWaitEventSet(NULL, 2);
    AddWaitEventToSet(wes, WL_LATCH_SET, PGINVALID_SOCKET, MyLatch, NULL);
#ifndef WIN32
    AddWaitEventToSet(wes, WL_SOCKET_READABLE, syslogPipe[0], NULL, NULL);
#endif
 
    /* main worker loop */
    for (;;)
    {
        bool        time_based_rotation = false;
        int         size_rotation_for = 0;
        long        cur_timeout;
        WaitEvent   event;
 
#ifndef WIN32
        int         rc;
#endif
 
        /* Clear any already-pending wakeups */
        ResetLatch(MyLatch);
 
        /*
         * Process any requests or signals received recently.
         */
        if (ConfigReloadPending)
        {
            ConfigReloadPending = false;
            ProcessConfigFile(PGC_SIGHUP);
 
            /*
             * Check if the log directory or filename pattern changed in
             * postgresql.conf. If so, force rotation to make sure we're
             * writing the logfiles in the right place.
             */
            if (strcmp(Log_directory, currentLogDir) != 0)
            {
                pfree(currentLogDir);
                currentLogDir = pstrdup(Log_directory);
                rotation_requested = true;
 
                /*
                 * Also, create new directory if not present; ignore errors
                 */
                (void) MakePGDirectory(Log_directory);
            }
            if (strcmp(Log_filename, currentLogFilename) != 0)
            {
                pfree(currentLogFilename);
                currentLogFilename = pstrdup(Log_filename);
                rotation_requested = true;
            }
 
            /*
             * Force a rotation if CSVLOG output was just turned on or off and
             * we need to open or close csvlogFile accordingly.
             */
            if (((Log_destination & LOG_DESTINATION_CSVLOG) != 0) !=
                (csvlogFile != NULL))
                rotation_requested = true;
 
            /*
             * Force a rotation if JSONLOG output was just turned on or off
             * and we need to open or close jsonlogFile accordingly.
             */
            if (((Log_destination & LOG_DESTINATION_JSONLOG) != 0) !=
                (jsonlogFile != NULL))
                rotation_requested = true;
 
            /*
             * If rotation time parameter changed, reset next rotation time,
             * but don't immediately force a rotation.
             */
            if (currentLogRotationAge != Log_RotationAge)
            {
                currentLogRotationAge = Log_RotationAge;
                set_next_rotation_time();
            }
 
            /*
             * If we had a rotation-disabling failure, re-enable rotation
             * attempts after SIGHUP, and force one immediately.
             */
            if (rotation_disabled)
            {
                rotation_disabled = false;
                rotation_requested = true;
            }
 
            /*
             * Force rewriting last log filename when reloading configuration.
             * Even if rotation_requested is false, log_destination may have
             * been changed and we don't want to wait the next file rotation.
             */
            update_metainfo_datafile();
        }
 
        if (Log_RotationAge > 0 && !rotation_disabled)
        {
            /* Do a logfile rotation if it's time */
            now = (pg_time_t) time(NULL);
            if (now >= next_rotation_time)
                rotation_requested = time_based_rotation = true;
        }
 
        if (!rotation_requested && Log_RotationSize > 0 && !rotation_disabled)
        {
            /* Do a rotation if file is too big */
            if (ftello(syslogFile) >= Log_RotationSize * (pgoff_t) 1024)
            {
                rotation_requested = true;
                size_rotation_for |= LOG_DESTINATION_STDERR;
            }
            if (csvlogFile != NULL &&
                ftello(csvlogFile) >= Log_RotationSize * (pgoff_t) 1024)
            {
                rotation_requested = true;
                size_rotation_for |= LOG_DESTINATION_CSVLOG;
            }
            if (jsonlogFile != NULL &&
                ftello(jsonlogFile) >= Log_RotationSize * (pgoff_t) 1024)
            {
                rotation_requested = true;
                size_rotation_for |= LOG_DESTINATION_JSONLOG;
            }
        }
 
        if (rotation_requested)
        {
            /*
             * Force rotation when both values are zero. It means the request
             * was sent by pg_rotate_logfile() or "pg_ctl logrotate".
             */
            if (!time_based_rotation && size_rotation_for == 0)
                size_rotation_for = LOG_DESTINATION_STDERR |
                    LOG_DESTINATION_CSVLOG |
                    LOG_DESTINATION_JSONLOG;
            logfile_rotate(time_based_rotation, size_rotation_for);
        }
 
        /*
         * Calculate time till next time-based rotation, so that we don't
         * sleep longer than that.  We assume the value of "now" obtained
         * above is still close enough.  Note we can't make this calculation
         * until after calling logfile_rotate(), since it will advance
         * next_rotation_time.
         *
         * Also note that we need to beware of overflow in calculation of the
         * timeout: with large settings of Log_RotationAge, next_rotation_time
         * could be more than INT_MAX msec in the future.  In that case we'll
         * wait no more than INT_MAX msec, and try again.
         */
        if (Log_RotationAge > 0 && !rotation_disabled)
        {
            pg_time_t   delay;
 
            delay = next_rotation_time - now;
            if (delay > 0)
            {
                if (delay > INT_MAX / 1000)
                    delay = INT_MAX / 1000;
                cur_timeout = delay * 1000L;    /* msec */
            }
            else
                cur_timeout = 0;
        }
        else
            cur_timeout = -1L;
 
        /*
         * Sleep until there's something to do
         */
#ifndef WIN32
        rc = WaitEventSetWait(wes, cur_timeout, &event, 1,
                              WAIT_EVENT_SYSLOGGER_MAIN);
 
        if (rc == 1 && event.events == WL_SOCKET_READABLE)
        {
            int         bytesRead;
 
            bytesRead = read(syslogPipe[0],
                             logbuffer + bytes_in_logbuffer,
                             sizeof(logbuffer) - bytes_in_logbuffer);
            if (bytesRead < 0)
            {
                if (errno != EINTR)
                    ereport(LOG,
                            (errcode_for_socket_access(),
                             errmsg("could not read from logger pipe: %m")));
            }
            else if (bytesRead > 0)
            {
                bytes_in_logbuffer += bytesRead;
                process_pipe_input(logbuffer, &bytes_in_logbuffer);
                continue;
            }
            else
            {
                /*
                 * Zero bytes read when select() is saying read-ready means
                 * EOF on the pipe: that is, there are no longer any processes
                 * with the pipe write end open.  Therefore, the postmaster
                 * and all backends are shut down, and we are done.
                 */
                pipe_eof_seen = true;
 
                /* if there's any data left then force it out now */
                flush_pipe_input(logbuffer, &bytes_in_logbuffer);
            }
        }
#else                           /* WIN32 */
 
        /*
         * On Windows we leave it to a separate thread to transfer data and
         * detect pipe EOF.  The main thread just wakes up to handle SIGHUP
         * and rotation conditions.
         *
         * Server code isn't generally thread-safe, so we ensure that only one
         * of the threads is active at a time by entering the critical section
         * whenever we're not sleeping.
         */
        LeaveCriticalSection(&sysloggerSection);
 
        (void) WaitEventSetWait(wes, cur_timeout, &event, 1,
                                WAIT_EVENT_SYSLOGGER_MAIN);
 
        EnterCriticalSection(&sysloggerSection);
#endif                          /* WIN32 */
 
        if (pipe_eof_seen)
        {
            /*
             * seeing this message on the real stderr is annoying - so we make
             * it DEBUG1 to suppress in normal use.
             */
            ereport(DEBUG1,
                    (errmsg_internal("logger shutting down")));
 
            /*
             * Normal exit from the syslogger is here.  Note that we
             * deliberately do not close syslogFile before exiting; this is to
             * allow for the possibility of elog messages being generated
             * inside proc_exit.  Regular exit() will take care of flushing
             * and closing stdio channels.
             */
            proc_exit(0);
        }
    }
}

References AddWaitEventToSet(), Assert, close, ConfigReloadPending, CreateWaitEventSet(), csvlogFile, DEBUG1, DestNone, DEVNULL, EINTR, elog, ereport, errcode_for_socket_access(), errmsg(), errmsg_internal(), WaitEvent::events, FATAL, fb(), fd(), first_syslogger_file_time, flush_pipe_input(), ftello, init_ps_display(), jsonlogFile, last_csv_file_name, last_json_file_name, last_sys_file_name, LOG, Log_destination, LOG_DESTINATION_CSVLOG, LOG_DESTINATION_JSONLOG, LOG_DESTINATION_STDERR, Log_directory, Log_filename, Log_RotationAge, Log_RotationSize, logfile_getname(), logfile_rotate(), MakePGDirectory(), MemoryContextDelete(), MyLatch, MyStartTime, next_rotation_time, now(), pfree(), PGC_SIGHUP, PGINVALID_SOCKET, pipe_eof_seen, PostmasterContext, pqsignal, proc_exit(), process_pipe_input(), ProcessConfigFile(), pstrdup(), read, READ_BUF_SIZE, redirection_done, ResetLatch(), rotation_disabled, rotation_requested, set_next_rotation_time(), SIGALRM, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SIGPIPE, SIGQUIT, SIGUSR1, sigUsr1Handler(), SIGUSR2, STDERR_FILENO, STDOUT_FILENO, syslogFile, syslogPipe, UnBlockSig, update_metainfo_datafile(), WaitEventSetWait(), whereToSendOutput, WL_LATCH_SET, and WL_SOCKET_READABLE.

write_syslogger_file()

void write_syslogger_file ( const char *  buffer, int  count, int  destination  )

extern

Definition at line 1092 of file syslogger.c.

{
    int         rc;
    FILE       *logfile;
 
    /*
     * If we're told to write to a structured log file, but it's not open,
     * dump the data to syslogFile (which is always open) instead.  This can
     * happen if structured output is enabled after postmaster start and we've
     * been unable to open logFile.  There are also race conditions during a
     * parameter change whereby backends might send us structured output
     * before we open the logFile or after we close it.  Writing formatted
     * output to the regular log file isn't great, but it beats dropping log
     * output on the floor.
     *
     * Think not to improve this by trying to open logFile on-the-fly.  Any
     * failure in that would lead to recursion.
     */
    if ((destination & LOG_DESTINATION_CSVLOG) && csvlogFile != NULL)
        logfile = csvlogFile;
    else if ((destination & LOG_DESTINATION_JSONLOG) && jsonlogFile != NULL)
        logfile = jsonlogFile;
    else
        logfile = syslogFile;
 
    rc = fwrite(buffer, 1, count, logfile);
 
    /*
     * Try to report any failure.  We mustn't use ereport because it would
     * just recurse right back here, but write_stderr is OK: it will write
     * either to the postmaster's original stderr, or to /dev/null, but never
     * to our input pipe which would result in a different sort of looping.
     */
    if (rc != count)
        write_stderr("could not write to log file: %m\n");
}

References csvlogFile, fb(), jsonlogFile, LOG_DESTINATION_CSVLOG, LOG_DESTINATION_JSONLOG, logfile, syslogFile, and write_stderr.

Referenced by flush_pipe_input(), process_pipe_input(), send_message_to_server_log(), write_csvlog(), and write_jsonlog().

Variable Documentation

Log_directory

PGDLLIMPORT char* Log_directory

extern

Definition at line 73 of file syslogger.c.

Referenced by convert_and_check_filename(), logfile_getname(), pg_ls_logdir(), SysLogger_Start(), and SysLoggerMain().

Log_file_mode

PGDLLIMPORT int Log_file_mode

extern

Definition at line 76 of file syslogger.c.

Referenced by logfile_open(), and show_log_file_mode().

Log_filename

PGDLLIMPORT char* Log_filename

extern

Definition at line 74 of file syslogger.c.

Referenced by logfile_getname(), and SysLoggerMain().

Log_RotationAge

PGDLLIMPORT int Log_RotationAge

extern

Definition at line 71 of file syslogger.c.

Referenced by set_next_rotation_time(), and SysLoggerMain().

Log_RotationSize

PGDLLIMPORT int Log_RotationSize

extern

Definition at line 72 of file syslogger.c.

Referenced by SysLoggerMain().

Log_truncate_on_rotation

PGDLLIMPORT bool Log_truncate_on_rotation

extern

Definition at line 75 of file syslogger.c.

Referenced by logfile_rotate_dest().

Logging_collector

PGDLLIMPORT bool Logging_collector

extern

Definition at line 70 of file syslogger.c.

Referenced by LaunchMissingBackgroundProcesses(), pg_rotate_logfile(), PostmasterMain(), process_pm_child_exit(), and SysLogger_Start().

syslogPipe

PGDLLIMPORT int syslogPipe[2]

extern

Definition at line 114 of file syslogger.c.

{-1, -1};

Referenced by ClosePostmasterPorts(), SysLogger_Start(), and SysLoggerMain().