/*------------------------------------------------------------------------- * * postgres.c * POSTGRES C Backend Interface * * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.196 2000/12/18 17:33:41 tgl Exp $ * * NOTES * this is the "main" module of the postgres backend and * hence the main module of the "traffic cop". * *------------------------------------------------------------------------- */ #include "postgres.h" #include #include #include #include #include #include #include #include #if HAVE_SYS_SELECT_H #include #endif #include #include #include #ifdef HAVE_GETOPT_H #include #endif #include "access/xlog.h" #include "commands/async.h" #include "commands/trigger.h" #include "commands/variable.h" #include "libpq/libpq.h" #include "libpq/pqformat.h" #include "libpq/pqsignal.h" #include "miscadmin.h" #include "nodes/print.h" #include "optimizer/cost.h" #include "optimizer/planner.h" #include "parser/analyze.h" #include "parser/parse.h" #include "parser/parser.h" #include "rewrite/rewriteHandler.h" #include "tcop/fastpath.h" #include "tcop/pquery.h" #include "tcop/tcopprot.h" #include "tcop/utility.h" #include "storage/proc.h" #include "utils/exc.h" #include "utils/guc.h" #include "utils/memutils.h" #include "utils/ps_status.h" #ifdef MULTIBYTE #include "mb/pg_wchar.h" #endif /* ---------------- * global variables * ---------------- */ extern int optind; extern char *optarg; /* * for ps display */ bool HostnameLookup; bool ShowPortNumber; bool Log_connections = false; CommandDest whereToSendOutput = Debug; extern void HandleDeadLock(SIGNAL_ARGS); static bool dontExecute = false; /* note: these declarations had better match tcopprot.h */ DLLIMPORT sigjmp_buf Warn_restart; bool Warn_restart_ready = false; bool InError = false; bool ProcDiePending = false; static bool EchoQuery = false; /* default don't echo */ char pg_pathname[MAXPGPATH]; FILE *StatFp = NULL; /* ---------------- * people who want to use EOF should #define DONTUSENEWLINE in * tcop/tcopdebug.h * ---------------- */ #ifndef TCOP_DONTUSENEWLINE int UseNewLine = 1; /* Use newlines query delimiters (the * default) */ #else int UseNewLine = 0; /* Use EOF as query delimiters */ #endif /* TCOP_DONTUSENEWLINE */ /* ** Flags for expensive function optimization -- JMH 3/9/92 */ int XfuncMode = 0; /* ---------------------------------------------------------------- * decls for routines only used in this file * ---------------------------------------------------------------- */ static int InteractiveBackend(StringInfo inBuf); static int SocketBackend(StringInfo inBuf); static int ReadCommand(StringInfo inBuf); static List *pg_parse_query(char *query_string, Oid *typev, int nargs); static List *pg_analyze_and_rewrite(Node *parsetree); static void start_xact_command(void); static void finish_xact_command(void); static void SigHupHandler(SIGNAL_ARGS); static void FloatExceptionHandler(SIGNAL_ARGS); static void quickdie(SIGNAL_ARGS); /* * Flag to mark SIGHUP. Whenever the main loop comes around it * will reread the configuration file. (Better than doing the * reading in the signal handler, ey?) */ static volatile bool got_SIGHUP = false; /* ---------------------------------------------------------------- * routines to obtain user input * ---------------------------------------------------------------- */ /* ---------------- * InteractiveBackend() is called for user interactive connections * the string entered by the user is placed in its parameter inBuf. * * EOF is returned if end-of-file input is seen; time to shut down. * ---------------- */ static int InteractiveBackend(StringInfo inBuf) { int c; /* character read from getc() */ bool end = false; /* end-of-input flag */ bool backslashSeen = false; /* have we seen a \ ? */ /* ---------------- * display a prompt and obtain input from the user * ---------------- */ printf("backend> "); fflush(stdout); /* Reset inBuf to empty */ inBuf->len = 0; inBuf->data[0] = '\0'; for (;;) { if (UseNewLine) { /* ---------------- * if we are using \n as a delimiter, then read * characters until the \n. * ---------------- */ while ((c = getc(stdin)) != EOF) { if (c == '\n') { if (backslashSeen) { /* discard backslash from inBuf */ inBuf->data[--inBuf->len] = '\0'; backslashSeen = false; continue; } else { /* keep the newline character */ appendStringInfoChar(inBuf, '\n'); break; } } else if (c == '\\') backslashSeen = true; else backslashSeen = false; appendStringInfoChar(inBuf, (char) c); } if (c == EOF) end = true; } else { /* ---------------- * otherwise read characters until EOF. * ---------------- */ while ((c = getc(stdin)) != EOF) appendStringInfoChar(inBuf, (char) c); if (inBuf->len == 0) end = true; } if (end) return EOF; /* ---------------- * otherwise we have a user query so process it. * ---------------- */ break; } /* ---------------- * if the query echo flag was given, print the query.. * ---------------- */ if (EchoQuery) printf("query: %s\n", inBuf->data); fflush(stdout); return 'Q'; } /* ---------------- * SocketBackend() Is called for frontend-backend connections * * If the input is a query (case 'Q') then the string entered by * the user is placed in its parameter inBuf. * * If the input is a fastpath function call (case 'F') then * the function call is processed in HandleFunctionRequest() * (now called from PostgresMain()). * * EOF is returned if the connection is lost. * ---------------- */ static int SocketBackend(StringInfo inBuf) { char qtype; char result = '\0'; /* ---------------- * get input from the frontend * ---------------- */ qtype = '?'; if (pq_getbytes(&qtype, 1) == EOF) return EOF; switch (qtype) { /* ---------------- * 'Q': user entered a query * ---------------- */ case 'Q': if (pq_getstr(inBuf)) return EOF; result = 'Q'; break; /* ---------------- * 'F': calling user/system functions * ---------------- */ case 'F': if (pq_getstr(inBuf)) return EOF; /* ignore "string" at start of F message */ result = 'F'; break; /* ---------------- * 'X': frontend is exiting * ---------------- */ case 'X': result = 'X'; break; /* ---------------- * otherwise we got garbage from the frontend. * * XXX are we certain that we want to do an elog(FATAL) here? * -cim 1/24/90 * ---------------- */ default: elog(FATAL, "Socket command type %c unknown", qtype); break; } return result; } /* ---------------- * ReadCommand reads a command from either the frontend or * standard input, places it in inBuf, and returns a char * representing whether the string is a 'Q'uery or a 'F'astpath * call. EOF is returned if end of file. * ---------------- */ static int ReadCommand(StringInfo inBuf) { int result; if (IsUnderPostmaster) result = SocketBackend(inBuf); else result = InteractiveBackend(inBuf); return result; } /* * Parse a query string and pass it through the rewriter. * * A list of Query nodes is returned, since the string might contain * multiple queries and/or the rewriter might expand one query to several. * * NOTE: this routine is no longer used for processing interactive queries, * but it is still needed for parsing of SQL function bodies. */ List * pg_parse_and_rewrite(char *query_string, /* string to execute */ Oid *typev, /* parameter types */ int nargs) /* number of parameters */ { List *raw_parsetree_list; List *querytree_list; List *list_item; /* ---------------- * (1) parse the request string into a list of raw parse trees. * ---------------- */ raw_parsetree_list = pg_parse_query(query_string, typev, nargs); /* ---------------- * (2) Do parse analysis and rule rewrite. * ---------------- */ querytree_list = NIL; foreach(list_item, raw_parsetree_list) { Node *parsetree = (Node *) lfirst(list_item); querytree_list = nconc(querytree_list, pg_analyze_and_rewrite(parsetree)); } return querytree_list; } /* * Do raw parsing (only). * * A list of parsetrees is returned, since there might be multiple * commands in the given string. * * NOTE: for interactive queries, it is important to keep this routine * separate from the analysis & rewrite stages. Analysis and rewriting * cannot be done in an aborted transaction, since they require access to * database tables. So, we rely on the raw parser to determine whether * we've seen a COMMIT or ABORT command; when we are in abort state, other * commands are not processed any further than the raw parse stage. */ static List * pg_parse_query(char *query_string, Oid *typev, int nargs) { List *raw_parsetree_list; if (Debug_print_query) elog(DEBUG, "query: %s", query_string); if (Show_parser_stats) ResetUsage(); raw_parsetree_list = parser(query_string, typev, nargs); if (Show_parser_stats) { fprintf(StatFp, "PARSER STATISTICS\n"); ShowUsage(); } return raw_parsetree_list; } /* * Given a raw parsetree (gram.y output), perform parse analysis and * rule rewriting. * * A list of Query nodes is returned, since either the analyzer or the * rewriter might expand one query to several. * * NOTE: for reasons mentioned above, this must be separate from raw parsing. */ static List * pg_analyze_and_rewrite(Node *parsetree) { List *querytree_list; List *list_item; Query *querytree; List *new_list; /* ---------------- * (1) Perform parse analysis. * ---------------- */ if (Show_parser_stats) ResetUsage(); querytree_list = parse_analyze(parsetree, NULL); if (Show_parser_stats) { fprintf(StatFp, "PARSE ANALYSIS STATISTICS\n"); ShowUsage(); ResetUsage(); } /* ---------------- * (2) Rewrite the queries, as necessary * * rewritten queries are collected in new_list. Note there may be * more or fewer than in the original list. * ---------------- */ new_list = NIL; foreach(list_item, querytree_list) { querytree = (Query *) lfirst(list_item); if (Debug_print_parse) { if (Debug_pretty_print) { elog(DEBUG, "parse tree:"); nodeDisplay(querytree); } else elog(DEBUG, "parse tree: %s", nodeToString(querytree)); } if (querytree->commandType == CMD_UTILITY) { /* don't rewrite utilities, just dump 'em into new_list */ new_list = lappend(new_list, querytree); } else { /* rewrite regular queries */ List *rewritten = QueryRewrite(querytree); new_list = nconc(new_list, rewritten); } } querytree_list = new_list; if (Show_parser_stats) { fprintf(StatFp, "REWRITER STATISTICS\n"); ShowUsage(); } #ifdef COPY_PARSE_PLAN_TREES /* Optional debugging check: pass querytree output through copyObject() */ new_list = (List *) copyObject(querytree_list); /* This checks both copyObject() and the equal() routines... */ if (! equal(new_list, querytree_list)) elog(NOTICE, "pg_analyze_and_rewrite: copyObject failed on parse tree"); else querytree_list = new_list; #endif if (Debug_print_rewritten) { if (Debug_pretty_print) { elog(DEBUG, "rewritten parse tree:"); foreach(list_item, querytree_list) { querytree = (Query *) lfirst(list_item); nodeDisplay(querytree); printf("\n"); } } else { elog(DEBUG, "rewritten parse tree:"); foreach(list_item, querytree_list) { querytree = (Query *) lfirst(list_item); elog(DEBUG, "%s", nodeToString(querytree)); } } } return querytree_list; } /* Generate a plan for a single query. */ Plan * pg_plan_query(Query *querytree) { Plan *plan; /* Utility commands have no plans. */ if (querytree->commandType == CMD_UTILITY) return NULL; if (Show_planner_stats) ResetUsage(); /* call that optimizer */ plan = planner(querytree); if (Show_planner_stats) { fprintf(stderr, "PLANNER STATISTICS\n"); ShowUsage(); } #ifdef COPY_PARSE_PLAN_TREES /* Optional debugging check: pass plan output through copyObject() */ { Plan *new_plan = (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(NOTICE, "pg_plan_query: copyObject failed on plan tree"); else #endif plan = new_plan; } #endif /* ---------------- * Print plan if debugging. * ---------------- */ if (Debug_print_plan) { if (Debug_pretty_print) { elog(DEBUG, "plan:"); nodeDisplay(plan); } else elog(DEBUG, "plan: %s", nodeToString(plan)); } return plan; } /* ---------------------------------------------------------------- * pg_exec_query_string() * * Takes a querystring, runs the parser/utilities or * parser/planner/executor over it as necessary. * * Assumptions: * * At call, we are not inside a transaction command. * * The CurrentMemoryContext after starting a transaction command must be * appropriate for execution of individual queries (typically this will be * TransactionCommandContext). Note that this routine resets that context * after each individual query, so don't store anything there that * must outlive the call! * * parse_context references a context suitable for holding the * parse/rewrite trees (typically this will be QueryContext). * This context *must* be longer-lived than the transaction context! * In fact, if the query string might contain BEGIN/COMMIT commands, * parse_context had better outlive TopTransactionContext! * * We could have hard-wired knowledge about QueryContext and * TransactionCommandContext into this routine, but it seems better * not to, in case callers from outside this module need to use some * other contexts. * * ---------------------------------------------------------------- */ void pg_exec_query_string(char *query_string, /* string to execute */ CommandDest dest, /* where results should go */ MemoryContext parse_context) /* context for parsetrees */ { bool xact_started; MemoryContext oldcontext; List *parsetree_list, *parsetree_item; /* * Start up a transaction command. All queries generated by the * query_string will be in this same command block, *unless* we find * a BEGIN/COMMIT/ABORT statement; we have to force a new xact command * after one of those, else bad things will happen in xact.c. * (Note that this will possibly change current memory context.) */ start_xact_command(); xact_started = true; /* * parse_context *must* be different from the execution memory context, * else the context reset at the bottom of the loop will destroy the * parsetree list. (We really ought to check that parse_context isn't a * child of CurrentMemoryContext either, but that would take more cycles * than it's likely to be worth.) */ Assert(parse_context != CurrentMemoryContext); /* * Switch to appropriate context for constructing parsetrees. */ oldcontext = MemoryContextSwitchTo(parse_context); /* * Do basic parsing of the query or queries (this should be safe * even if we are in aborted transaction state!) */ parsetree_list = pg_parse_query(query_string, NULL, 0); /* * Switch back to execution context to enter the loop. */ MemoryContextSwitchTo(oldcontext); /* * Run through the parsetree(s) and process each one. */ foreach(parsetree_item, parsetree_list) { Node *parsetree = (Node *) lfirst(parsetree_item); bool isTransactionStmt; List *querytree_list, *querytree_item; /* Transaction control statements need some special handling */ isTransactionStmt = IsA(parsetree, TransactionStmt); /* * If we are in an aborted transaction, ignore all commands except * COMMIT/ABORT. It is important that this test occur before we * try to do parse analysis, rewrite, or planning, since all those * phases try to do database accesses, which may fail in abort state. * (It might be safe to allow some additional utility commands in * this state, but not many...) */ if (IsAbortedTransactionBlockState()) { bool allowit = false; if (isTransactionStmt) { TransactionStmt *stmt = (TransactionStmt *) parsetree; switch (stmt->command) { case COMMIT: case ROLLBACK: allowit = true; break; default: break; } } if (! allowit) { /* ---------------- * the EndCommand() stuff is to tell the frontend * that the command ended. -cim 6/1/90 * ---------------- */ char *tag = "*ABORT STATE*"; elog(NOTICE, "current transaction is aborted, " "queries ignored until end of transaction block"); EndCommand(tag, dest); /* * We continue in the loop, on the off chance that there * is a COMMIT or ROLLBACK utility command later in the * query string. */ continue; } } /* Make sure we are in a transaction command */ if (! xact_started) { start_xact_command(); xact_started = true; } /* If we got a cancel signal in parsing or prior command, quit */ if (QueryCancel) CancelQuery(); /* * OK to analyze and rewrite this query. * * Switch to appropriate context for constructing querytrees * (again, these must outlive the execution context). */ oldcontext = MemoryContextSwitchTo(parse_context); querytree_list = pg_analyze_and_rewrite(parsetree); /* * Switch back to execution context for planning and execution. */ MemoryContextSwitchTo(oldcontext); /* * Inner loop handles the individual queries generated from a * single parsetree by analysis and rewrite. */ foreach(querytree_item, querytree_list) { Query *querytree = (Query *) lfirst(querytree_item); /* Make sure we are in a transaction command */ if (! xact_started) { start_xact_command(); xact_started = true; } /* If we got a cancel signal in analysis or prior command, quit */ if (QueryCancel) CancelQuery(); if (querytree->commandType == CMD_UTILITY) { /* ---------------- * process utility functions (create, destroy, etc..) * ---------------- */ if (Debug_print_query) elog(DEBUG, "ProcessUtility: %s", query_string); else if (DebugLvl > 1) elog(DEBUG, "ProcessUtility"); ProcessUtility(querytree->utilityStmt, dest); } else { /* ---------------- * process a plannable query. * ---------------- */ Plan *plan; plan = pg_plan_query(querytree); /* if we got a cancel signal whilst planning, quit */ if (QueryCancel) CancelQuery(); /* Initialize snapshot state for query */ SetQuerySnapshot(); /* * execute the plan */ if (Show_executor_stats) ResetUsage(); if (dontExecute) { /* don't execute it, just show the query plan */ print_plan(plan, querytree); } else { if (DebugLvl > 1) elog(DEBUG, "ProcessQuery"); ProcessQuery(querytree, plan, dest); } if (Show_executor_stats) { fprintf(stderr, "EXECUTOR STATISTICS\n"); ShowUsage(); } } /* * In a query block, we want to increment the command counter * between queries so that the effects of early queries are * visible to subsequent ones. In particular we'd better * do so before checking constraints. */ if (!isTransactionStmt) CommandCounterIncrement(); /* * Clear the execution context to recover temporary * memory used by the query. NOTE: if query string contains * BEGIN/COMMIT transaction commands, execution context may * now be different from what we were originally passed; * so be careful to clear current context not "oldcontext". */ Assert(parse_context != CurrentMemoryContext); MemoryContextResetAndDeleteChildren(CurrentMemoryContext); /* * If this was a transaction control statement, commit it * and arrange to start a new xact command for the next * command (if any). */ if (isTransactionStmt) { finish_xact_command(); xact_started = false; } } /* end loop over queries generated from a parsetree */ } /* end loop over parsetrees */ /* * Close down transaction statement, if one is open. */ if (xact_started) finish_xact_command(); } /* * Convenience routines for starting/committing a single command. */ static void start_xact_command(void) { if (DebugLvl >= 1) elog(DEBUG, "StartTransactionCommand"); StartTransactionCommand(); } static void finish_xact_command(void) { /* Invoke IMMEDIATE constraint triggers */ DeferredTriggerEndQuery(); /* Now commit the command */ if (DebugLvl >= 1) elog(DEBUG, "CommitTransactionCommand"); set_ps_display("commit"); /* XXX probably the wrong place to do this */ CommitTransactionCommand(); #ifdef SHOW_MEMORY_STATS /* Print mem stats at each commit for leak tracking */ if (ShowStats) MemoryContextStats(TopMemoryContext); #endif } /* -------------------------------- * signal handler routines used in PostgresMain() * * handle_warn() catches SIGQUIT. It forces control back to the main * loop, just as if an internal error (elog(ERROR,...)) had occurred. * elog() used to actually use kill(2) to induce a SIGQUIT to get here! * But that's not 100% reliable on some systems, so now it does its own * siglongjmp() instead. * We still provide the signal catcher so that an error quit can be * forced externally. This should be done only with great caution, * however, since an asynchronous signal could leave the system in * who-knows-what inconsistent state. * * quickdie() occurs when signalled by the postmaster. * Some backend has bought the farm, * so we need to stop what we're doing and exit. * * die() performs an orderly cleanup via proc_exit() * -------------------------------- */ void handle_warn(SIGNAL_ARGS) { /* Don't joggle the elbow of a critical section */ if (CritSectionCount > 0) { QueryCancel = true; return; } siglongjmp(Warn_restart, 1); } static void quickdie(SIGNAL_ARGS) { PG_SETMASK(&BlockSig); elog(NOTICE, "Message from PostgreSQL backend:" "\n\tThe Postmaster has informed me that some other backend" " died abnormally and possibly corrupted shared memory." "\n\tI have rolled back the current transaction and am" " going to terminate your database system connection and exit." "\n\tPlease reconnect to the database system and repeat your query."); /* * DO NOT proc_exit(0) -- we're here because shared memory may be * corrupted, so we don't want to flush any shared state to stable * storage. Just nail the windows shut and get out of town. */ exit(1); } /* * Abort transaction and exit */ void die(SIGNAL_ARGS) { PG_SETMASK(&BlockSig); /* Don't joggle the elbow of a critical section */ if (CritSectionCount > 0) { QueryCancel = true; ProcDiePending = true; return; } /* Don't joggle the elbow of proc_exit, either */ if (proc_exit_inprogress) return; elog(FATAL, "The system is shutting down"); } /* signal handler for floating point exception */ static void FloatExceptionHandler(SIGNAL_ARGS) { elog(ERROR, "floating point exception!" " The last floating point operation either exceeded legal ranges" " or was a divide by zero"); } /* signal handler for query cancel signal from postmaster */ static void QueryCancelHandler(SIGNAL_ARGS) { int save_errno = errno; QueryCancel = true; LockWaitCancel(); errno = save_errno; } void CancelQuery(void) { /* * QueryCancel flag will be reset in main loop, which we reach by * longjmp from elog(). */ elog(ERROR, "Query was cancelled."); } static void SigHupHandler(SIGNAL_ARGS) { got_SIGHUP = true; } static void usage(char *progname) { printf("%s is the PostgreSQL stand-alone backend. It is not\nintended to be used by normal users.\n\n", progname); printf("Usage:\n %s [options...] [dbname]\n\n", progname); printf("Options:\n"); #ifdef USE_ASSERT_CHECKING printf(" -A 1|0 enable/disable run-time assert checking\n"); #endif printf(" -B NBUFFERS number of shared buffers (default %d)\n", DEF_NBUFFERS); printf(" -c NAME=VALUE set run-time parameter\n"); printf(" -d 1-5 debugging level\n"); printf(" -D DATADIR database directory\n"); printf(" -e use European date format\n"); printf(" -E echo query before execution\n"); printf(" -F turn fsync off\n"); printf(" -N do not use newline as interactive query delimiter\n"); printf(" -o FILENAME send stdout and stderr to given file\n"); printf(" -P disable system indexes\n"); printf(" -s show statistics after each query\n"); printf(" -S SORT-MEM set amount of memory for sorts (in kbytes)\n"); printf("Developer options:\n"); printf(" -f [s|i|n|m|h] forbid use of some plan types\n"); printf(" -i do not execute queries\n"); printf(" -L turn off locking\n"); printf(" -O allow system table structure changes\n"); printf(" -t [pa|pl|ex] show timings after each query\n"); printf(" -W NUM wait NUM seconds to allow attach from a debugger\n"); printf("\nReport bugs to .\n"); } /* ---------------------------------------------------------------- * PostgresMain * postgres main loop -- all backends, interactive or otherwise start here * * argc/argv are the command line arguments to be used. When being forked * by the postmaster, these are not the original argv array of the process. * real_argc/real_argv point to the original argv array, which is needed by * `ps' display on some platforms. username is the (possibly authenticated) * PostgreSQL user name to be used for the session. * ---------------------------------------------------------------- */ int PostgresMain(int argc, char *argv[], int real_argc, char *real_argv[], const char * username) { int flag; const char *DBName = NULL; bool secure = true; int errs = 0; int firstchar; StringInfo parser_input; char *remote_host; unsigned short remote_port; char *potential_DataDir = NULL; /* * Catch standard options before doing much else. This even works * on systems without getopt_long. */ if (!IsUnderPostmaster && argc > 1) { if (strcmp(argv[1], "--help")==0 || strcmp(argv[1], "-?")==0) { usage(argv[0]); exit(0); } if (strcmp(argv[1], "--version")==0 || strcmp(argv[1], "-V")==0) { puts("postgres (PostgreSQL) " PG_VERSION); exit(0); } } /* * Fire up essential subsystems: error and memory management * * If we are running under the postmaster, this is done already. */ if (!IsUnderPostmaster) { EnableExceptionHandling(true); MemoryContextInit(); } SetProcessingMode(InitProcessing); /* * Set default values for command-line options. */ Noversion = false; EchoQuery = false; if (!IsUnderPostmaster) { ResetAllOptions(); potential_DataDir = getenv("PGDATA"); } StatFp = stderr; /* Check for PGDATESTYLE environment variable */ set_default_datestyle(); /* ---------------- * parse command line arguments * * There are now two styles of command line layout for the backend: * * For interactive use (not started from postmaster) the format is * postgres [switches] [databasename] * If the databasename is omitted it is taken to be the user name. * * When started from the postmaster, the format is * postgres [secure switches] -p databasename [insecure switches] * Switches appearing after -p came from the client (via "options" * field of connection request). For security reasons we restrict * what these switches can do. * ---------------- */ optind = 1; /* reset after postmaster's usage */ while ((flag = getopt(argc, argv, "A:B:c:CD:d:Eef:FiLNOPo:p:S:st:v:W:x:-:")) != EOF) switch (flag) { case 'A': #ifdef USE_ASSERT_CHECKING assert_enabled = atoi(optarg); #else fprintf(stderr, "Assert checking is not compiled in\n"); #endif break; case 'B': /* ---------------- * specify the size of buffer pool * ---------------- */ if (secure) NBuffers = atoi(optarg); break; case 'C': /* ---------------- * don't print version string * ---------------- */ Noversion = true; break; case 'D': /* PGDATA directory */ if (secure) { potential_DataDir = optarg; } break; case 'd': /* debug level */ DebugLvl = atoi(optarg); if (DebugLvl >= 1); Log_connections = true; if (DebugLvl >= 2) Debug_print_query = true; if (DebugLvl >= 3) Debug_print_parse = true; if (DebugLvl >= 4) Debug_print_plan = true; if (DebugLvl >= 5) Debug_print_rewritten = true; break; case 'E': /* ---------------- * E - echo the query the user entered * ---------------- */ EchoQuery = true; break; case 'e': /* -------------------------- * Use european date formats. * -------------------------- */ EuroDates = true; break; case 'F': /* -------------------- * turn off fsync * * 7.0 buffer manager can support different backends running * with different fsync settings, so this no longer needs * to be "if (secure)". * -------------------- */ enableFsync = false; break; case 'f': /* ----------------- * f - forbid generation of certain plans * ----------------- */ switch (optarg[0]) { case 's': /* seqscan */ enable_seqscan = false; break; case 'i': /* indexscan */ enable_indexscan = false; break; case 't': /* tidscan */ enable_tidscan = false; break; case 'n': /* nestloop */ enable_nestloop = false; break; case 'm': /* mergejoin */ enable_mergejoin = false; break; case 'h': /* hashjoin */ enable_hashjoin = false; break; default: errs++; } break; case 'i': dontExecute = true; break; case 'L': /* -------------------- * turn off locking * -------------------- */ if (secure) lockingOff = 1; break; case 'N': /* ---------------- * N - Don't use newline as a query delimiter * ---------------- */ UseNewLine = 0; break; case 'O': /* -------------------- * allow system table structure modifications * -------------------- */ if (secure) /* XXX safe to allow from client??? */ allowSystemTableMods = true; break; case 'P': /* -------------------- * ignore system indexes * -------------------- */ if (secure) /* XXX safe to allow from client??? */ IgnoreSystemIndexes(true); break; case 'o': /* ---------------- * o - send output (stdout and stderr) to the given file * ---------------- */ if (secure) StrNCpy(OutputFileName, optarg, MAXPGPATH); break; case 'p': /* ---------------- * p - special flag passed if backend was forked * by a postmaster. * ---------------- */ if (secure) { DBName = strdup(optarg); secure = false; /* subsequent switches are NOT * secure */ } break; case 'S': /* ---------------- * S - amount of sort memory to use in 1k bytes * ---------------- */ { int S; S = atoi(optarg); if (S >= 4 * BLCKSZ / 1024) SortMem = S; } break; case 's': /* ---------------- * s - report usage statistics (timings) after each query * ---------------- */ Show_query_stats = 1; break; case 't': /* ---------------- * tell postgres to report usage statistics (timings) for * each query * * -tpa[rser] = print stats for parser time of each query * -tpl[anner] = print stats for planner time of each query * -te[xecutor] = print stats for executor time of each query * caution: -s can not be used together with -t. * ---------------- */ switch (optarg[0]) { case 'p': if (optarg[1] == 'a') Show_parser_stats = 1; else if (optarg[1] == 'l') Show_planner_stats = 1; else errs++; break; case 'e': Show_executor_stats = 1; break; default: errs++; break; } break; case 'v': if (secure) FrontendProtocol = (ProtocolVersion) atoi(optarg); break; case 'W': /* ---------------- * wait N seconds to allow attach from a debugger * ---------------- */ sleep(atoi(optarg)); break; case 'x': #ifdef NOT_USED /* planner/xfunc.h */ /* * control joey hellerstein's expensive function * optimization */ if (XfuncMode != 0) { fprintf(stderr, "only one -x flag is allowed\n"); errs++; break; } if (strcmp(optarg, "off") == 0) XfuncMode = XFUNC_OFF; else if (strcmp(optarg, "nor") == 0) XfuncMode = XFUNC_NOR; else if (strcmp(optarg, "nopull") == 0) XfuncMode = XFUNC_NOPULL; else if (strcmp(optarg, "nopm") == 0) XfuncMode = XFUNC_NOPM; else if (strcmp(optarg, "pullall") == 0) XfuncMode = XFUNC_PULLALL; else if (strcmp(optarg, "wait") == 0) XfuncMode = XFUNC_WAIT; else { fprintf(stderr, "use -x {off,nor,nopull,nopm,pullall,wait}\n"); errs++; } #endif break; case 'c': case '-': { char *name, *value; ParseLongOption(optarg, &name, &value); if (!value) { if (flag == '-') elog(ERROR, "--%s requires argument", optarg); else elog(ERROR, "-c %s requires argument", optarg); } /* all options are allowed if not under postmaster */ SetConfigOption(name, value, (IsUnderPostmaster) ? PGC_BACKEND : PGC_POSTMASTER); free(name); if (value) free(value); break; } default: errs++; break; } /* * Post-processing for command line options. * * XXX It'd be nice if libpq were already running here, so we could do * elog(NOTICE) instead of just writing on stderr... */ if (Show_query_stats && (Show_parser_stats || Show_planner_stats || Show_executor_stats)) { fprintf(stderr, "Query statistics are disabled because parser, planner, or executor statistics are on.\n"); Show_query_stats = false; } if (!IsUnderPostmaster) { if (!potential_DataDir) { fprintf(stderr, "%s does not know where to find the database system " "data. You must specify the directory that contains the " "database system either by specifying the -D invocation " "option or by setting the PGDATA environment variable.\n\n", argv[0]); proc_exit(1); } SetDataDir(potential_DataDir); } Assert(DataDir); /* * 1. Set BlockSig and UnBlockSig masks. 2. Set up signal handlers. 3. * Allow only SIGUSR1 signal (we never block it) during * initialization. * * Note that postmaster already blocked ALL signals to make us happy. */ pqinitmask(); #ifdef HAVE_SIGPROCMASK sigdelset(&BlockSig, SIGUSR1); #else BlockSig &= ~(sigmask(SIGUSR1)); #endif PG_SETMASK(&BlockSig); /* block everything except SIGUSR1 */ pqsignal(SIGHUP, SigHupHandler); /* set flag to read config file */ pqsignal(SIGINT, QueryCancelHandler); /* cancel current query */ pqsignal(SIGQUIT, handle_warn); /* handle error */ pqsignal(SIGTERM, die); pqsignal(SIGALRM, HandleDeadLock); /* * 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, quickdie); pqsignal(SIGUSR2, Async_NotifyHandler); /* flush also sinval cache */ pqsignal(SIGFPE, FloatExceptionHandler); pqsignal(SIGCHLD, SIG_IGN); /* ignored, sent by LockOwners */ pqsignal(SIGTTIN, SIG_DFL); pqsignal(SIGTTOU, SIG_DFL); pqsignal(SIGCONT, SIG_DFL); if (IsUnderPostmaster) { /* noninteractive case: nothing should be left after switches */ if (errs || argc != optind || DBName == NULL) { fprintf(stderr, "%s: invalid command line arguments\nTry -? for help.\n", argv[0]); proc_exit(1); } pq_init(); /* initialize libpq at backend startup */ whereToSendOutput = Remote; BaseInit(); } else { /* interactive case: database name can be last arg on command line */ whereToSendOutput = Debug; if (errs || argc - optind > 1) { fprintf(stderr, "%s: invalid command line arguments\nTry -? for help.\n", argv[0]); proc_exit(1); } else if (argc - optind == 1) DBName = argv[optind]; else if ((DBName = username) == NULL) { fprintf(stderr, "%s: user name undefined and no database specified\n", argv[0]); proc_exit(1); } /* * Create lockfile for data directory. */ if (! CreateDataDirLockFile(DataDir, false)) proc_exit(1); XLOGPathInit(); BaseInit(); /* * Start up xlog for standalone backend, and register to have it * closed down at exit. */ StartupXLOG(); on_shmem_exit(ShutdownXLOG, 0); } /* * Set up additional info. */ #ifdef CYR_RECODE SetCharSet(); #endif /* On some systems our dynloader code needs the executable's pathname */ if (FindExec(pg_pathname, real_argv[0], "postgres") < 0) elog(FATAL, "%s: could not locate executable, bailing out...", real_argv[0]); /* * Find remote host name or address. */ remote_host = NULL; if (IsUnderPostmaster) { if (MyProcPort->raddr.sa.sa_family == AF_INET) { struct hostent *host_ent; char * host_addr; remote_port = ntohs(MyProcPort->raddr.in.sin_port); host_addr = inet_ntoa(MyProcPort->raddr.in.sin_addr); if (HostnameLookup) { host_ent = gethostbyaddr((char *) &MyProcPort->raddr.in.sin_addr, sizeof(MyProcPort->raddr.in.sin_addr), AF_INET); if (host_ent) { remote_host = palloc(strlen(host_addr) + strlen(host_ent->h_name) + 3); sprintf(remote_host, "%s[%s]", host_ent->h_name, host_addr); } } if (remote_host == NULL) remote_host = pstrdup(host_addr); if (ShowPortNumber) { char * str = palloc(strlen(remote_host) + 7); sprintf(str, "%s:%hu", remote_host, remote_port); pfree(remote_host); remote_host = str; } } else /* not AF_INET */ remote_host = "[local]"; /* * Set process parameters for ps * * WARNING: On some platforms the environment will be moved * around to make room for the ps display string. So any * references to optarg or getenv() from above will be invalid * after this call. Better use strdup or something similar. */ init_ps_display(real_argc, real_argv, username, DBName, remote_host); set_ps_display("startup"); } if (Log_connections) elog(DEBUG, "connection: host=%s user=%s database=%s", remote_host, username, DBName); /* * 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. */ if (DebugLvl > 1) elog(DEBUG, "InitPostgres"); InitPostgres(DBName, username); SetProcessingMode(NormalProcessing); /* * Send this backend's cancellation info to the frontend. */ if (whereToSendOutput == Remote && PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2) { StringInfoData buf; pq_beginmessage(&buf); pq_sendbyte(&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. */ } if (!IsUnderPostmaster) { puts("\nPOSTGRES backend interactive interface "); puts("$Revision: 1.196 $ $Date: 2000/12/18 17:33:41 $\n"); } /* * Create the memory context we will use in the main loop. * * QueryContext is reset once per iteration of the main loop, * ie, upon completion of processing of each supplied query string. * It can therefore be used for any data that should live just as * long as the query string --- parse trees, for example. */ QueryContext = AllocSetContextCreate(TopMemoryContext, "QueryContext", ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE); /* * 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. */ if (sigsetjmp(Warn_restart, 1) != 0) { /* * NOTE: if you are tempted to add more code in this if-block, * consider the probability that it should be in AbortTransaction() * instead. * * Make sure we are in a valid memory context during recovery. * * We use ErrorContext in hopes that it will have some free space * even if we're otherwise up against it... */ MemoryContextSwitchTo(ErrorContext); /* Do the recovery */ if (DebugLvl >= 1) elog(DEBUG, "AbortCurrentTransaction"); AbortCurrentTransaction(); /* * Now return to normal top-level context and clear ErrorContext * for next time. */ MemoryContextSwitchTo(TopMemoryContext); MemoryContextResetAndDeleteChildren(ErrorContext); /* * Clear flag to indicate that we got out of error recovery mode * successfully. (Flag was set in elog.c before longjmp().) */ InError = false; } Warn_restart_ready = true; /* we can now handle elog(ERROR) */ PG_SETMASK(&UnBlockSig); /* * Non-error queries loop here. */ for (;;) { /* * Release storage left over from prior query cycle, and * create a new query input buffer in the cleared QueryContext. */ MemoryContextSwitchTo(QueryContext); MemoryContextResetAndDeleteChildren(QueryContext); parser_input = makeStringInfo(); /* ---------------- * (1) tell the frontend we're ready for a new query. * * Note: this includes fflush()'ing the last of the prior output. * ---------------- */ ReadyForQuery(whereToSendOutput); /* ---------------- * (2) deal with pending asynchronous NOTIFY from other backends, * and enable async.c's signal handler to execute NOTIFY directly. * ---------------- */ QueryCancel = false; /* forget any earlier CANCEL signal */ SetWaitingForLock(false); EnableNotifyInterrupt(); /* ---------------- * (3) read a command (loop blocks here) * ---------------- */ set_ps_display("idle"); firstchar = ReadCommand(parser_input); QueryCancel = false; /* forget any earlier CANCEL signal */ /* ---------------- * (4) disable async.c's signal handler. * ---------------- */ DisableNotifyInterrupt(); /* ---------------- * (5) check for any other interesting events that happened * while we slept. * ---------------- */ if (got_SIGHUP) { got_SIGHUP = false; ProcessConfigFile(PGC_SIGHUP); } /* ---------------- * (6) process the command. * ---------------- */ switch (firstchar) { /* ---------------- * 'F' indicates a fastpath call. * ---------------- */ case 'F': /* start an xact for this function invocation */ start_xact_command(); if (HandleFunctionRequest() == EOF) { /* lost frontend connection during F message input */ proc_exit(0); } /* commit the function-invocation transaction */ finish_xact_command(); break; /* ---------------- * 'Q' indicates a user query * ---------------- */ case 'Q': if (strspn(parser_input->data, " \t\r\n") == parser_input->len) { /* ---------------- * if there is nothing in the input buffer, don't bother * trying to parse and execute anything; just send * back a quick NullCommand response. * ---------------- */ if (IsUnderPostmaster) NullCommand(Remote); } else { /* ---------------- * otherwise, process the input string. * * Note: transaction command start/end is now done * within pg_exec_query_string(), not here. * ---------------- */ if (Show_query_stats) ResetUsage(); pg_exec_query_string(parser_input->data, whereToSendOutput, QueryContext); if (Show_query_stats) { fprintf(StatFp, "QUERY STATISTICS\n"); ShowUsage(); } } 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: /* * 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); default: elog(ERROR, "unknown frontend message was received"); } #ifdef MEMORY_CONTEXT_CHECKING /* * Check all memory after each backend loop. This is a rather * weird place to do it, perhaps. */ MemoryContextCheck(TopMemoryContext); #endif } /* end of input-reading loop */ /* can't get here because the above loop never exits */ Assert(false); return 1; /* keep compiler quiet */ } #ifndef HAVE_GETRUSAGE #include "rusagestub.h" #else #include #endif /* HAVE_GETRUSAGE */ struct rusage Save_r; struct timeval Save_t; void ResetUsage(void) { struct timezone tz; getrusage(RUSAGE_SELF, &Save_r); gettimeofday(&Save_t, &tz); ResetBufferUsage(); /* ResetTupleCount(); */ } void ShowUsage(void) { struct timeval user, sys; struct timeval elapse_t; struct timezone tz; struct rusage r; getrusage(RUSAGE_SELF, &r); gettimeofday(&elapse_t, &tz); memmove((char *) &user, (char *) &r.ru_utime, sizeof(user)); memmove((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; } /* * Set output destination if not otherwise set */ if (StatFp == NULL) StatFp = stderr; /* * 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. */ fprintf(StatFp, "! system usage stats:\n"); fprintf(StatFp, "!\t%ld.%06ld elapsed %ld.%06ld user %ld.%06ld system sec\n", (long int) elapse_t.tv_sec - Save_t.tv_sec, (long int) elapse_t.tv_usec - Save_t.tv_usec, (long int) r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec, (long int) r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec, (long int) r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec, (long int) r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec); fprintf(StatFp, "!\t[%ld.%06ld user %ld.%06ld sys total]\n", (long int) user.tv_sec, (long int) user.tv_usec, (long int) sys.tv_sec, (long int) sys.tv_usec); /* BeOS has rusage but only has some fields, and not these... */ #if defined(HAVE_GETRUSAGE) && !defined(__BEOS__) fprintf(StatFp, "!\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); fprintf(StatFp, "!\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); fprintf(StatFp, "!\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); fprintf(StatFp, "!\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 */ fprintf(StatFp, "! postgres usage stats:\n"); PrintBufferUsage(StatFp); /* DisplayTupleCount(StatFp); */ } #ifdef NOT_USED static int assertEnable(int val) { assert_enabled = val; return val; } #ifdef ASSERT_CHECKING_TEST int assertTest(int val) { Assert(val == 0); if (assert_enabled) { /* val != 0 should be trapped by previous Assert */ elog(NOTICE, "Assert test successfull (val = %d)", val); } else elog(NOTICE, "Assert checking is disabled (val = %d)", val); return val; } #endif #endif