tcopprot.h File Reference

#include "nodes/params.h"
#include "nodes/plannodes.h"
#include "storage/procsignal.h"
#include "utils/guc.h"
#include "utils/queryenvironment.h"

Include dependency graph for tcopprot.h:

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

Go to the source code of this file.

Macros
#define	STACK_DEPTH_SLOP   (512 * 1024L)

Enumerations
enum	LogStmtLevel { LOGSTMT_NONE , LOGSTMT_DDL , LOGSTMT_MOD , LOGSTMT_ALL }

Functions
List *	pg_parse_query (const char *query_string)
List *	pg_rewrite_query (Query *query)
List *	pg_analyze_and_rewrite_fixedparams (RawStmt *parsetree, const char *query_string, const Oid *paramTypes, int numParams, QueryEnvironment *queryEnv)
List *	pg_analyze_and_rewrite_varparams (RawStmt *parsetree, const char *query_string, Oid **paramTypes, int *numParams, QueryEnvironment *queryEnv)
List *	pg_analyze_and_rewrite_withcb (RawStmt *parsetree, const char *query_string, ParserSetupHook parserSetup, void *parserSetupArg, QueryEnvironment *queryEnv)
PlannedStmt *	pg_plan_query (Query *querytree, const char *query_string, int cursorOptions, ParamListInfo boundParams)
List *	pg_plan_queries (List *querytrees, const char *query_string, int cursorOptions, ParamListInfo boundParams)
void	die (SIGNAL_ARGS)
void	quickdie (SIGNAL_ARGS) pg_attribute_noreturn()
void	StatementCancelHandler (SIGNAL_ARGS)
void	FloatExceptionHandler (SIGNAL_ARGS) pg_attribute_noreturn()
void	HandleRecoveryConflictInterrupt (ProcSignalReason reason)
void	ProcessClientReadInterrupt (bool blocked)
void	ProcessClientWriteInterrupt (bool blocked)
void	process_postgres_switches (int argc, char *argv[], GucContext ctx, const char **dbname)
void	PostgresSingleUserMain (int argc, char *argv[], const char *username) pg_attribute_noreturn()
void	PostgresMain (const char *dbname, const char *username) pg_attribute_noreturn()
long	get_stack_depth_rlimit (void)
void	ResetUsage (void)
void	ShowUsage (const char *title)
int	check_log_duration (char *msec_str, bool was_logged)
void	set_debug_options (int debug_flag, GucContext context, GucSource source)
bool	set_plan_disabling_options (const char *arg, GucContext context, GucSource source)
const char *	get_stats_option_name (const char *arg)

Variables
PGDLLIMPORT CommandDest	whereToSendOutput
PGDLLIMPORT const char *	debug_query_string
PGDLLIMPORT int	max_stack_depth
PGDLLIMPORT int	PostAuthDelay
PGDLLIMPORT int	client_connection_check_interval
PGDLLIMPORT bool	Log_disconnections
PGDLLIMPORT int	log_statement

Macro Definition Documentation

STACK_DEPTH_SLOP

#define STACK_DEPTH_SLOP   (512 * 1024L)

Definition at line 25 of file tcopprot.h.

Enumeration Type Documentation

LogStmtLevel

enum LogStmtLevel

Enumerator
LOGSTMT_NONE
LOGSTMT_DDL
LOGSTMT_MOD
LOGSTMT_ALL

Definition at line 35 of file tcopprot.h.

{
    LOGSTMT_NONE,               /* log no statements */
    LOGSTMT_DDL,                /* log data definition statements */
    LOGSTMT_MOD,                /* log modification statements, plus DDL */
    LOGSTMT_ALL,                /* log all statements */
} LogStmtLevel;

Function Documentation

check_log_duration()

int check_log_duration	(	char *	msec_str,
		bool	was_logged
	)

Definition at line 2379 of file postgres.c.

{
    if (log_duration || log_min_duration_sample >= 0 ||
        log_min_duration_statement >= 0 || xact_is_sampled)
    {
        long        secs;
        int         usecs;
        int         msecs;
        bool        exceeded_duration;
        bool        exceeded_sample_duration;
        bool        in_sample = false;
 
        TimestampDifference(GetCurrentStatementStartTimestamp(),
                            GetCurrentTimestamp(),
                            &secs, &usecs);
        msecs = usecs / 1000;
 
        /*
         * This odd-looking test for log_min_duration_* being exceeded is
         * designed to avoid integer overflow with very long durations: don't
         * compute secs * 1000 until we've verified it will fit in int.
         */
        exceeded_duration = (log_min_duration_statement == 0 ||
                             (log_min_duration_statement > 0 &&
                              (secs > log_min_duration_statement / 1000 ||
                               secs * 1000 + msecs >= log_min_duration_statement)));
 
        exceeded_sample_duration = (log_min_duration_sample == 0 ||
                                    (log_min_duration_sample > 0 &&
                                     (secs > log_min_duration_sample / 1000 ||
                                      secs * 1000 + msecs >= log_min_duration_sample)));
 
        /*
         * Do not log if log_statement_sample_rate = 0. Log a sample if
         * log_statement_sample_rate <= 1 and avoid unnecessary PRNG call if
         * log_statement_sample_rate = 1.
         */
        if (exceeded_sample_duration)
            in_sample = log_statement_sample_rate != 0 &&
                (log_statement_sample_rate == 1 ||
                 pg_prng_double(&pg_global_prng_state) <= log_statement_sample_rate);
 
        if (exceeded_duration || in_sample || log_duration || xact_is_sampled)
        {
            snprintf(msec_str, 32, "%ld.%03d",
                     secs * 1000 + msecs, usecs % 1000);
            if ((exceeded_duration || in_sample || xact_is_sampled) && !was_logged)
                return 2;
            else
                return 1;
        }
    }
 
    return 0;
}

References GetCurrentStatementStartTimestamp(), GetCurrentTimestamp(), log_duration, log_min_duration_sample, log_min_duration_statement, log_statement_sample_rate, pg_global_prng_state, pg_prng_double(), snprintf, TimestampDifference(), and xact_is_sampled.

Referenced by exec_bind_message(), exec_execute_message(), exec_parse_message(), exec_simple_query(), and HandleFunctionRequest().

die()

void die

(

SIGNAL_ARGS

)

Definition at line 2971 of file postgres.c.

{
    /* Don't joggle the elbow of proc_exit */
    if (!proc_exit_inprogress)
    {
        InterruptPending = true;
        ProcDiePending = true;
    }
 
    /* for the cumulative stats system */
    pgStatSessionEndCause = DISCONNECT_KILLED;
 
    /* If we're still here, waken anything waiting on the process latch */
    SetLatch(MyLatch);
 
    /*
     * If we're in single user mode, we want to quit immediately - we can't
     * rely on latches as they wouldn't work when stdin/stdout is a file.
     * Rather ugly, but it's unlikely to be worthwhile to invest much more
     * effort just for the benefit of single user mode.
     */
    if (DoingCommandRead && whereToSendOutput != DestRemote)
        ProcessInterrupts();
}

References DestRemote, DISCONNECT_KILLED, DoingCommandRead, InterruptPending, MyLatch, pgStatSessionEndCause, proc_exit_inprogress, ProcDiePending, ProcessInterrupts(), SetLatch(), and whereToSendOutput.

Referenced by PostgresMain().

FloatExceptionHandler()

void FloatExceptionHandler

(

SIGNAL_ARGS

)

Definition at line 3018 of file postgres.c.

{
    /* We're not returning, so no need to save errno */
    ereport(ERROR,
            (errcode(ERRCODE_FLOATING_POINT_EXCEPTION),
             errmsg("floating-point exception"),
             errdetail("An invalid floating-point operation was signaled. "
                       "This probably means an out-of-range result or an "
                       "invalid operation, such as division by zero.")));
}

References ereport, errcode(), errdetail(), errmsg(), and ERROR.

Referenced by AutoVacWorkerMain(), BackgroundWorkerMain(), plperl_init_interp(), PostgresMain(), and ReplSlotSyncWorkerMain().

get_stack_depth_rlimit()

long get_stack_depth_rlimit

(

void

)

Definition at line 4960 of file postgres.c.

{
#if defined(HAVE_GETRLIMIT)
    static long val = 0;
 
    /* This won't change after process launch, so check just once */
    if (val == 0)
    {
        struct rlimit rlim;
 
        if (getrlimit(RLIMIT_STACK, &rlim) < 0)
            val = -1;
        else if (rlim.rlim_cur == RLIM_INFINITY)
            val = LONG_MAX;
        /* rlim_cur is probably of an unsigned type, so check for overflow */
        else if (rlim.rlim_cur >= LONG_MAX)
            val = LONG_MAX;
        else
            val = rlim.rlim_cur;
    }
    return val;
#else
    /* On Windows we set the backend stack size in src/backend/Makefile */
    return WIN32_STACK_RLIMIT;
#endif
}

References val.

Referenced by check_max_stack_depth(), and InitializeGUCOptionsFromEnvironment().

get_stats_option_name()

const char* get_stats_option_name

(

const char *

arg

)

Definition at line 3749 of file postgres.c.

{
    switch (arg[0])
    {
        case 'p':
            if (optarg[1] == 'a')   /* "parser" */
                return "log_parser_stats";
            else if (optarg[1] == 'l')  /* "planner" */
                return "log_planner_stats";
            break;
 
        case 'e':               /* "executor" */
            return "log_executor_stats";
            break;
    }
 
    return NULL;
}

References arg, and optarg.

Referenced by PostmasterMain(), and process_postgres_switches().

HandleRecoveryConflictInterrupt()

void HandleRecoveryConflictInterrupt

(

ProcSignalReason

reason

)

Definition at line 3034 of file postgres.c.

{
    RecoveryConflictPendingReasons[reason] = true;
    RecoveryConflictPending = true;
    InterruptPending = true;
    /* latch will be set by procsignal_sigusr1_handler */
}

References InterruptPending, RecoveryConflictPending, and RecoveryConflictPendingReasons.

Referenced by procsignal_sigusr1_handler().

pg_analyze_and_rewrite_fixedparams()

List* pg_analyze_and_rewrite_fixedparams	(	RawStmt *	parsetree,
		const char *	query_string,
		const Oid *	paramTypes,
		int	numParams,
		QueryEnvironment *	queryEnv
	)

Definition at line 671 of file postgres.c.

{
    Query      *query;
    List       *querytree_list;
 
    TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
 
    /*
     * (1) Perform parse analysis.
     */
    if (log_parser_stats)
        ResetUsage();
 
    query = parse_analyze_fixedparams(parsetree, query_string, paramTypes, numParams,
                                      queryEnv);
 
    if (log_parser_stats)
        ShowUsage("PARSE ANALYSIS STATISTICS");
 
    /*
     * (2) Rewrite the queries, as necessary
     */
    querytree_list = pg_rewrite_query(query);
 
    TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
 
    return querytree_list;
}

References log_parser_stats, parse_analyze_fixedparams(), pg_rewrite_query(), ResetUsage(), and ShowUsage().

Referenced by _SPI_execute_plan(), _SPI_prepare_plan(), BeginCopyTo(), exec_simple_query(), execute_sql_string(), and RevalidateCachedQuery().

pg_analyze_and_rewrite_varparams()

List* pg_analyze_and_rewrite_varparams	(	RawStmt *	parsetree,
		const char *	query_string,
		Oid **	paramTypes,
		int *	numParams,
		QueryEnvironment *	queryEnv
	)

Definition at line 710 of file postgres.c.

{
    Query      *query;
    List       *querytree_list;
 
    TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
 
    /*
     * (1) Perform parse analysis.
     */
    if (log_parser_stats)
        ResetUsage();
 
    query = parse_analyze_varparams(parsetree, query_string, paramTypes, numParams,
                                    queryEnv);
 
    /*
     * Check all parameter types got determined.
     */
    for (int i = 0; i < *numParams; i++)
    {
        Oid         ptype = (*paramTypes)[i];
 
        if (ptype == InvalidOid || ptype == UNKNOWNOID)
            ereport(ERROR,
                    (errcode(ERRCODE_INDETERMINATE_DATATYPE),
                     errmsg("could not determine data type of parameter $%d",
                            i + 1)));
    }
 
    if (log_parser_stats)
        ShowUsage("PARSE ANALYSIS STATISTICS");
 
    /*
     * (2) Rewrite the queries, as necessary
     */
    querytree_list = pg_rewrite_query(query);
 
    TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
 
    return querytree_list;
}

References ereport, errcode(), errmsg(), ERROR, i, InvalidOid, log_parser_stats, parse_analyze_varparams(), pg_rewrite_query(), ResetUsage(), and ShowUsage().

Referenced by exec_parse_message(), and PrepareQuery().

pg_analyze_and_rewrite_withcb()

List* pg_analyze_and_rewrite_withcb	(	RawStmt *	parsetree,
		const char *	query_string,
		ParserSetupHook	parserSetup,
		void *	parserSetupArg,
		QueryEnvironment *	queryEnv
	)

Definition at line 764 of file postgres.c.

{
    Query      *query;
    List       *querytree_list;
 
    TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
 
    /*
     * (1) Perform parse analysis.
     */
    if (log_parser_stats)
        ResetUsage();
 
    query = parse_analyze_withcb(parsetree, query_string, parserSetup, parserSetupArg,
                                 queryEnv);
 
    if (log_parser_stats)
        ShowUsage("PARSE ANALYSIS STATISTICS");
 
    /*
     * (2) Rewrite the queries, as necessary
     */
    querytree_list = pg_rewrite_query(query);
 
    TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
 
    return querytree_list;
}

References log_parser_stats, parse_analyze_withcb(), pg_rewrite_query(), ResetUsage(), and ShowUsage().

Referenced by _SPI_execute_plan(), _SPI_prepare_plan(), fmgr_sql_validator(), init_sql_fcache(), inline_set_returning_function(), and RevalidateCachedQuery().

pg_parse_query()

List* pg_parse_query

(

const char *

query_string

)

Definition at line 611 of file postgres.c.

{
    List       *raw_parsetree_list;
 
    TRACE_POSTGRESQL_QUERY_PARSE_START(query_string);
 
    if (log_parser_stats)
        ResetUsage();
 
    raw_parsetree_list = raw_parser(query_string, RAW_PARSE_DEFAULT);
 
    if (log_parser_stats)
        ShowUsage("PARSER STATISTICS");
 
#ifdef COPY_PARSE_PLAN_TREES
    /* Optional debugging check: pass raw parsetrees through copyObject() */
    {
        List       *new_list = copyObject(raw_parsetree_list);
 
        /* This checks both copyObject() and the equal() routines... */
        if (!equal(new_list, raw_parsetree_list))
            elog(WARNING, "copyObject() failed to produce an equal raw parse tree");
        else
            raw_parsetree_list = new_list;
    }
#endif
 
    /*
     * Optional debugging check: pass raw parsetrees through
     * outfuncs/readfuncs
     */
#ifdef WRITE_READ_PARSE_PLAN_TREES
    {
        char       *str = nodeToStringWithLocations(raw_parsetree_list);
        List       *new_list = stringToNodeWithLocations(str);
 
        pfree(str);
        /* This checks both outfuncs/readfuncs and the equal() routines... */
        if (!equal(new_list, raw_parsetree_list))
            elog(WARNING, "outfuncs/readfuncs failed to produce an equal raw parse tree");
        else
            raw_parsetree_list = new_list;
    }
#endif
 
    TRACE_POSTGRESQL_QUERY_PARSE_DONE(query_string);
 
    return raw_parsetree_list;
}

References copyObject, elog, equal(), log_parser_stats, new_list(), nodeToStringWithLocations(), pfree(), RAW_PARSE_DEFAULT, raw_parser(), ResetUsage(), ShowUsage(), str, and WARNING.

Referenced by exec_parse_message(), exec_simple_query(), execute_sql_string(), fmgr_sql_validator(), ImportForeignSchema(), init_sql_fcache(), inline_function(), and inline_set_returning_function().

pg_plan_queries()

List* pg_plan_queries	(	List *	querytrees,
		const char *	query_string,
		int	cursorOptions,
		ParamListInfo	boundParams
	)

Definition at line 972 of file postgres.c.

{
    List       *stmt_list = NIL;
    ListCell   *query_list;
 
    foreach(query_list, querytrees)
    {
        Query      *query = lfirst_node(Query, query_list);
        PlannedStmt *stmt;
 
        if (query->commandType == CMD_UTILITY)
        {
            /* Utility commands require no planning. */
            stmt = makeNode(PlannedStmt);
            stmt->commandType = CMD_UTILITY;
            stmt->canSetTag = query->canSetTag;
            stmt->utilityStmt = query->utilityStmt;
            stmt->stmt_location = query->stmt_location;
            stmt->stmt_len = query->stmt_len;
            stmt->queryId = query->queryId;
        }
        else
        {
            stmt = pg_plan_query(query, query_string, cursorOptions,
                                 boundParams);
        }
 
        stmt_list = lappend(stmt_list, stmt);
    }
 
    return stmt_list;
}

References CMD_UTILITY, Query::commandType, lappend(), lfirst_node, makeNode, NIL, pg_plan_query(), stmt, Query::stmt_location, and Query::utilityStmt.

Referenced by BuildCachedPlan(), exec_simple_query(), and execute_sql_string().

pg_plan_query()

PlannedStmt* pg_plan_query	(	Query *	querytree,
		const char *	query_string,
		int	cursorOptions,
		ParamListInfo	boundParams
	)

Definition at line 886 of file postgres.c.

{
    PlannedStmt *plan;
 
    /* Utility commands have no plans. */
    if (querytree->commandType == CMD_UTILITY)
        return NULL;
 
    /* Planner must have a snapshot in case it calls user-defined functions. */
    Assert(ActiveSnapshotSet());
 
    TRACE_POSTGRESQL_QUERY_PLAN_START();
 
    if (log_planner_stats)
        ResetUsage();
 
    /* call the optimizer */
    plan = planner(querytree, query_string, cursorOptions, boundParams);
 
    if (log_planner_stats)
        ShowUsage("PLANNER STATISTICS");
 
#ifdef COPY_PARSE_PLAN_TREES
    /* Optional debugging check: pass plan tree through copyObject() */
    {
        PlannedStmt *new_plan = copyObject(plan);
 
        /*
         * equal() currently does not have routines to compare Plan nodes, so
         * don't try to test equality here.  Perhaps fix someday?
         */
#ifdef NOT_USED
        /* This checks both copyObject() and the equal() routines... */
        if (!equal(new_plan, plan))
            elog(WARNING, "copyObject() failed to produce an equal plan tree");
        else
#endif
            plan = new_plan;
    }
#endif
 
#ifdef WRITE_READ_PARSE_PLAN_TREES
    /* Optional debugging check: pass plan tree through outfuncs/readfuncs */
    {
        char       *str;
        PlannedStmt *new_plan;
 
        str = nodeToStringWithLocations(plan);
        new_plan = stringToNodeWithLocations(str);
        pfree(str);
 
        /*
         * equal() currently does not have routines to compare Plan nodes, so
         * don't try to test equality here.  Perhaps fix someday?
         */
#ifdef NOT_USED
        /* This checks both outfuncs/readfuncs and the equal() routines... */
        if (!equal(new_plan, plan))
            elog(WARNING, "outfuncs/readfuncs failed to produce an equal plan tree");
        else
#endif
            plan = new_plan;
    }
#endif
 
    /*
     * Print plan if debugging.
     */
    if (Debug_print_plan)
        elog_node_display(LOG, "plan", plan, Debug_pretty_print);
 
    TRACE_POSTGRESQL_QUERY_PLAN_DONE();
 
    return plan;
}

References ActiveSnapshotSet(), Assert, CMD_UTILITY, copyObject, Debug_pretty_print, Debug_print_plan, elog, elog_node_display(), equal(), LOG, log_planner_stats, nodeToStringWithLocations(), pfree(), plan, planner(), querytree(), ResetUsage(), ShowUsage(), str, and WARNING.

Referenced by BeginCopyTo(), ExecCreateTableAs(), init_execution_state(), PerformCursorOpen(), pg_plan_queries(), refresh_matview_datafill(), and standard_ExplainOneQuery().

pg_rewrite_query()

List* pg_rewrite_query

(

Query *

query

)

Definition at line 804 of file postgres.c.

{
    List       *querytree_list;
 
    if (Debug_print_parse)
        elog_node_display(LOG, "parse tree", query,
                          Debug_pretty_print);
 
    if (log_parser_stats)
        ResetUsage();
 
    if (query->commandType == CMD_UTILITY)
    {
        /* don't rewrite utilities, just dump 'em into result list */
        querytree_list = list_make1(query);
    }
    else
    {
        /* rewrite regular queries */
        querytree_list = QueryRewrite(query);
    }
 
    if (log_parser_stats)
        ShowUsage("REWRITER STATISTICS");
 
#ifdef COPY_PARSE_PLAN_TREES
    /* Optional debugging check: pass querytree through copyObject() */
    {
        List       *new_list;
 
        new_list = copyObject(querytree_list);
        /* This checks both copyObject() and the equal() routines... */
        if (!equal(new_list, querytree_list))
            elog(WARNING, "copyObject() failed to produce an equal rewritten parse tree");
        else
            querytree_list = new_list;
    }
#endif
 
#ifdef WRITE_READ_PARSE_PLAN_TREES
    /* Optional debugging check: pass querytree through outfuncs/readfuncs */
    {
        List       *new_list = NIL;
        ListCell   *lc;
 
        foreach(lc, querytree_list)
        {
            Query      *curr_query = lfirst_node(Query, lc);
            char       *str = nodeToStringWithLocations(curr_query);
            Query      *new_query = stringToNodeWithLocations(str);
 
            /*
             * queryId is not saved in stored rules, but we must preserve it
             * here to avoid breaking pg_stat_statements.
             */
            new_query->queryId = curr_query->queryId;
 
            new_list = lappend(new_list, new_query);
            pfree(str);
        }
 
        /* This checks both outfuncs/readfuncs and the equal() routines... */
        if (!equal(new_list, querytree_list))
            elog(WARNING, "outfuncs/readfuncs failed to produce an equal rewritten parse tree");
        else
            querytree_list = new_list;
    }
#endif
 
    if (Debug_print_rewritten)
        elog_node_display(LOG, "rewritten parse tree", querytree_list,
                          Debug_pretty_print);
 
    return querytree_list;
}

References CMD_UTILITY, Query::commandType, copyObject, Debug_pretty_print, Debug_print_parse, Debug_print_rewritten, elog, elog_node_display(), equal(), lappend(), lfirst_node, list_make1, LOG, log_parser_stats, new_list(), NIL, nodeToStringWithLocations(), pfree(), QueryRewrite(), ResetUsage(), ShowUsage(), str, and WARNING.

Referenced by fmgr_sql_validator(), init_sql_fcache(), inline_set_returning_function(), pg_analyze_and_rewrite_fixedparams(), pg_analyze_and_rewrite_varparams(), and pg_analyze_and_rewrite_withcb().

PostgresMain()

void PostgresMain	(	const char *	dbname,
		const char *	username
	)

Definition at line 4151 of file postgres.c.

{
    sigjmp_buf  local_sigjmp_buf;
 
    /* these must be volatile to ensure state is preserved across longjmp: */
    volatile bool send_ready_for_query = true;
    volatile bool idle_in_transaction_timeout_enabled = false;
    volatile bool idle_session_timeout_enabled = false;
 
    Assert(dbname != NULL);
    Assert(username != NULL);
 
    Assert(GetProcessingMode() == InitProcessing);
 
    /*
     * Set up signal handlers.  (InitPostmasterChild or InitStandaloneProcess
     * has already set up BlockSig and made that the active signal mask.)
     *
     * Note that postmaster blocked all signals before forking child process,
     * so there is no race condition whereby we might receive a signal before
     * we have set up the handler.
     *
     * Also note: it's best not to use any signals that are SIG_IGNored in the
     * postmaster.  If such a signal arrives before we are able to change the
     * handler to non-SIG_IGN, it'll get dropped.  Instead, make a dummy
     * handler in the postmaster to reserve the signal. (Of course, this isn't
     * an issue for signals that are locally generated, such as SIGALRM and
     * SIGPIPE.)
     */
    if (am_walsender)
        WalSndSignals();
    else
    {
        pqsignal(SIGHUP, SignalHandlerForConfigReload);
        pqsignal(SIGINT, StatementCancelHandler);   /* cancel current query */
        pqsignal(SIGTERM, die); /* cancel current query and exit */
 
        /*
         * In a postmaster child backend, replace SignalHandlerForCrashExit
         * with quickdie, so we can tell the client we're dying.
         *
         * In a standalone backend, SIGQUIT can be generated from the keyboard
         * easily, while SIGTERM cannot, so we make both signals do die()
         * rather than quickdie().
         */
        if (IsUnderPostmaster)
            pqsignal(SIGQUIT, quickdie);    /* hard crash time */
        else
            pqsignal(SIGQUIT, die); /* cancel current query and exit */
        InitializeTimeouts();   /* establishes SIGALRM handler */
 
        /*
         * Ignore failure to write to frontend. Note: if frontend closes
         * connection, we will notice it and exit cleanly when control next
         * returns to outer loop.  This seems safer than forcing exit in the
         * midst of output during who-knows-what operation...
         */
        pqsignal(SIGPIPE, SIG_IGN);
        pqsignal(SIGUSR1, procsignal_sigusr1_handler);
        pqsignal(SIGUSR2, SIG_IGN);
        pqsignal(SIGFPE, FloatExceptionHandler);
 
        /*
         * Reset some signals that are accepted by postmaster but not by
         * backend
         */
        pqsignal(SIGCHLD, SIG_DFL); /* system() requires this on some
                                     * platforms */
    }
 
    /* Early initialization */
    BaseInit();
 
    /* We need to allow SIGINT, etc during the initial transaction */
    sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
 
    /*
     * General initialization.
     *
     * NOTE: if you are tempted to add code in this vicinity, consider putting
     * it inside InitPostgres() instead.  In particular, anything that
     * involves database access should be there, not here.
     *
     * Honor session_preload_libraries if not dealing with a WAL sender.
     */
    InitPostgres(dbname, InvalidOid,    /* database to connect to */
                 username, InvalidOid,  /* role to connect as */
                 (!am_walsender) ? INIT_PG_LOAD_SESSION_LIBS : 0,
                 NULL);         /* no out_dbname */
 
    /*
     * If the PostmasterContext is still around, recycle the space; we don't
     * need it anymore after InitPostgres completes.
     */
    if (PostmasterContext)
    {
        MemoryContextDelete(PostmasterContext);
        PostmasterContext = NULL;
    }
 
    SetProcessingMode(NormalProcessing);
 
    /*
     * Now all GUC states are fully set up.  Report them to client if
     * appropriate.
     */
    BeginReportingGUCOptions();
 
    /*
     * Also set up handler to log session end; we have to wait till now to be
     * sure Log_disconnections has its final value.
     */
    if (IsUnderPostmaster && Log_disconnections)
        on_proc_exit(log_disconnections, 0);
 
    pgstat_report_connect(MyDatabaseId);
 
    /* Perform initialization specific to a WAL sender process. */
    if (am_walsender)
        InitWalSender();
 
    /*
     * Send this backend's cancellation info to the frontend.
     */
    if (whereToSendOutput == DestRemote)
    {
        StringInfoData buf;
 
        pq_beginmessage(&buf, PqMsg_BackendKeyData);
        pq_sendint32(&buf, (int32) MyProcPid);
        pq_sendint32(&buf, (int32) MyCancelKey);
        pq_endmessage(&buf);
        /* Need not flush since ReadyForQuery will do it. */
    }
 
    /* Welcome banner for standalone case */
    if (whereToSendOutput == DestDebug)
        printf("\nPostgreSQL stand-alone backend %s\n", PG_VERSION);
 
    /*
     * Create the memory context we will use in the main loop.
     *
     * MessageContext is reset once per iteration of the main loop, ie, upon
     * completion of processing of each command message from the client.
     */
    MessageContext = AllocSetContextCreate(TopMemoryContext,
                                           "MessageContext",
                                           ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Create memory context and buffer used for RowDescription messages. As
     * SendRowDescriptionMessage(), via exec_describe_statement_message(), is
     * frequently executed for ever single statement, we don't want to
     * allocate a separate buffer every time.
     */
    row_description_context = AllocSetContextCreate(TopMemoryContext,
                                                    "RowDescriptionContext",
                                                    ALLOCSET_DEFAULT_SIZES);
    MemoryContextSwitchTo(row_description_context);
    initStringInfo(&row_description_buf);
    MemoryContextSwitchTo(TopMemoryContext);
 
    /* Fire any defined login event triggers, if appropriate */
    EventTriggerOnLogin();
 
    /*
     * POSTGRES main processing loop begins here
     *
     * If an exception is encountered, processing resumes here so we abort the
     * current transaction and start a new one.
     *
     * You might wonder why this isn't coded as an infinite loop around a
     * PG_TRY construct.  The reason is that this is the bottom of the
     * exception stack, and so with PG_TRY there would be no exception handler
     * in force at all during the CATCH part.  By leaving the outermost setjmp
     * always active, we have at least some chance of recovering from an error
     * during error recovery.  (If we get into an infinite loop thereby, it
     * will soon be stopped by overflow of elog.c's internal state stack.)
     *
     * Note that we use sigsetjmp(..., 1), so that this function's signal mask
     * (to wit, UnBlockSig) will be restored when longjmp'ing to here.  This
     * is essential in case we longjmp'd out of a signal handler on a platform
     * where that leaves the signal blocked.  It's not redundant with the
     * unblock in AbortTransaction() because the latter is only called if we
     * were inside a transaction.
     */
 
    if (sigsetjmp(local_sigjmp_buf, 1) != 0)
    {
        /*
         * NOTE: if you are tempted to add more code in this if-block,
         * consider the high probability that it should be in
         * AbortTransaction() instead.  The only stuff done directly here
         * should be stuff that is guaranteed to apply *only* for outer-level
         * error recovery, such as adjusting the FE/BE protocol status.
         */
 
        /* Since not using PG_TRY, must reset error stack by hand */
        error_context_stack = NULL;
 
        /* Prevent interrupts while cleaning up */
        HOLD_INTERRUPTS();
 
        /*
         * Forget any pending QueryCancel request, since we're returning to
         * the idle loop anyway, and cancel any active timeout requests.  (In
         * future we might want to allow some timeout requests to survive, but
         * at minimum it'd be necessary to do reschedule_timeouts(), in case
         * we got here because of a query cancel interrupting the SIGALRM
         * interrupt handler.)  Note in particular that we must clear the
         * statement and lock timeout indicators, to prevent any future plain
         * query cancels from being misreported as timeouts in case we're
         * forgetting a timeout cancel.
         */
        disable_all_timeouts(false);    /* do first to avoid race condition */
        QueryCancelPending = false;
        idle_in_transaction_timeout_enabled = false;
        idle_session_timeout_enabled = false;
 
        /* Not reading from the client anymore. */
        DoingCommandRead = false;
 
        /* Make sure libpq is in a good state */
        pq_comm_reset();
 
        /* Report the error to the client and/or server log */
        EmitErrorReport();
 
        /*
         * If Valgrind noticed something during the erroneous query, print the
         * query string, assuming we have one.
         */
        valgrind_report_error_query(debug_query_string);
 
        /*
         * Make sure debug_query_string gets reset before we possibly clobber
         * the storage it points at.
         */
        debug_query_string = NULL;
 
        /*
         * Abort the current transaction in order to recover.
         */
        AbortCurrentTransaction();
 
        if (am_walsender)
            WalSndErrorCleanup();
 
        PortalErrorCleanup();
 
        /*
         * We can't release replication slots inside AbortTransaction() as we
         * need to be able to start and abort transactions while having a slot
         * acquired. But we never need to hold them across top level errors,
         * so releasing here is fine. There also is a before_shmem_exit()
         * callback ensuring correct cleanup on FATAL errors.
         */
        if (MyReplicationSlot != NULL)
            ReplicationSlotRelease();
 
        /* We also want to cleanup temporary slots on error. */
        ReplicationSlotCleanup(false);
 
        jit_reset_after_error();
 
        /*
         * Now return to normal top-level context and clear ErrorContext for
         * next time.
         */
        MemoryContextSwitchTo(MessageContext);
        FlushErrorState();
 
        /*
         * If we were handling an extended-query-protocol message, initiate
         * skip till next Sync.  This also causes us not to issue
         * ReadyForQuery (until we get Sync).
         */
        if (doing_extended_query_message)
            ignore_till_sync = true;
 
        /* We don't have a transaction command open anymore */
        xact_started = false;
 
        /*
         * If an error occurred while we were reading a message from the
         * client, we have potentially lost track of where the previous
         * message ends and the next one begins.  Even though we have
         * otherwise recovered from the error, we cannot safely read any more
         * messages from the client, so there isn't much we can do with the
         * connection anymore.
         */
        if (pq_is_reading_msg())
            ereport(FATAL,
                    (errcode(ERRCODE_PROTOCOL_VIOLATION),
                     errmsg("terminating connection because protocol synchronization was lost")));
 
        /* Now we can allow interrupts again */
        RESUME_INTERRUPTS();
    }
 
    /* We can now handle ereport(ERROR) */
    PG_exception_stack = &local_sigjmp_buf;
 
    if (!ignore_till_sync)
        send_ready_for_query = true;    /* initially, or after error */
 
    /*
     * Non-error queries loop here.
     */
 
    for (;;)
    {
        int         firstchar;
        StringInfoData input_message;
 
        /*
         * At top of loop, reset extended-query-message flag, so that any
         * errors encountered in "idle" state don't provoke skip.
         */
        doing_extended_query_message = false;
 
        /*
         * For valgrind reporting purposes, the "current query" begins here.
         */
#ifdef USE_VALGRIND
        old_valgrind_error_count = VALGRIND_COUNT_ERRORS;
#endif
 
        /*
         * Release storage left over from prior query cycle, and create a new
         * query input buffer in the cleared MessageContext.
         */
        MemoryContextSwitchTo(MessageContext);
        MemoryContextReset(MessageContext);
 
        initStringInfo(&input_message);
 
        /*
         * Also consider releasing our catalog snapshot if any, so that it's
         * not preventing advance of global xmin while we wait for the client.
         */
        InvalidateCatalogSnapshotConditionally();
 
        /*
         * (1) If we've reached idle state, tell the frontend we're ready for
         * a new query.
         *
         * Note: this includes fflush()'ing the last of the prior output.
         *
         * This is also a good time to flush out collected statistics to the
         * cumulative stats system, and to update the PS stats display.  We
         * avoid doing those every time through the message loop because it'd
         * slow down processing of batched messages, and because we don't want
         * to report uncommitted updates (that confuses autovacuum).  The
         * notification processor wants a call too, if we are not in a
         * transaction block.
         *
         * Also, if an idle timeout is enabled, start the timer for that.
         */
        if (send_ready_for_query)
        {
            if (IsAbortedTransactionBlockState())
            {
                set_ps_display("idle in transaction (aborted)");
                pgstat_report_activity(STATE_IDLEINTRANSACTION_ABORTED, NULL);
 
                /* Start the idle-in-transaction timer */
                if (IdleInTransactionSessionTimeout > 0
                    && (IdleInTransactionSessionTimeout < TransactionTimeout || TransactionTimeout == 0))
                {
                    idle_in_transaction_timeout_enabled = true;
                    enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
                                         IdleInTransactionSessionTimeout);
                }
            }
            else if (IsTransactionOrTransactionBlock())
            {
                set_ps_display("idle in transaction");
                pgstat_report_activity(STATE_IDLEINTRANSACTION, NULL);
 
                /* Start the idle-in-transaction timer */
                if (IdleInTransactionSessionTimeout > 0
                    && (IdleInTransactionSessionTimeout < TransactionTimeout || TransactionTimeout == 0))
                {
                    idle_in_transaction_timeout_enabled = true;
                    enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
                                         IdleInTransactionSessionTimeout);
                }
            }
            else
            {
                long        stats_timeout;
 
                /*
                 * Process incoming notifies (including self-notifies), if
                 * any, and send relevant messages to the client.  Doing it
                 * here helps ensure stable behavior in tests: if any notifies
                 * were received during the just-finished transaction, they'll
                 * be seen by the client before ReadyForQuery is.
                 */
                if (notifyInterruptPending)
                    ProcessNotifyInterrupt(false);
 
                /*
                 * Check if we need to report stats. If pgstat_report_stat()
                 * decides it's too soon to flush out pending stats / lock
                 * contention prevented reporting, it'll tell us when we
                 * should try to report stats again (so that stats updates
                 * aren't unduly delayed if the connection goes idle for a
                 * long time). We only enable the timeout if we don't already
                 * have a timeout in progress, because we don't disable the
                 * timeout below. enable_timeout_after() needs to determine
                 * the current timestamp, which can have a negative
                 * performance impact. That's OK because pgstat_report_stat()
                 * won't have us wake up sooner than a prior call.
                 */
                stats_timeout = pgstat_report_stat(false);
                if (stats_timeout > 0)
                {
                    if (!get_timeout_active(IDLE_STATS_UPDATE_TIMEOUT))
                        enable_timeout_after(IDLE_STATS_UPDATE_TIMEOUT,
                                             stats_timeout);
                }
                else
                {
                    /* all stats flushed, no need for the timeout */
                    if (get_timeout_active(IDLE_STATS_UPDATE_TIMEOUT))
                        disable_timeout(IDLE_STATS_UPDATE_TIMEOUT, false);
                }
 
                set_ps_display("idle");
                pgstat_report_activity(STATE_IDLE, NULL);
 
                /* Start the idle-session timer */
                if (IdleSessionTimeout > 0)
                {
                    idle_session_timeout_enabled = true;
                    enable_timeout_after(IDLE_SESSION_TIMEOUT,
                                         IdleSessionTimeout);
                }
            }
 
            /* Report any recently-changed GUC options */
            ReportChangedGUCOptions();
 
            ReadyForQuery(whereToSendOutput);
            send_ready_for_query = false;
        }
 
        /*
         * (2) Allow asynchronous signals to be executed immediately if they
         * come in while we are waiting for client input. (This must be
         * conditional since we don't want, say, reads on behalf of COPY FROM
         * STDIN doing the same thing.)
         */
        DoingCommandRead = true;
 
        /*
         * (3) read a command (loop blocks here)
         */
        firstchar = ReadCommand(&input_message);
 
        /*
         * (4) turn off the idle-in-transaction and idle-session timeouts if
         * active.  We do this before step (5) so that any last-moment timeout
         * is certain to be detected in step (5).
         *
         * At most one of these timeouts will be active, so there's no need to
         * worry about combining the timeout.c calls into one.
         */
        if (idle_in_transaction_timeout_enabled)
        {
            disable_timeout(IDLE_IN_TRANSACTION_SESSION_TIMEOUT, false);
            idle_in_transaction_timeout_enabled = false;
        }
        if (idle_session_timeout_enabled)
        {
            disable_timeout(IDLE_SESSION_TIMEOUT, false);
            idle_session_timeout_enabled = false;
        }
 
        /*
         * (5) disable async signal conditions again.
         *
         * Query cancel is supposed to be a no-op when there is no query in
         * progress, so if a query cancel arrived while we were idle, just
         * reset QueryCancelPending. ProcessInterrupts() has that effect when
         * it's called when DoingCommandRead is set, so check for interrupts
         * before resetting DoingCommandRead.
         */
        CHECK_FOR_INTERRUPTS();
        DoingCommandRead = false;
 
        /*
         * (6) check for any other interesting events that happened while we
         * slept.
         */
        if (ConfigReloadPending)
        {
            ConfigReloadPending = false;
            ProcessConfigFile(PGC_SIGHUP);
        }
 
        /*
         * (7) process the command.  But ignore it if we're skipping till
         * Sync.
         */
        if (ignore_till_sync && firstchar != EOF)
            continue;
 
        switch (firstchar)
        {
            case PqMsg_Query:
                {
                    const char *query_string;
 
                    /* Set statement_timestamp() */
                    SetCurrentStatementStartTimestamp();
 
                    query_string = pq_getmsgstring(&input_message);
                    pq_getmsgend(&input_message);
 
                    if (am_walsender)
                    {
                        if (!exec_replication_command(query_string))
                            exec_simple_query(query_string);
                    }
                    else
                        exec_simple_query(query_string);
 
                    valgrind_report_error_query(query_string);
 
                    send_ready_for_query = true;
                }
                break;
 
            case PqMsg_Parse:
                {
                    const char *stmt_name;
                    const char *query_string;
                    int         numParams;
                    Oid        *paramTypes = NULL;
 
                    forbidden_in_wal_sender(firstchar);
 
                    /* Set statement_timestamp() */
                    SetCurrentStatementStartTimestamp();
 
                    stmt_name = pq_getmsgstring(&input_message);
                    query_string = pq_getmsgstring(&input_message);
                    numParams = pq_getmsgint(&input_message, 2);
                    if (numParams > 0)
                    {
                        paramTypes = palloc_array(Oid, numParams);
                        for (int i = 0; i < numParams; i++)
                            paramTypes[i] = pq_getmsgint(&input_message, 4);
                    }
                    pq_getmsgend(&input_message);
 
                    exec_parse_message(query_string, stmt_name,
                                       paramTypes, numParams);
 
                    valgrind_report_error_query(query_string);
                }
                break;
 
            case PqMsg_Bind:
                forbidden_in_wal_sender(firstchar);
 
                /* Set statement_timestamp() */
                SetCurrentStatementStartTimestamp();
 
                /*
                 * this message is complex enough that it seems best to put
                 * the field extraction out-of-line
                 */
                exec_bind_message(&input_message);
 
                /* exec_bind_message does valgrind_report_error_query */
                break;
 
            case PqMsg_Execute:
                {
                    const char *portal_name;
                    int         max_rows;
 
                    forbidden_in_wal_sender(firstchar);
 
                    /* Set statement_timestamp() */
                    SetCurrentStatementStartTimestamp();
 
                    portal_name = pq_getmsgstring(&input_message);
                    max_rows = pq_getmsgint(&input_message, 4);
                    pq_getmsgend(&input_message);
 
                    exec_execute_message(portal_name, max_rows);
 
                    /* exec_execute_message does valgrind_report_error_query */
                }
                break;
 
            case PqMsg_FunctionCall:
                forbidden_in_wal_sender(firstchar);
 
                /* Set statement_timestamp() */
                SetCurrentStatementStartTimestamp();
 
                /* Report query to various monitoring facilities. */
                pgstat_report_activity(STATE_FASTPATH, NULL);
                set_ps_display("<FASTPATH>");
 
                /* start an xact for this function invocation */
                start_xact_command();
 
                /*
                 * Note: we may at this point be inside an aborted
                 * transaction.  We can't throw error for that until we've
                 * finished reading the function-call message, so
                 * HandleFunctionRequest() must check for it after doing so.
                 * Be careful not to do anything that assumes we're inside a
                 * valid transaction here.
                 */
 
                /* switch back to message context */
                MemoryContextSwitchTo(MessageContext);
 
                HandleFunctionRequest(&input_message);
 
                /* commit the function-invocation transaction */
                finish_xact_command();
 
                valgrind_report_error_query("fastpath function call");
 
                send_ready_for_query = true;
                break;
 
            case PqMsg_Close:
                {
                    int         close_type;
                    const char *close_target;
 
                    forbidden_in_wal_sender(firstchar);
 
                    close_type = pq_getmsgbyte(&input_message);
                    close_target = pq_getmsgstring(&input_message);
                    pq_getmsgend(&input_message);
 
                    switch (close_type)
                    {
                        case 'S':
                            if (close_target[0] != '\0')
                                DropPreparedStatement(close_target, false);
                            else
                            {
                                /* special-case the unnamed statement */
                                drop_unnamed_stmt();
                            }
                            break;
                        case 'P':
                            {
                                Portal      portal;
 
                                portal = GetPortalByName(close_target);
                                if (PortalIsValid(portal))
                                    PortalDrop(portal, false);
                            }
                            break;
                        default:
                            ereport(ERROR,
                                    (errcode(ERRCODE_PROTOCOL_VIOLATION),
                                     errmsg("invalid CLOSE message subtype %d",
                                            close_type)));
                            break;
                    }
 
                    if (whereToSendOutput == DestRemote)
                        pq_putemptymessage(PqMsg_CloseComplete);
 
                    valgrind_report_error_query("CLOSE message");
                }
                break;
 
            case PqMsg_Describe:
                {
                    int         describe_type;
                    const char *describe_target;
 
                    forbidden_in_wal_sender(firstchar);
 
                    /* Set statement_timestamp() (needed for xact) */
                    SetCurrentStatementStartTimestamp();
 
                    describe_type = pq_getmsgbyte(&input_message);
                    describe_target = pq_getmsgstring(&input_message);
                    pq_getmsgend(&input_message);
 
                    switch (describe_type)
                    {
                        case 'S':
                            exec_describe_statement_message(describe_target);
                            break;
                        case 'P':
                            exec_describe_portal_message(describe_target);
                            break;
                        default:
                            ereport(ERROR,
                                    (errcode(ERRCODE_PROTOCOL_VIOLATION),
                                     errmsg("invalid DESCRIBE message subtype %d",
                                            describe_type)));
                            break;
                    }
 
                    valgrind_report_error_query("DESCRIBE message");
                }
                break;
 
            case PqMsg_Flush:
                pq_getmsgend(&input_message);
                if (whereToSendOutput == DestRemote)
                    pq_flush();
                break;
 
            case PqMsg_Sync:
                pq_getmsgend(&input_message);
                finish_xact_command();
                valgrind_report_error_query("SYNC message");
                send_ready_for_query = true;
                break;
 
                /*
                 * 'X' means that the frontend is closing down the socket. EOF
                 * means unexpected loss of frontend connection. Either way,
                 * perform normal shutdown.
                 */
            case EOF:
 
                /* for the cumulative statistics system */
                pgStatSessionEndCause = DISCONNECT_CLIENT_EOF;
 
                /* FALLTHROUGH */
 
            case PqMsg_Terminate:
 
                /*
                 * Reset whereToSendOutput to prevent ereport from attempting
                 * to send any more messages to client.
                 */
                if (whereToSendOutput == DestRemote)
                    whereToSendOutput = DestNone;
 
                /*
                 * NOTE: if you are tempted to add more code here, DON'T!
                 * Whatever you had in mind to do should be set up as an
                 * on_proc_exit or on_shmem_exit callback, instead. Otherwise
                 * it will fail to be called during other backend-shutdown
                 * scenarios.
                 */
                proc_exit(0);
 
            case PqMsg_CopyData:
            case PqMsg_CopyDone:
            case PqMsg_CopyFail:
 
                /*
                 * Accept but ignore these messages, per protocol spec; we
                 * probably got here because a COPY failed, and the frontend
                 * is still sending data.
                 */
                break;
 
            default:
                ereport(FATAL,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("invalid frontend message type %d",
                                firstchar)));
        }
    }                           /* end of input-reading loop */
}

References AbortCurrentTransaction(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, am_walsender, Assert, BaseInit(), BeginReportingGUCOptions(), buf, CHECK_FOR_INTERRUPTS, ConfigReloadPending, dbname, debug_query_string, DestDebug, DestNone, DestRemote, die(), disable_all_timeouts(), disable_timeout(), DISCONNECT_CLIENT_EOF, doing_extended_query_message, DoingCommandRead, drop_unnamed_stmt(), DropPreparedStatement(), EmitErrorReport(), enable_timeout_after(), ereport, errcode(), errmsg(), ERROR, error_context_stack, EventTriggerOnLogin(), exec_bind_message(), exec_describe_portal_message(), exec_describe_statement_message(), exec_execute_message(), exec_parse_message(), exec_replication_command(), exec_simple_query(), FATAL, finish_xact_command(), FloatExceptionHandler(), FlushErrorState(), forbidden_in_wal_sender(), get_timeout_active(), GetPortalByName(), GetProcessingMode, HandleFunctionRequest(), HOLD_INTERRUPTS, i, IDLE_IN_TRANSACTION_SESSION_TIMEOUT, IDLE_SESSION_TIMEOUT, IDLE_STATS_UPDATE_TIMEOUT, IdleInTransactionSessionTimeout, IdleSessionTimeout, ignore_till_sync, INIT_PG_LOAD_SESSION_LIBS, InitializeTimeouts(), InitPostgres(), InitProcessing, initStringInfo(), InitWalSender(), InvalidateCatalogSnapshotConditionally(), InvalidOid, IsAbortedTransactionBlockState(), IsTransactionOrTransactionBlock(), IsUnderPostmaster, jit_reset_after_error(), Log_disconnections, log_disconnections(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), MessageContext, MyCancelKey, MyDatabaseId, MyProcPid, MyReplicationSlot, NormalProcessing, notifyInterruptPending, on_proc_exit(), palloc_array, PG_exception_stack, PGC_SIGHUP, pgstat_report_activity(), pgstat_report_connect(), pgstat_report_stat(), pgStatSessionEndCause, PortalDrop(), PortalErrorCleanup(), PortalIsValid, PostmasterContext, pq_beginmessage(), pq_comm_reset, pq_endmessage(), pq_flush, pq_getmsgbyte(), pq_getmsgend(), pq_getmsgint(), pq_getmsgstring(), pq_is_reading_msg(), pq_putemptymessage(), pq_sendint32(), PqMsg_BackendKeyData, PqMsg_Bind, PqMsg_Close, PqMsg_CloseComplete, PqMsg_CopyData, PqMsg_CopyDone, PqMsg_CopyFail, PqMsg_Describe, PqMsg_Execute, PqMsg_Flush, PqMsg_FunctionCall, PqMsg_Parse, PqMsg_Query, PqMsg_Sync, PqMsg_Terminate, pqsignal(), printf, proc_exit(), ProcessConfigFile(), ProcessNotifyInterrupt(), procsignal_sigusr1_handler(), QueryCancelPending, quickdie(), ReadCommand(), ReadyForQuery(), ReplicationSlotCleanup(), ReplicationSlotRelease(), ReportChangedGUCOptions(), RESUME_INTERRUPTS, row_description_buf, row_description_context, set_ps_display(), SetCurrentStatementStartTimestamp(), SetProcessingMode, SIG_DFL, SIG_IGN, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SIGPIPE, SIGQUIT, SIGUSR1, SIGUSR2, start_xact_command(), STATE_FASTPATH, STATE_IDLE, STATE_IDLEINTRANSACTION, STATE_IDLEINTRANSACTION_ABORTED, StatementCancelHandler(), TopMemoryContext, TransactionTimeout, UnBlockSig, username, valgrind_report_error_query, WalSndErrorCleanup(), WalSndSignals(), whereToSendOutput, and xact_started.

Referenced by BackendMain(), and PostgresSingleUserMain().

PostgresSingleUserMain()

void PostgresSingleUserMain	(	int	argc,
		char *	argv[],
		const char *	username
	)

Definition at line 4041 of file postgres.c.

{
    const char *dbname = NULL;
 
    Assert(!IsUnderPostmaster);
 
    /* Initialize startup process environment. */
    InitStandaloneProcess(argv[0]);
 
    /*
     * Set default values for command-line options.
     */
    InitializeGUCOptions();
 
    /*
     * Parse command-line options.
     */
    process_postgres_switches(argc, argv, PGC_POSTMASTER, &dbname);
 
    /* Must have gotten a database name, or have a default (the username) */
    if (dbname == NULL)
    {
        dbname = username;
        if (dbname == NULL)
            ereport(FATAL,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("%s: no database nor user name specified",
                            progname)));
    }
 
    /* Acquire configuration parameters */
    if (!SelectConfigFiles(userDoption, progname))
        proc_exit(1);
 
    /*
     * Validate we have been given a reasonable-looking DataDir and change
     * into it.
     */
    checkDataDir();
    ChangeToDataDir();
 
    /*
     * Create lockfile for data directory.
     */
    CreateDataDirLockFile(false);
 
    /* read control file (error checking and contains config ) */
    LocalProcessControlFile(false);
 
    /*
     * process any libraries that should be preloaded at postmaster start
     */
    process_shared_preload_libraries();
 
    /* Initialize MaxBackends */
    InitializeMaxBackends();
 
    /*
     * Give preloaded libraries a chance to request additional shared memory.
     */
    process_shmem_requests();
 
    /*
     * Now that loadable modules have had their chance to request additional
     * shared memory, determine the value of any runtime-computed GUCs that
     * depend on the amount of shared memory required.
     */
    InitializeShmemGUCs();
 
    /*
     * Now that modules have been loaded, we can process any custom resource
     * managers specified in the wal_consistency_checking GUC.
     */
    InitializeWalConsistencyChecking();
 
    CreateSharedMemoryAndSemaphores();
 
    /*
     * Remember stand-alone backend startup time,roughly at the same point
     * during startup that postmaster does so.
     */
    PgStartTime = GetCurrentTimestamp();
 
    /*
     * Create a per-backend PGPROC struct in shared memory. We must do this
     * before we can use LWLocks.
     */
    InitProcess();
 
    /*
     * Now that sufficient infrastructure has been initialized, PostgresMain()
     * can do the rest.
     */
    PostgresMain(dbname, username);
}

References Assert, ChangeToDataDir(), checkDataDir(), CreateDataDirLockFile(), CreateSharedMemoryAndSemaphores(), dbname, ereport, errcode(), errmsg(), FATAL, GetCurrentTimestamp(), InitializeGUCOptions(), InitializeMaxBackends(), InitializeShmemGUCs(), InitializeWalConsistencyChecking(), InitProcess(), InitStandaloneProcess(), IsUnderPostmaster, LocalProcessControlFile(), PGC_POSTMASTER, PgStartTime, PostgresMain(), proc_exit(), process_postgres_switches(), process_shared_preload_libraries(), process_shmem_requests(), progname, SelectConfigFiles(), userDoption, and username.

Referenced by main().

process_postgres_switches()

void process_postgres_switches	(	int	argc,
		char *	argv[],
		GucContext	ctx,
		const char **	dbname
	)

Definition at line 3789 of file postgres.c.

{
    bool        secure = (ctx == PGC_POSTMASTER);
    int         errs = 0;
    GucSource   gucsource;
    int         flag;
 
    if (secure)
    {
        gucsource = PGC_S_ARGV; /* switches came from command line */
 
        /* Ignore the initial --single argument, if present */
        if (argc > 1 && strcmp(argv[1], "--single") == 0)
        {
            argv++;
            argc--;
        }
    }
    else
    {
        gucsource = PGC_S_CLIENT;   /* switches came from client */
    }
 
#ifdef HAVE_INT_OPTERR
 
    /*
     * Turn this off because it's either printed to stderr and not the log
     * where we'd want it, or argv[0] is now "--single", which would make for
     * a weird error message.  We print our own error message below.
     */
    opterr = 0;
#endif
 
    /*
     * Parse command-line options.  CAUTION: keep this in sync with
     * postmaster/postmaster.c (the option sets should not conflict) and with
     * the common help() function in main/main.c.
     */
    while ((flag = getopt(argc, argv, "B:bC:c:D:d:EeFf:h:ijk:lN:nOPp:r:S:sTt:v:W:-:")) != -1)
    {
        switch (flag)
        {
            case 'B':
                SetConfigOption("shared_buffers", optarg, ctx, gucsource);
                break;
 
            case 'b':
                /* Undocumented flag used for binary upgrades */
                if (secure)
                    IsBinaryUpgrade = true;
                break;
 
            case 'C':
                /* ignored for consistency with the postmaster */
                break;
 
            case 'c':
            case '-':
                {
                    char       *name,
                               *value;
 
                    ParseLongOption(optarg, &name, &value);
                    if (!value)
                    {
                        if (flag == '-')
                            ereport(ERROR,
                                    (errcode(ERRCODE_SYNTAX_ERROR),
                                     errmsg("--%s requires a value",
                                            optarg)));
                        else
                            ereport(ERROR,
                                    (errcode(ERRCODE_SYNTAX_ERROR),
                                     errmsg("-c %s requires a value",
                                            optarg)));
                    }
                    SetConfigOption(name, value, ctx, gucsource);
                    pfree(name);
                    pfree(value);
                    break;
                }
 
            case 'D':
                if (secure)
                    userDoption = strdup(optarg);
                break;
 
            case 'd':
                set_debug_options(atoi(optarg), ctx, gucsource);
                break;
 
            case 'E':
                if (secure)
                    EchoQuery = true;
                break;
 
            case 'e':
                SetConfigOption("datestyle", "euro", ctx, gucsource);
                break;
 
            case 'F':
                SetConfigOption("fsync", "false", ctx, gucsource);
                break;
 
            case 'f':
                if (!set_plan_disabling_options(optarg, ctx, gucsource))
                    errs++;
                break;
 
            case 'h':
                SetConfigOption("listen_addresses", optarg, ctx, gucsource);
                break;
 
            case 'i':
                SetConfigOption("listen_addresses", "*", ctx, gucsource);
                break;
 
            case 'j':
                if (secure)
                    UseSemiNewlineNewline = true;
                break;
 
            case 'k':
                SetConfigOption("unix_socket_directories", optarg, ctx, gucsource);
                break;
 
            case 'l':
                SetConfigOption("ssl", "true", ctx, gucsource);
                break;
 
            case 'N':
                SetConfigOption("max_connections", optarg, ctx, gucsource);
                break;
 
            case 'n':
                /* ignored for consistency with postmaster */
                break;
 
            case 'O':
                SetConfigOption("allow_system_table_mods", "true", ctx, gucsource);
                break;
 
            case 'P':
                SetConfigOption("ignore_system_indexes", "true", ctx, gucsource);
                break;
 
            case 'p':
                SetConfigOption("port", optarg, ctx, gucsource);
                break;
 
            case 'r':
                /* send output (stdout and stderr) to the given file */
                if (secure)
                    strlcpy(OutputFileName, optarg, MAXPGPATH);
                break;
 
            case 'S':
                SetConfigOption("work_mem", optarg, ctx, gucsource);
                break;
 
            case 's':
                SetConfigOption("log_statement_stats", "true", ctx, gucsource);
                break;
 
            case 'T':
                /* ignored for consistency with the postmaster */
                break;
 
            case 't':
                {
                    const char *tmp = get_stats_option_name(optarg);
 
                    if (tmp)
                        SetConfigOption(tmp, "true", ctx, gucsource);
                    else
                        errs++;
                    break;
                }
 
            case 'v':
 
                /*
                 * -v is no longer used in normal operation, since
                 * FrontendProtocol is already set before we get here. We keep
                 * the switch only for possible use in standalone operation,
                 * in case we ever support using normal FE/BE protocol with a
                 * standalone backend.
                 */
                if (secure)
                    FrontendProtocol = (ProtocolVersion) atoi(optarg);
                break;
 
            case 'W':
                SetConfigOption("post_auth_delay", optarg, ctx, gucsource);
                break;
 
            default:
                errs++;
                break;
        }
 
        if (errs)
            break;
    }
 
    /*
     * Optional database name should be there only if *dbname is NULL.
     */
    if (!errs && dbname && *dbname == NULL && argc - optind >= 1)
        *dbname = strdup(argv[optind++]);
 
    if (errs || argc != optind)
    {
        if (errs)
            optind--;           /* complain about the previous argument */
 
        /* spell the error message a bit differently depending on context */
        if (IsUnderPostmaster)
            ereport(FATAL,
                    errcode(ERRCODE_SYNTAX_ERROR),
                    errmsg("invalid command-line argument for server process: %s", argv[optind]),
                    errhint("Try \"%s --help\" for more information.", progname));
        else
            ereport(FATAL,
                    errcode(ERRCODE_SYNTAX_ERROR),
                    errmsg("%s: invalid command-line argument: %s",
                           progname, argv[optind]),
                    errhint("Try \"%s --help\" for more information.", progname));
    }
 
    /*
     * Reset getopt(3) library so that it will work correctly in subprocesses
     * or when this function is called a second time with another array.
     */
    optind = 1;
#ifdef HAVE_INT_OPTRESET
    optreset = 1;               /* some systems need this too */
#endif
}

References dbname, EchoQuery, ereport, errcode(), errhint(), errmsg(), ERROR, FATAL, flag(), FrontendProtocol, get_stats_option_name(), getopt(), IsBinaryUpgrade, IsUnderPostmaster, MAXPGPATH, name, optarg, opterr, optind, OutputFileName, ParseLongOption(), pfree(), PGC_POSTMASTER, PGC_S_ARGV, PGC_S_CLIENT, progname, set_debug_options(), set_plan_disabling_options(), SetConfigOption(), strlcpy(), userDoption, UseSemiNewlineNewline, and value.

Referenced by PostgresSingleUserMain(), and process_startup_options().

ProcessClientReadInterrupt()

void ProcessClientReadInterrupt

(

bool

blocked

)

Definition at line 509 of file postgres.c.

{
    int         save_errno = errno;
 
    if (DoingCommandRead)
    {
        /* Check for general interrupts that arrived before/while reading */
        CHECK_FOR_INTERRUPTS();
 
        /* Process sinval catchup interrupts, if any */
        if (catchupInterruptPending)
            ProcessCatchupInterrupt();
 
        /* Process notify interrupts, if any */
        if (notifyInterruptPending)
            ProcessNotifyInterrupt(true);
    }
    else if (ProcDiePending)
    {
        /*
         * We're dying.  If there is no data available to read, then it's safe
         * (and sane) to handle that now.  If we haven't tried to read yet,
         * make sure the process latch is set, so that if there is no data
         * then we'll come back here and die.  If we're done reading, also
         * make sure the process latch is set, as we might've undesirably
         * cleared it while reading.
         */
        if (blocked)
            CHECK_FOR_INTERRUPTS();
        else
            SetLatch(MyLatch);
    }
 
    errno = save_errno;
}

References catchupInterruptPending, CHECK_FOR_INTERRUPTS, DoingCommandRead, MyLatch, notifyInterruptPending, ProcDiePending, ProcessCatchupInterrupt(), ProcessNotifyInterrupt(), and SetLatch().

Referenced by interactive_getc(), and secure_read().

ProcessClientWriteInterrupt()

void ProcessClientWriteInterrupt

(

bool

blocked

)

Definition at line 555 of file postgres.c.

{
    int         save_errno = errno;
 
    if (ProcDiePending)
    {
        /*
         * We're dying.  If it's not possible to write, then we should handle
         * that immediately, else a stuck client could indefinitely delay our
         * response to the signal.  If we haven't tried to write yet, make
         * sure the process latch is set, so that if the write would block
         * then we'll come back here and die.  If we're done writing, also
         * make sure the process latch is set, as we might've undesirably
         * cleared it while writing.
         */
        if (blocked)
        {
            /*
             * Don't mess with whereToSendOutput if ProcessInterrupts wouldn't
             * service ProcDiePending.
             */
            if (InterruptHoldoffCount == 0 && CritSectionCount == 0)
            {
                /*
                 * We don't want to send the client the error message, as a)
                 * that would possibly block again, and b) it would likely
                 * lead to loss of protocol sync because we may have already
                 * sent a partial protocol message.
                 */
                if (whereToSendOutput == DestRemote)
                    whereToSendOutput = DestNone;
 
                CHECK_FOR_INTERRUPTS();
            }
        }
        else
            SetLatch(MyLatch);
    }
 
    errno = save_errno;
}

References CHECK_FOR_INTERRUPTS, CritSectionCount, DestNone, DestRemote, InterruptHoldoffCount, MyLatch, ProcDiePending, SetLatch(), and whereToSendOutput.

Referenced by secure_write().

quickdie()

void quickdie

(

SIGNAL_ARGS

)

Definition at line 2874 of file postgres.c.

{
    sigaddset(&BlockSig, SIGQUIT);  /* prevent nested calls */
    sigprocmask(SIG_SETMASK, &BlockSig, NULL);
 
    /*
     * Prevent interrupts while exiting; though we just blocked signals that
     * would queue new interrupts, one may have been pending.  We don't want a
     * quickdie() downgraded to a mere query cancel.
     */
    HOLD_INTERRUPTS();
 
    /*
     * If we're aborting out of client auth, don't risk trying to send
     * anything to the client; we will likely violate the protocol, not to
     * mention that we may have interrupted the guts of OpenSSL or some
     * authentication library.
     */
    if (ClientAuthInProgress && whereToSendOutput == DestRemote)
        whereToSendOutput = DestNone;
 
    /*
     * Notify the client before exiting, to give a clue on what happened.
     *
     * It's dubious to call ereport() from a signal handler.  It is certainly
     * not async-signal safe.  But it seems better to try, than to disconnect
     * abruptly and leave the client wondering what happened.  It's remotely
     * possible that we crash or hang while trying to send the message, but
     * receiving a SIGQUIT is a sign that something has already gone badly
     * wrong, so there's not much to lose.  Assuming the postmaster is still
     * running, it will SIGKILL us soon if we get stuck for some reason.
     *
     * One thing we can do to make this a tad safer is to clear the error
     * context stack, so that context callbacks are not called.  That's a lot
     * less code that could be reached here, and the context info is unlikely
     * to be very relevant to a SIGQUIT report anyway.
     */
    error_context_stack = NULL;
 
    /*
     * When responding to a postmaster-issued signal, we send the message only
     * to the client; sending to the server log just creates log spam, plus
     * it's more code that we need to hope will work in a signal handler.
     *
     * Ideally these should be ereport(FATAL), but then we'd not get control
     * back to force the correct type of process exit.
     */
    switch (GetQuitSignalReason())
    {
        case PMQUIT_NOT_SENT:
            /* Hmm, SIGQUIT arrived out of the blue */
            ereport(WARNING,
                    (errcode(ERRCODE_ADMIN_SHUTDOWN),
                     errmsg("terminating connection because of unexpected SIGQUIT signal")));
            break;
        case PMQUIT_FOR_CRASH:
            /* A crash-and-restart cycle is in progress */
            ereport(WARNING_CLIENT_ONLY,
                    (errcode(ERRCODE_CRASH_SHUTDOWN),
                     errmsg("terminating connection because of crash of another server process"),
                     errdetail("The postmaster has commanded this server process to roll back"
                               " the current transaction and exit, because another"
                               " server process exited abnormally and possibly corrupted"
                               " shared memory."),
                     errhint("In a moment you should be able to reconnect to the"
                             " database and repeat your command.")));
            break;
        case PMQUIT_FOR_STOP:
            /* Immediate-mode stop */
            ereport(WARNING_CLIENT_ONLY,
                    (errcode(ERRCODE_ADMIN_SHUTDOWN),
                     errmsg("terminating connection due to immediate shutdown command")));
            break;
    }
 
    /*
     * We DO NOT want to run proc_exit() or atexit() callbacks -- we're here
     * because shared memory may be corrupted, so we don't want to try to
     * clean up our transaction.  Just nail the windows shut and get out of
     * town.  The callbacks wouldn't be safe to run from a signal handler,
     * anyway.
     *
     * Note we do _exit(2) not _exit(0).  This is to force the postmaster into
     * a system reset cycle if someone sends a manual SIGQUIT to a random
     * backend.  This is necessary precisely because we don't clean up our
     * shared memory state.  (The "dead man switch" mechanism in pmsignal.c
     * should ensure the postmaster sees this as a crash, too, but no harm in
     * being doubly sure.)
     */
    _exit(2);
}

References BlockSig, ClientAuthInProgress, DestNone, DestRemote, ereport, errcode(), errdetail(), errhint(), errmsg(), error_context_stack, GetQuitSignalReason(), HOLD_INTERRUPTS, PMQUIT_FOR_CRASH, PMQUIT_FOR_STOP, PMQUIT_NOT_SENT, SIGQUIT, WARNING, WARNING_CLIENT_ONLY, and whereToSendOutput.

Referenced by PostgresMain().

ResetUsage()

void ResetUsage

(

void

)

Definition at line 4992 of file postgres.c.

{
    getrusage(RUSAGE_SELF, &Save_r);
    gettimeofday(&Save_t, NULL);
}

References getrusage(), gettimeofday(), RUSAGE_SELF, Save_r, and Save_t.

Referenced by _bt_leader_participate_as_worker(), _bt_leafbuild(), _bt_parallel_build_main(), _SPI_pquery(), btbuild(), exec_bind_message(), exec_execute_message(), exec_parse_message(), exec_simple_query(), pg_analyze_and_rewrite_fixedparams(), pg_analyze_and_rewrite_varparams(), pg_analyze_and_rewrite_withcb(), pg_parse_query(), pg_plan_query(), pg_rewrite_query(), PortalRun(), and PortalRunMulti().

set_debug_options()

void set_debug_options	(	int	debug_flag,
		GucContext	context,
		GucSource	source
	)

Definition at line 3678 of file postgres.c.

{
    if (debug_flag > 0)
    {
        char        debugstr[64];
 
        sprintf(debugstr, "debug%d", debug_flag);
        SetConfigOption("log_min_messages", debugstr, context, source);
    }
    else
        SetConfigOption("log_min_messages", "notice", context, source);
 
    if (debug_flag >= 1 && context == PGC_POSTMASTER)
    {
        SetConfigOption("log_connections", "true", context, source);
        SetConfigOption("log_disconnections", "true", context, source);
    }
    if (debug_flag >= 2)
        SetConfigOption("log_statement", "all", context, source);
    if (debug_flag >= 3)
        SetConfigOption("debug_print_parse", "true", context, source);
    if (debug_flag >= 4)
        SetConfigOption("debug_print_plan", "true", context, source);
    if (debug_flag >= 5)
        SetConfigOption("debug_print_rewritten", "true", context, source);
}

References context, PGC_POSTMASTER, SetConfigOption(), source, and sprintf.

Referenced by PostmasterMain(), and process_postgres_switches().

set_plan_disabling_options()

bool set_plan_disabling_options	(	const char *	arg,
		GucContext	context,
		GucSource	source
	)

Definition at line 3707 of file postgres.c.

{
    const char *tmp = NULL;
 
    switch (arg[0])
    {
        case 's':               /* seqscan */
            tmp = "enable_seqscan";
            break;
        case 'i':               /* indexscan */
            tmp = "enable_indexscan";
            break;
        case 'o':               /* indexonlyscan */
            tmp = "enable_indexonlyscan";
            break;
        case 'b':               /* bitmapscan */
            tmp = "enable_bitmapscan";
            break;
        case 't':               /* tidscan */
            tmp = "enable_tidscan";
            break;
        case 'n':               /* nestloop */
            tmp = "enable_nestloop";
            break;
        case 'm':               /* mergejoin */
            tmp = "enable_mergejoin";
            break;
        case 'h':               /* hashjoin */
            tmp = "enable_hashjoin";
            break;
    }
    if (tmp)
    {
        SetConfigOption(tmp, "false", context, source);
        return true;
    }
    else
        return false;
}

References arg, context, SetConfigOption(), and source.

Referenced by PostmasterMain(), and process_postgres_switches().

ShowUsage()

void ShowUsage

(

const char *

title

)

Definition at line 4999 of file postgres.c.

{
    StringInfoData str;
    struct timeval user,
                sys;
    struct timeval elapse_t;
    struct rusage r;
 
    getrusage(RUSAGE_SELF, &r);
    gettimeofday(&elapse_t, NULL);
    memcpy((char *) &user, (char *) &r.ru_utime, sizeof(user));
    memcpy((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
    if (elapse_t.tv_usec < Save_t.tv_usec)
    {
        elapse_t.tv_sec--;
        elapse_t.tv_usec += 1000000;
    }
    if (r.ru_utime.tv_usec < Save_r.ru_utime.tv_usec)
    {
        r.ru_utime.tv_sec--;
        r.ru_utime.tv_usec += 1000000;
    }
    if (r.ru_stime.tv_usec < Save_r.ru_stime.tv_usec)
    {
        r.ru_stime.tv_sec--;
        r.ru_stime.tv_usec += 1000000;
    }
 
    /*
     * The only stats we don't show here are ixrss, idrss, isrss.  It takes
     * some work to interpret them, and most platforms don't fill them in.
     */
    initStringInfo(&str);
 
    appendStringInfoString(&str, "! system usage stats:\n");
    appendStringInfo(&str,
                     "!\t%ld.%06ld s user, %ld.%06ld s system, %ld.%06ld s elapsed\n",
                     (long) (r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec),
                     (long) (r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec),
                     (long) (r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec),
                     (long) (r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec),
                     (long) (elapse_t.tv_sec - Save_t.tv_sec),
                     (long) (elapse_t.tv_usec - Save_t.tv_usec));
    appendStringInfo(&str,
                     "!\t[%ld.%06ld s user, %ld.%06ld s system total]\n",
                     (long) user.tv_sec,
                     (long) user.tv_usec,
                     (long) sys.tv_sec,
                     (long) sys.tv_usec);
#ifndef WIN32
 
    /*
     * The following rusage fields are not defined by POSIX, but they're
     * present on all current Unix-like systems so we use them without any
     * special checks.  Some of these could be provided in our Windows
     * emulation in src/port/win32getrusage.c with more work.
     */
    appendStringInfo(&str,
                     "!\t%ld kB max resident size\n",
#if defined(__darwin__)
    /* in bytes on macOS */
                     r.ru_maxrss / 1024
#else
    /* in kilobytes on most other platforms */
                     r.ru_maxrss
#endif
        );
    appendStringInfo(&str,
                     "!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
                     r.ru_inblock - Save_r.ru_inblock,
    /* they only drink coffee at dec */
                     r.ru_oublock - Save_r.ru_oublock,
                     r.ru_inblock, r.ru_oublock);
    appendStringInfo(&str,
                     "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
                     r.ru_majflt - Save_r.ru_majflt,
                     r.ru_minflt - Save_r.ru_minflt,
                     r.ru_majflt, r.ru_minflt,
                     r.ru_nswap - Save_r.ru_nswap,
                     r.ru_nswap);
    appendStringInfo(&str,
                     "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
                     r.ru_nsignals - Save_r.ru_nsignals,
                     r.ru_nsignals,
                     r.ru_msgrcv - Save_r.ru_msgrcv,
                     r.ru_msgsnd - Save_r.ru_msgsnd,
                     r.ru_msgrcv, r.ru_msgsnd);
    appendStringInfo(&str,
                     "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
                     r.ru_nvcsw - Save_r.ru_nvcsw,
                     r.ru_nivcsw - Save_r.ru_nivcsw,
                     r.ru_nvcsw, r.ru_nivcsw);
#endif                          /* !WIN32 */
 
    /* remove trailing newline */
    if (str.data[str.len - 1] == '\n')
        str.data[--str.len] = '\0';
 
    ereport(LOG,
            (errmsg_internal("%s", title),
             errdetail_internal("%s", str.data)));
 
    pfree(str.data);
}

References __darwin__, appendStringInfo(), appendStringInfoString(), ereport, errdetail_internal(), errmsg_internal(), getrusage(), gettimeofday(), initStringInfo(), LOG, pfree(), rusage::ru_stime, rusage::ru_utime, RUSAGE_SELF, Save_r, Save_t, str, and user.

Referenced by _bt_leader_participate_as_worker(), _bt_leafbuild(), _bt_parallel_build_main(), _SPI_pquery(), btbuild(), exec_bind_message(), exec_execute_message(), exec_parse_message(), exec_simple_query(), pg_analyze_and_rewrite_fixedparams(), pg_analyze_and_rewrite_varparams(), pg_analyze_and_rewrite_withcb(), pg_parse_query(), pg_plan_query(), pg_rewrite_query(), PortalRun(), and PortalRunMulti().

StatementCancelHandler()

void StatementCancelHandler

(

SIGNAL_ARGS

)

Definition at line 3001 of file postgres.c.

{
    /*
     * Don't joggle the elbow of proc_exit
     */
    if (!proc_exit_inprogress)
    {
        InterruptPending = true;
        QueryCancelPending = true;
    }
 
    /* If we're still here, waken anything waiting on the process latch */
    SetLatch(MyLatch);
}

References InterruptPending, MyLatch, proc_exit_inprogress, QueryCancelPending, and SetLatch().

Referenced by AutoVacWorkerMain(), BackgroundWorkerMain(), PostgresMain(), and WalSndSignals().

Variable Documentation

client_connection_check_interval

PGDLLIMPORT int client_connection_check_interval

extern

Definition at line 104 of file postgres.c.

Referenced by ProcessInterrupts(), and start_xact_command().

debug_query_string

PGDLLIMPORT const char* debug_query_string

extern

Definition at line 87 of file postgres.c.

Referenced by _brin_begin_parallel(), _brin_parallel_build_main(), _bt_begin_parallel(), _bt_parallel_build_main(), check_log_of_query(), current_query(), errstart(), exec_bind_message(), exec_execute_message(), exec_parse_message(), exec_replication_command(), exec_simple_query(), initialize_worker_spi(), parallel_vacuum_init(), parallel_vacuum_main(), ParallelQueryMain(), PostgresMain(), proc_exit_prepare(), send_message_to_server_log(), worker_spi_main(), write_csvlog(), and write_jsonlog().

Log_disconnections

PGDLLIMPORT bool Log_disconnections

extern

Definition at line 93 of file postgres.c.

Referenced by PostgresMain().

log_statement

PGDLLIMPORT int log_statement

extern

Definition at line 95 of file postgres.c.

Referenced by check_log_statement(), and HandleFunctionRequest().

max_stack_depth

PGDLLIMPORT int max_stack_depth

extern

Definition at line 98 of file postgres.c.

Referenced by check_stack_depth().

PostAuthDelay

PGDLLIMPORT int PostAuthDelay

extern

Definition at line 101 of file postgres.c.

Referenced by AutoVacWorkerMain(), BackgroundWorkerMain(), and InitPostgres().

whereToSendOutput

PGDLLIMPORT CommandDest whereToSendOutput

extern

Definition at line 90 of file postgres.c.

Referenced by BackendInitialize(), BeginCopyFrom(), BeginCopyTo(), BeginReportingGUCOptions(), die(), DoCopyTo(), errfinish(), exec_bind_message(), exec_describe_portal_message(), exec_describe_statement_message(), exec_execute_message(), exec_parse_message(), exec_simple_query(), NotifyMyFrontEnd(), PostgresMain(), PostmasterMain(), pq_cleanup_redirect_to_shm_mq(), pq_redirect_to_shm_mq(), ProcessClientWriteInterrupt(), ProcessInterrupts(), quickdie(), ReadCommand(), send_message_to_server_log(), should_output_to_client(), SocketBackend(), SyncRepWaitForLSN(), and SysLoggerMain().