tcopprot.h File Reference

#include "nodes/params.h"
#include "nodes/parsenodes.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 (RawStmt *parsetree, const char *query_string, Oid *paramTypes, int numParams, QueryEnvironment *queryEnv)
List *	pg_analyze_and_rewrite_params (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)
bool	check_max_stack_depth (int *newval, void **extra, GucSource source)
void	assign_max_stack_depth (int newval, void *extra)
void	die (SIGNAL_ARGS)
void	quickdie (SIGNAL_ARGS) pg_attribute_noreturn()
void	StatementCancelHandler (SIGNAL_ARGS)
void	FloatExceptionHandler (SIGNAL_ARGS) pg_attribute_noreturn()
void	RecoveryConflictInterrupt (ProcSignalReason reason)
void	ProcessClientReadInterrupt (bool blocked)
void	ProcessClientWriteInterrupt (bool blocked)
void	process_postgres_switches (int argc, char *argv[], GucContext ctx, const char **dbname)
void	PostgresMain (int argc, char *argv[], 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
CommandDest	whereToSendOutput
PGDLLIMPORT const char *	debug_query_string
int	max_stack_depth
int	PostAuthDelay
int	client_connection_check_interval
PGDLLIMPORT int	log_statement

Macro Definition Documentation

STACK_DEPTH_SLOP

#define STACK_DEPTH_SLOP   (512 * 1024L)

Definition at line 26 of file tcopprot.h.

Referenced by check_max_stack_depth(), and InitializeGUCOptionsFromEnvironment().

Enumeration Type Documentation

LogStmtLevel

enum LogStmtLevel

Enumerator
LOGSTMT_NONE
LOGSTMT_DDL
LOGSTMT_MOD
LOGSTMT_ALL

Definition at line 36 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

assign_max_stack_depth()

void assign_max_stack_depth	(	int	newval,
		void *	extra
	)

Definition at line 3521 of file postgres.c.

References max_stack_depth_bytes.

{
    long        newval_bytes = newval * 1024L;

    max_stack_depth_bytes = newval_bytes;
}

check_log_duration()

int check_log_duration	(	char *	msec_str,
		bool	was_logged
	)

Definition at line 2306 of file postgres.c.

References GetCurrentStatementStartTimestamp(), GetCurrentTimestamp(), log_duration, log_min_duration_sample, log_min_duration_statement, log_statement_sample_rate, MAX_RANDOM_VALUE, random(), snprintf, TimestampDifference(), and xact_is_sampled.

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

{
    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 random() call
         * if log_statement_sample_rate = 1.
         */
        if (exceeded_sample_duration)
            in_sample = log_statement_sample_rate != 0 &&
                (log_statement_sample_rate == 1 ||
                 random() <= log_statement_sample_rate * MAX_RANDOM_VALUE);

        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;
}

check_max_stack_depth()

bool check_max_stack_depth	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 3504 of file postgres.c.

References get_stack_depth_rlimit(), GUC_check_errdetail, GUC_check_errhint, and STACK_DEPTH_SLOP.

{
    long        newval_bytes = *newval * 1024L;
    long        stack_rlimit = get_stack_depth_rlimit();

    if (stack_rlimit > 0 && newval_bytes > stack_rlimit - STACK_DEPTH_SLOP)
    {
        GUC_check_errdetail("\"max_stack_depth\" must not exceed %ldkB.",
                            (stack_rlimit - STACK_DEPTH_SLOP) / 1024L);
        GUC_check_errhint("Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent.");
        return false;
    }
    return true;
}

die()

void die

(

SIGNAL_ARGS

)

Definition at line 2897 of file postgres.c.

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

Referenced by PostgresMain().

{
    int         save_errno = errno;

    /* Don't joggle the elbow of proc_exit */
    if (!proc_exit_inprogress)
    {
        InterruptPending = true;
        ProcDiePending = true;
    }

    /* for the statistics collector */
    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();

    errno = save_errno;
}

FloatExceptionHandler()

void FloatExceptionHandler

(

SIGNAL_ARGS

)

Definition at line 2952 of file postgres.c.

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

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), plperl_init_interp(), PostgresMain(), and StartBackgroundWorker().

{
    /* 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.")));
}

get_stack_depth_rlimit()

long get_stack_depth_rlimit

(

void

)

Definition at line 4724 of file postgres.c.

References val.

Referenced by check_max_stack_depth(), and InitializeGUCOptionsFromEnvironment().

{
#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_STACK)
    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                           /* no getrlimit */
#if defined(WIN32) || defined(__CYGWIN__)
    /* On Windows we set the backend stack size in src/backend/Makefile */
    return WIN32_STACK_RLIMIT;
#else                           /* not windows ... give up */
    return -1;
#endif
#endif
}

get_stats_option_name()

const char* get_stats_option_name

(

const char *

arg

)

Definition at line 3607 of file postgres.c.

References optarg.

Referenced by PostmasterMain(), and process_postgres_switches().

{
    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;
}

pg_analyze_and_rewrite()

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

Definition at line 624 of file postgres.c.

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

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

{
    Query      *query;
    List       *querytree_list;

    TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);

    /*
     * (1) Perform parse analysis.
     */
    if (log_parser_stats)
        ResetUsage();

    query = parse_analyze(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;
}

pg_analyze_and_rewrite_params()

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

Definition at line 661 of file postgres.c.

References Assert, compute_query_id, free_parsestate(), JumbleQuery(), log_parser_stats, make_parsestate(), ParseState::p_queryEnv, ParseState::p_sourcetext, pg_rewrite_query(), pgstat_report_query_id(), post_parse_analyze_hook, ResetUsage(), ShowUsage(), and transformTopLevelStmt().

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

{
    ParseState *pstate;
    Query      *query;
    List       *querytree_list;
    JumbleState *jstate = NULL;

    Assert(query_string != NULL);   /* required as of 8.4 */

    TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);

    /*
     * (1) Perform parse analysis.
     */
    if (log_parser_stats)
        ResetUsage();

    pstate = make_parsestate(NULL);
    pstate->p_sourcetext = query_string;
    pstate->p_queryEnv = queryEnv;
    (*parserSetup) (pstate, parserSetupArg);

    query = transformTopLevelStmt(pstate, parsetree);

    if (compute_query_id)
        jstate = JumbleQuery(query, query_string);

    if (post_parse_analyze_hook)
        (*post_parse_analyze_hook) (pstate, query, jstate);

    free_parsestate(pstate);

    pgstat_report_query_id(query->queryId, false);

    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;
}

pg_parse_query()

List* pg_parse_query

(

const char *

query_string

)

Definition at line 576 of file postgres.c.

References copyObject, elog, equal(), log_parser_stats, new_list(), RAW_PARSE_DEFAULT, raw_parser(), ResetUsage(), ShowUsage(), 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().

{
    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

    /*
     * Currently, outfuncs/readfuncs support is missing for many raw parse
     * tree nodes, so we don't try to implement WRITE_READ_PARSE_PLAN_TREES
     * here.
     */

    TRACE_POSTGRESQL_QUERY_PARSE_DONE(query_string);

    return raw_parsetree_list;
}

pg_plan_queries()

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

Definition at line 897 of file postgres.c.

References PlannedStmt::canSetTag, Query::canSetTag, CMD_UTILITY, PlannedStmt::commandType, Query::commandType, lappend(), lfirst_node, makeNode, NIL, pg_plan_query(), PlannedStmt::queryId, Query::queryId, PlannedStmt::stmt_len, Query::stmt_len, PlannedStmt::stmt_location, Query::stmt_location, PlannedStmt::utilityStmt, and Query::utilityStmt.

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

{
    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;
}

pg_plan_query()

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

Definition at line 811 of file postgres.c.

References ActiveSnapshotSet(), Assert, CMD_UTILITY, Query::commandType, copyObject, Debug_pretty_print, Debug_print_plan, elog, elog_node_display(), equal(), LOG, log_planner_stats, nodeToString(), pfree(), planner(), ResetUsage(), ShowUsage(), generate_unaccent_rules::str, and WARNING.

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

{
    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 = nodeToString(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;
}

pg_rewrite_query()

List* pg_rewrite_query

(

Query *

query

)

Definition at line 719 of file postgres.c.

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

Referenced by exec_parse_message(), init_sql_fcache(), inline_set_returning_function(), pg_analyze_and_rewrite(), and pg_analyze_and_rewrite_params().

{
    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 equal 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;

        /*
         * We currently lack outfuncs/readfuncs support for most utility
         * statement types, so only attempt to write/read non-utility queries.
         */
        foreach(lc, querytree_list)
        {
            Query      *query = castNode(Query, lfirst(lc));

            if (query->commandType != CMD_UTILITY)
            {
                char       *str = nodeToString(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 = query->queryId;

                new_list = lappend(new_list, new_query);
                pfree(str);
            }
            else
                new_list = lappend(new_list, query);
        }

        /* This checks both outfuncs/readfuncs and the equal() routines... */
        if (!equal(new_list, querytree_list))
            elog(WARNING, "outfuncs/readfuncs failed to produce equal 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;
}

PostgresMain()

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

Definition at line 3902 of file postgres.c.

References AbortCurrentTransaction(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, am_walsender, BaseInit(), BeginReportingGUCOptions(), buf, ChangeToDataDir(), CHECK_FOR_INTERRUPTS, checkDataDir(), ConfigReloadPending, CreateDataDirLockFile(), 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, 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(), GetCurrentTimestamp(), GetPortalByName(), HandleFunctionRequest(), HOLD_INTERRUPTS, i, IDLE_IN_TRANSACTION_SESSION_TIMEOUT, IDLE_SESSION_TIMEOUT, IdleInTransactionSessionTimeout, IdleSessionTimeout, ignore_till_sync, InitializeGUCOptions(), InitializeMaxBackends(), InitializeTimeouts(), InitPostgres(), InitProcess(), InitProcessing, InitStandaloneProcess(), initStringInfo(), InitWalSender(), InvalidateCatalogSnapshotConditionally(), InvalidOid, IsAbortedTransactionBlockState(), IsTransactionOrTransactionBlock(), IsUnderPostmaster, jit_reset_after_error(), LocalProcessControlFile(), Log_disconnections, log_disconnections(), MemoryContextDelete(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), MessageContext, MyCancelKey, MyProcPid, MyReplicationSlot, NormalProcessing, notifyInterruptPending, on_proc_exit(), palloc(), PG_exception_stack, PG_SETMASK, PGC_POSTMASTER, PGC_SIGHUP, PgStartTime, pgstat_report_activity(), 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(), pqsignal(), printf, proc_exit(), process_postgres_switches(), process_session_preload_libraries(), ProcessCompletedNotifies(), ProcessConfigFile(), ProcessNotifyInterrupt(), procsignal_sigusr1_handler(), progname, QueryCancelPending, quickdie(), ReadCommand(), ReadyForQuery(), ReplicationSlotCleanup(), ReplicationSlotRelease(), ReportChangedGUCOptions(), RESUME_INTERRUPTS, SelectConfigFiles(), set_ps_display(), SetCurrentStatementStartTimestamp(), SetProcessingMode, SIG_DFL, SIG_IGN, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SIGPIPE, SIGQUIT, SIGUSR1, SIGUSR2, SPICleanup(), start_xact_command(), STATE_FASTPATH, STATE_IDLE, STATE_IDLEINTRANSACTION, STATE_IDLEINTRANSACTION_ABORTED, StatementCancelHandler(), TopMemoryContext, UnBlockSig, userDoption, username, WalSndErrorCleanup(), WalSndSignals(), whereToSendOutput, and xact_started.

Referenced by BackendRun(), and main().

{
    int         firstchar;
    StringInfoData input_message;
    sigjmp_buf  local_sigjmp_buf;
    volatile bool send_ready_for_query = true;
    bool        idle_in_transaction_timeout_enabled = false;
    bool        idle_session_timeout_enabled = false;

    /* Initialize startup process environment if necessary. */
    if (!IsUnderPostmaster)
        InitStandaloneProcess(argv[0]);

    SetProcessingMode(InitProcessing);

    /*
     * Set default values for command-line options.
     */
    if (!IsUnderPostmaster)
        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, unless inherited from postmaster */
    if (!IsUnderPostmaster)
    {
        if (!SelectConfigFiles(userDoption, progname))
            proc_exit(1);
    }

    /*
     * 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 */
    }

    if (!IsUnderPostmaster)
    {
        /*
         * Validate we have been given a reasonable-looking DataDir (if under
         * postmaster, assume postmaster did this already).
         */
        checkDataDir();

        /* Change into DataDir (if under postmaster, was done already) */
        ChangeToDataDir();

        /*
         * Create lockfile for data directory.
         */
        CreateDataDirLockFile(false);

        /* read control file (error checking and contains config ) */
        LocalProcessControlFile(false);

        /* Initialize MaxBackends (if under postmaster, was done already) */
        InitializeMaxBackends();
    }

    /* Early initialization */
    BaseInit();

    /*
     * Create a per-backend PGPROC struct in shared memory, except in the
     * EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
     * this before we can use LWLocks (and in the EXEC_BACKEND case we already
     * had to do some stuff with LWLocks).
     */
#ifdef EXEC_BACKEND
    if (!IsUnderPostmaster)
        InitProcess();
#else
    InitProcess();
#endif

    /* We need to allow SIGINT, etc during the initial transaction */
    PG_SETMASK(&UnBlockSig);

    /*
     * 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.
     */
    InitPostgres(dbname, InvalidOid, username, InvalidOid, NULL, false);

    /*
     * If the PostmasterContext is still around, recycle the space; we don't
     * need it anymore after InitPostgres completes.  Note this does not trash
     * *MyProcPort, because ConnCreate() allocated that space with malloc()
     * ... else we'd need to copy the Port data first.  Also, subsidiary data
     * such as the username isn't lost either; see ProcessStartupPacket().
     */
    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);

    /* Perform initialization specific to a WAL sender process. */
    if (am_walsender)
        InitWalSender();

    /*
     * process any libraries that should be preloaded at backend start (this
     * likewise can't be done until GUC settings are complete)
     */
    process_session_preload_libraries();

    /*
     * Send this backend's cancellation info to the frontend.
     */
    if (whereToSendOutput == DestRemote)
    {
        StringInfoData buf;

        pq_beginmessage(&buf, 'K');
        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);

    /*
     * Remember stand-alone backend startup time
     */
    if (!IsUnderPostmaster)
        PgStartTime = GetCurrentTimestamp();

    /*
     * 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);
        QueryCancelPending = false; /* second to avoid race condition */

        /* 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();

        /*
         * 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();
        SPICleanup();

        /*
         * 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's another cleanup in ProcKill()
         * ensuring we'll correctly cleanup on FATAL errors as well.
         */
        if (MyReplicationSlot != NULL)
            ReplicationSlotRelease();

        /* We also want to cleanup temporary slots on error. */
        ReplicationSlotCleanup();

        jit_reset_after_error();

        /*
         * Now return to normal top-level context and clear ErrorContext for
         * next time.
         */
        MemoryContextSwitchTo(TopMemoryContext);
        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 (;;)
    {
        /*
         * 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;

        /*
         * Release storage left over from prior query cycle, and create a new
         * query input buffer in the cleared MessageContext.
         */
        MemoryContextSwitchTo(MessageContext);
        MemoryContextResetAndDeleteChildren(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 send collected statistics to the
         * collector, 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)
                {
                    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)
                {
                    idle_in_transaction_timeout_enabled = true;
                    enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
                                         IdleInTransactionSessionTimeout);
                }
            }
            else
            {
                /* Send out notify signals and transmit self-notifies */
                ProcessCompletedNotifies();

                /*
                 * Also process incoming notifies, if any.  This is mostly to
                 * 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();

                pgstat_report_stat(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 'Q':           /* simple 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);

                    send_ready_for_query = true;
                }
                break;

            case 'P':           /* 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 = (Oid *) palloc(numParams * sizeof(Oid));
                        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);
                }
                break;

            case 'B':           /* 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);
                break;

            case 'E':           /* 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);
                }
                break;

            case 'F':           /* fastpath function call */
                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();

                send_ready_for_query = true;
                break;

            case 'C':           /* 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('3');    /* CloseComplete */
                }
                break;

            case 'D':           /* 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;
                    }
                }
                break;

            case 'H':           /* flush */
                pq_getmsgend(&input_message);
                if (whereToSendOutput == DestRemote)
                    pq_flush();
                break;

            case 'S':           /* sync */
                pq_getmsgend(&input_message);
                finish_xact_command();
                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 statistics collector */
                pgStatSessionEndCause = DISCONNECT_CLIENT_EOF;

                /* FALLTHROUGH */

            case 'X':

                /*
                 * 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 'd':           /* copy data */
            case 'c':           /* copy done */
            case 'f':           /* copy fail */

                /*
                 * 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 */
}

process_postgres_switches()

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

Definition at line 3647 of file postgres.c.

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

Referenced by PostgresMain(), and process_startup_options().

{
    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 '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;

            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);
                    free(name);
                    if (value)
                        free(value);
                    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
}

ProcessClientReadInterrupt()

void ProcessClientReadInterrupt

(

bool

blocked

)

Definition at line 474 of file postgres.c.

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

Referenced by interactive_getc(), and secure_read().

{
    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();
    }
    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;
}

ProcessClientWriteInterrupt()

void ProcessClientWriteInterrupt

(

bool

blocked

)

Definition at line 520 of file postgres.c.

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

Referenced by secure_write().

{
    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
             * do anything.
             */
            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;
}

quickdie()

void quickdie

(

SIGNAL_ARGS

)

Definition at line 2800 of file postgres.c.

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

Referenced by PostgresMain().

{
    sigaddset(&BlockSig, SIGQUIT);  /* prevent nested calls */
    PG_SETMASK(&BlockSig);

    /*
     * 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);
}

RecoveryConflictInterrupt()

void RecoveryConflictInterrupt

(

ProcSignalReason

reason

)

Definition at line 2970 of file postgres.c.

References Assert, CheckDeadLockAlert(), elog, FATAL, GetStartupBufferPinWaitBufId(), HoldingBufferPinThatDelaysRecovery(), InterruptPending, IsAbortedTransactionBlockState(), IsSubTransaction(), IsTransactionOrTransactionBlock(), IsWaitingForLock(), MyLatch, MyProc, proc_exit_inprogress, ProcDiePending, PROCSIG_RECOVERY_CONFLICT_BUFFERPIN, PROCSIG_RECOVERY_CONFLICT_DATABASE, PROCSIG_RECOVERY_CONFLICT_LOCK, PROCSIG_RECOVERY_CONFLICT_SNAPSHOT, PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK, PROCSIG_RECOVERY_CONFLICT_TABLESPACE, QueryCancelPending, PGPROC::recoveryConflictPending, RecoveryConflictPending, RecoveryConflictReason, RecoveryConflictRetryable, and SetLatch().

Referenced by procsignal_sigusr1_handler().

{
    int         save_errno = errno;

    /*
     * Don't joggle the elbow of proc_exit
     */
    if (!proc_exit_inprogress)
    {
        RecoveryConflictReason = reason;
        switch (reason)
        {
            case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:

                /*
                 * If we aren't waiting for a lock we can never deadlock.
                 */
                if (!IsWaitingForLock())
                    return;

                /* Intentional fall through to check wait for pin */
                /* FALLTHROUGH */

            case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:

                /*
                 * If PROCSIG_RECOVERY_CONFLICT_BUFFERPIN is requested but we
                 * aren't blocking the Startup process there is nothing more
                 * to do.
                 *
                 * When PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK is
                 * requested, if we're waiting for locks and the startup
                 * process is not waiting for buffer pin (i.e., also waiting
                 * for locks), we set the flag so that ProcSleep() will check
                 * for deadlocks.
                 */
                if (!HoldingBufferPinThatDelaysRecovery())
                {
                    if (reason == PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK &&
                        GetStartupBufferPinWaitBufId() < 0)
                        CheckDeadLockAlert();
                    return;
                }

                MyProc->recoveryConflictPending = true;

                /* Intentional fall through to error handling */
                /* FALLTHROUGH */

            case PROCSIG_RECOVERY_CONFLICT_LOCK:
            case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
            case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:

                /*
                 * If we aren't in a transaction any longer then ignore.
                 */
                if (!IsTransactionOrTransactionBlock())
                    return;

                /*
                 * If we can abort just the current subtransaction then we are
                 * OK to throw an ERROR to resolve the conflict. Otherwise
                 * drop through to the FATAL case.
                 *
                 * XXX other times that we can throw just an ERROR *may* be
                 * PROCSIG_RECOVERY_CONFLICT_LOCK if no locks are held in
                 * parent transactions
                 *
                 * PROCSIG_RECOVERY_CONFLICT_SNAPSHOT if no snapshots are held
                 * by parent transactions and the transaction is not
                 * transaction-snapshot mode
                 *
                 * PROCSIG_RECOVERY_CONFLICT_TABLESPACE if no temp files or
                 * cursors open in parent transactions
                 */
                if (!IsSubTransaction())
                {
                    /*
                     * If we already aborted then we no longer need to cancel.
                     * We do this here since we do not wish to ignore aborted
                     * subtransactions, which must cause FATAL, currently.
                     */
                    if (IsAbortedTransactionBlockState())
                        return;

                    RecoveryConflictPending = true;
                    QueryCancelPending = true;
                    InterruptPending = true;
                    break;
                }

                /* Intentional fall through to session cancel */
                /* FALLTHROUGH */

            case PROCSIG_RECOVERY_CONFLICT_DATABASE:
                RecoveryConflictPending = true;
                ProcDiePending = true;
                InterruptPending = true;
                break;

            default:
                elog(FATAL, "unrecognized conflict mode: %d",
                     (int) reason);
        }

        Assert(RecoveryConflictPending && (QueryCancelPending || ProcDiePending));

        /*
         * All conflicts apart from database cause dynamic errors where the
         * command or transaction can be retried at a later point with some
         * potential for success. No need to reset this, since non-retryable
         * conflict errors are currently FATAL.
         */
        if (reason == PROCSIG_RECOVERY_CONFLICT_DATABASE)
            RecoveryConflictRetryable = false;
    }

    /*
     * Set the process latch. This function essentially emulates signal
     * handlers like die() and StatementCancelHandler() and it seems prudent
     * to behave similarly as they do.
     */
    SetLatch(MyLatch);

    errno = save_errno;
}

ResetUsage()

void ResetUsage

(

void

)

Definition at line 4760 of file postgres.c.

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(), pg_analyze_and_rewrite_params(), pg_parse_query(), pg_plan_query(), pg_rewrite_query(), PortalRun(), and PortalRunMulti().

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

set_debug_options()

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

Definition at line 3536 of file postgres.c.

References PGC_POSTMASTER, SetConfigOption(), and sprintf.

Referenced by PostmasterMain(), and process_postgres_switches().

{
    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);
}

set_plan_disabling_options()

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

Definition at line 3565 of file postgres.c.

References SetConfigOption().

Referenced by PostmasterMain(), and process_postgres_switches().

{
    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;
}

ShowUsage()

void ShowUsage

(

const char *

title

)

Definition at line 4767 of file postgres.c.

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

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(), pg_analyze_and_rewrite_params(), pg_parse_query(), pg_plan_query(), pg_rewrite_query(), PortalRun(), and PortalRunMulti().

{
    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);
#if defined(HAVE_GETRUSAGE)
    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                          /* HAVE_GETRUSAGE */

    /* 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);
}

StatementCancelHandler()

void StatementCancelHandler

(

SIGNAL_ARGS

)

Definition at line 2931 of file postgres.c.

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

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), PostgresMain(), StartBackgroundWorker(), and WalSndSignals().

{
    int         save_errno = errno;

    /*
     * 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);

    errno = save_errno;
}

Variable Documentation

client_connection_check_interval

int client_connection_check_interval

Definition at line 106 of file postgres.c.

Referenced by ProcessInterrupts(), and start_xact_command().

debug_query_string

PGDLLIMPORT const char* debug_query_string

Definition at line 89 of file postgres.c.

Referenced by _bt_begin_parallel(), _bt_parallel_build_main(), begin_parallel_vacuum(), current_query(), errstart(), exec_bind_message(), exec_execute_message(), exec_parse_message(), exec_replication_command(), exec_simple_query(), initialize_worker_spi(), parallel_vacuum_main(), ParallelQueryMain(), PostgresMain(), proc_exit_prepare(), send_message_to_server_log(), and write_csvlog().

log_statement

PGDLLIMPORT int log_statement

Definition at line 97 of file postgres.c.

Referenced by check_log_statement(), and HandleFunctionRequest().

max_stack_depth

int max_stack_depth

Definition at line 100 of file postgres.c.

Referenced by check_stack_depth().

PostAuthDelay

int PostAuthDelay

Definition at line 103 of file postgres.c.

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), InitPostgres(), and StartBackgroundWorker().

whereToSendOutput

CommandDest whereToSendOutput

Definition at line 92 of file postgres.c.

Referenced by BackendInitialize(), BackendRun(), 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(), SysLoggerMain(), and WalSndResourceCleanup().