#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_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, int cursorOptions, ParamListInfo boundParams)

List *	pg_plan_queries (List *querytrees, 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	log_statement

Macro Definition Documentation

#define STACK_DEPTH_SLOP (512 * 1024L)

Definition at line 31 of file tcopprot.h.

Referenced by check_max_stack_depth(), and InitializeGUCOptionsFromEnvironment().

Enumeration Type Documentation

enum LogStmtLevel

Enumerator
LOGSTMT_NONE
LOGSTMT_DDL
LOGSTMT_MOD
LOGSTMT_ALL

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

void assign_max_stack_depth	(	int	newval,
		void *	extra
	)

Definition at line 3197 of file postgres.c.

References max_stack_depth_bytes.

 {
     long        newval_bytes = newval * 1024L;
 
     max_stack_depth_bytes = newval_bytes;
 }

int check_log_duration	(	char *	msec_str,
		bool	was_logged
	)

Definition at line 2100 of file postgres.c.

References GetCurrentStatementStartTimestamp(), GetCurrentTimestamp(), log_duration, log_min_duration_statement, snprintf(), and TimestampDifference().

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

 {
     if (log_duration || log_min_duration_statement >= 0)
     {
         long        secs;
         int         usecs;
         int         msecs;
         bool        exceeded;
 
         TimestampDifference(GetCurrentStatementStartTimestamp(),
                             GetCurrentTimestamp(),
                             &secs, &usecs);
         msecs = usecs / 1000;
 
         /*
          * This odd-looking test for log_min_duration_statement 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 = (log_min_duration_statement == 0 ||
                     (log_min_duration_statement > 0 &&
                      (secs > log_min_duration_statement / 1000 ||
                       secs * 1000 + msecs >= log_min_duration_statement)));
 
         if (exceeded || log_duration)
         {
             snprintf(msec_str, 32, "%ld.%03d",
                      secs * 1000 + msecs, usecs % 1000);
             if (exceeded && !was_logged)
                 return 2;
             else
                 return 1;
         }
     }
 
     return 0;
 }

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

Definition at line 3180 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;
 }

void die ( SIGNAL_ARGS )

Definition at line 2617 of file postgres.c.

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

Referenced by ApplyLauncherMain(), ApplyWorkerMain(), AutoVacWorkerMain(), bootstrap_signals(), ParallelWorkerMain(), PostgresMain(), and WalSndSignals().

 {
     int         save_errno = errno;
 
     /* Don't joggle the elbow of proc_exit */
     if (!proc_exit_inprogress)
     {
         InterruptPending = true;
         ProcDiePending = true;
     }
 
     /* 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;
 }

void FloatExceptionHandler ( SIGNAL_ARGS )

Definition at line 2669 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.")));
 }

long get_stack_depth_rlimit ( void )

Definition at line 4352 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
 }

const char* get_stats_option_name ( const char * arg )

Definition at line 3283 of file postgres.c.

References NULL, and 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;
 }

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

Definition at line 638 of file postgres.c.

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

Referenced by _SPI_execute_plan(), _SPI_prepare_plan(), BeginCopy(), 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;
 }

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

Definition at line 675 of file postgres.c.

References Assert, free_parsestate(), log_parser_stats, make_parsestate(), NULL, ParseState::p_queryEnv, ParseState::p_sourcetext, pg_rewrite_query(), 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;
 
     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 (post_parse_analyze_hook)
         (*post_parse_analyze_hook) (pstate, query);
 
     free_parsestate(pstate);
 
     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;
 }

List* pg_parse_query ( const char * query_string )

Definition at line 596 of file postgres.c.

References copyObject, elog, equal(), log_parser_stats, new_list(), raw_parser(), ResetUsage(), ShowUsage(), and WARNING.

Referenced by _SPI_prepare_oneshot_plan(), _SPI_prepare_plan(), 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);
 
     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
 
     TRACE_POSTGRESQL_QUERY_PARSE_DONE(query_string);
 
     return raw_parsetree_list;
 }

List* pg_plan_queries	(	List *	querytrees,
		int	cursorOptions,
		ParamListInfo	boundParams
	)

Definition at line 840 of file postgres.c.

References PlannedStmt::canSetTag, Query::canSetTag, CMD_UTILITY, PlannedStmt::commandType, Query::commandType, lappend(), lfirst_node, makeNode, NIL, pg_plan_query(), 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;
         }
         else
         {
             stmt = pg_plan_query(query, cursorOptions, boundParams);
         }
 
         stmt_list = lappend(stmt_list, stmt);
     }
 
     return stmt_list;
 }

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

Definition at line 779 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, NULL, planner(), ResetUsage(), ShowUsage(), and WARNING.

Referenced by BeginCopy(), 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, cursorOptions, boundParams);
 
     if (log_planner_stats)
         ShowUsage("PLANNER STATISTICS");
 
 #ifdef COPY_PARSE_PLAN_TREES
     /* Optional debugging check: pass plan output 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
 
     /*
      * Print plan if debugging.
      */
     if (Debug_print_plan)
         elog_node_display(LOG, "plan", plan, Debug_pretty_print);
 
     TRACE_POSTGRESQL_QUERY_PLAN_DONE();
 
     return plan;
 }

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

Definition at line 3582 of file postgres.c.

References AbortCurrentTransaction(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate(), am_walsender, Assert, BaseInit(), BeginReportingGUCOptions(), BlockSig, buf, ChangeToDataDir(), CHECK_FOR_INTERRUPTS, ConfigReloadPending, CreateDataDirLockFile(), DataDir, debug_query_string, DestDebug, DestNone, DestRemote, die(), disable_all_timeouts(), disable_timeout(), 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, IdleInTransactionSessionTimeout, ignore_till_sync, InitializeGUCOptions(), InitializeMaxBackends(), InitializeTimeouts(), InitPostgres(), InitProcess(), InitProcessing, InitStandaloneProcess(), initStringInfo(), InitWalSender(), InvalidateCatalogSnapshotConditionally(), InvalidOid, IsAbortedTransactionBlockState(), IsTransactionOrTransactionBlock(), IsUnderPostmaster, Log_disconnections, log_disconnections(), MemoryContextDelete(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), MessageContext, MyCancelKey, MyProcPid, MyReplicationSlot, NormalProcessing, NULL, on_proc_exit(), palloc(), PG_exception_stack, PG_SETMASK, PGC_POSTMASTER, PGC_SIGHUP, PgStartTime, pgstat_report_activity(), pgstat_report_stat(), PortalDrop(), PortalIsValid, PostgresSigHupHandler(), 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_sendint(), pqinitmask(), pqsignal(), proc_exit(), process_postgres_switches(), process_session_preload_libraries(), ProcessCompletedNotifies(), ProcessConfigFile(), procsignal_sigusr1_handler(), progname, QueryCancelPending, quickdie(), ReadCommand(), ReadyForQuery(), ReplicationSlotCleanup(), ReplicationSlotRelease(), RESUME_INTERRUPTS, SelectConfigFiles(), set_ps_display(), SetCurrentStatementStartTimestamp(), SetProcessingMode, SIG_DFL, SIG_IGN, SIGCHLD, SIGHUP, SIGPIPE, SIGQUIT, SIGUSR1, SIGUSR2, start_xact_command(), STATE_FASTPATH, STATE_IDLE, STATE_IDLEINTRANSACTION, STATE_IDLEINTRANSACTION_ABORTED, StatementCancelHandler(), TopMemoryContext, UnBlockSig, userDoption, username, ValidatePgVersion(), 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        disable_idle_in_transaction_timeout = 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 and masks.
      *
      * 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, PostgresSigHupHandler);    /* set flag to read config
                                                      * file */
         pqsignal(SIGINT, StatementCancelHandler);   /* cancel current query */
         pqsignal(SIGTERM, die); /* cancel current query and exit */
 
         /*
          * 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 */
     }
 
     pqinitmask();
 
     if (IsUnderPostmaster)
     {
         /* We allow SIGQUIT (quickdie) at all times */
         sigdelset(&BlockSig, SIGQUIT);
     }
 
     PG_SETMASK(&BlockSig);      /* block everything except SIGQUIT */
 
     if (!IsUnderPostmaster)
     {
         /*
          * Validate we have been given a reasonable-looking DataDir (if under
          * postmaster, assume postmaster did this already).
          */
         Assert(DataDir);
         ValidatePgVersion(DataDir);
 
         /* Change into DataDir (if under postmaster, was done already) */
         ChangeToDataDir();
 
         /*
          * Create lockfile for data directory.
          */
         CreateDataDirLockFile(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);
 
     /*
      * 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_sendint(&buf, (int32) MyProcPid, sizeof(int32));
         pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
         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);
 
     /*
      * 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();
 
         /*
          * 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();
 
         /*
          * 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.
          */
         if (send_ready_for_query)
         {
             if (IsAbortedTransactionBlockState())
             {
                 set_ps_display("idle in transaction (aborted)", false);
                 pgstat_report_activity(STATE_IDLEINTRANSACTION_ABORTED, NULL);
 
                 /* Start the idle-in-transaction timer */
                 if (IdleInTransactionSessionTimeout > 0)
                 {
                     disable_idle_in_transaction_timeout = true;
                     enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
                                          IdleInTransactionSessionTimeout);
                 }
             }
             else if (IsTransactionOrTransactionBlock())
             {
                 set_ps_display("idle in transaction", false);
                 pgstat_report_activity(STATE_IDLEINTRANSACTION, NULL);
 
                 /* Start the idle-in-transaction timer */
                 if (IdleInTransactionSessionTimeout > 0)
                 {
                     disable_idle_in_transaction_timeout = true;
                     enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
                                          IdleInTransactionSessionTimeout);
                 }
             }
             else
             {
                 ProcessCompletedNotifies();
                 pgstat_report_stat(false);
 
                 set_ps_display("idle", false);
                 pgstat_report_activity(STATE_IDLE, NULL);
             }
 
             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) 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;
 
         /*
          * (5) turn off the idle-in-transaction timeout
          */
         if (disable_idle_in_transaction_timeout)
         {
             disable_timeout(IDLE_IN_TRANSACTION_SESSION_TIMEOUT, false);
             disable_idle_in_transaction_timeout = 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)
                     {
                         int         i;
 
                         paramTypes = (Oid *) palloc(numParams * sizeof(Oid));
                         for (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>", false);
 
                 /* 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 'X':
             case EOF:
 
                 /*
                  * 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 */
 }

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

Definition at line 3323 of file postgres.c.

References EchoQuery, ereport, errcode(), errhint(), errmsg(), ERROR, FATAL, flag(), free, FrontendProtocol, get_stats_option_name(), getopt(), IsBinaryUpgrade, IsUnderPostmaster, MAXPGPATH, name, NULL, 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:nOo:Pp: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 'o':
                 errs++;
                 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
 }

void ProcessClientReadInterrupt ( bool blocked )

Definition at line 516 of file postgres.c.

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

Referenced by interactive_getc(), and secure_read().

 {
     int         save_errno = errno;
 
     if (DoingCommandRead)
     {
         /* Check for general interrupts that arrived while reading */
         CHECK_FOR_INTERRUPTS();
 
         /* Process sinval catchup interrupts that happened while reading */
         if (catchupInterruptPending)
             ProcessCatchupInterrupt();
 
         /* Process sinval catchup interrupts that happened while reading */
         if (notifyInterruptPending)
             ProcessNotifyInterrupt();
     }
     else if (ProcDiePending && blocked)
     {
         /*
          * We're dying. It's safe (and sane) to handle that now.
          */
         CHECK_FOR_INTERRUPTS();
     }
 
     errno = save_errno;
 }

void ProcessClientWriteInterrupt ( bool blocked )

Definition at line 554 of file postgres.c.

References CHECK_FOR_INTERRUPTS, DestNone, DestRemote, ProcDiePending, and whereToSendOutput.

Referenced by secure_write().

 {
     int         save_errno = errno;
 
     /*
      * We only want to process the interrupt here if socket writes are
      * blocking to increase the chance to get an error message to the client.
      * If we're not blocked there'll soon be a CHECK_FOR_INTERRUPTS(). But if
      * we're blocked we'll never get out of that situation if the client has
      * died.
      */
     if (ProcDiePending && blocked)
     {
         /*
          * We're dying. It's safe (and sane) to handle that now. But we don't
          * want to send the client the error message as that a) would possibly
          * block again b) would possibly lead to sending an error message to
          * the client, while we already started to send something else.
          */
         if (whereToSendOutput == DestRemote)
             whereToSendOutput = DestNone;
 
         CHECK_FOR_INTERRUPTS();
     }
 
     errno = save_errno;
 }

void quickdie ( SIGNAL_ARGS )

Definition at line 2556 of file postgres.c.

References BlockSig, ClientAuthInProgress, DestNone, DestRemote, ereport, errcode(), errdetail(), errhint(), errmsg(), HOLD_INTERRUPTS, on_exit_reset(), PG_SETMASK, SIGQUIT, WARNING, and whereToSendOutput.

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

 {
     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;
 
     /*
      * Ideally this should be ereport(FATAL), but then we'd not get control
      * back...
      */
     ereport(WARNING,
             (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.")));
 
     /*
      * We DO NOT want to run proc_exit() 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.  Now that
      * there's an atexit callback to prevent third-party code from breaking
      * things by calling exit() directly, we have to reset the callbacks
      * explicitly to make this work as intended.
      */
     on_exit_reset();
 
     /*
      * Note we do exit(2) not exit(0).  This is to force the postmaster into a
      * system reset cycle if some idiot DBA 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);
 }

void RecoveryConflictInterrupt ( ProcSignalReason reason )

Definition at line 2705 of file postgres.c.

References Assert, elog, FATAL, 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 drop through to check wait for pin */
 
             case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
 
                 /*
                  * If we aren't blocking the Startup process there is nothing
                  * more to do.
                  */
                 if (!HoldingBufferPinThatDelaysRecovery())
                     return;
 
                 MyProc->recoveryConflictPending = true;
 
                 /* Intentional drop through to error handling */
 
             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 drop through to session cancel */
 
             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;
 }

void ResetUsage ( void )

Definition at line 4388 of file postgres.c.

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

Referenced by _bt_leafbuild(), _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);
 }

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

Definition at line 3212 of file postgres.c.

References PGC_POSTMASTER, and SetConfigOption().

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

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

Definition at line 3241 of file postgres.c.

References NULL, and 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;
 }

void ShowUsage ( const char * title )

Definition at line 4395 of file postgres.c.

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

Referenced by _bt_leafbuild(), _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 for memory usage -- i can't
      * figure out how to interpret the relevant fields in the rusage struct,
      * and they change names across o/s platforms, anyway. if you can figure
      * out what the entries mean, you can somehow extract resident set size,
      * shared text size, and unshared data and stack sizes.
      */
     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/%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);
 }

void StatementCancelHandler ( SIGNAL_ARGS )

Definition at line 2648 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;
 }