1 /*------------------------------------------------------------------------- 2 * 3 * postgres.c 4 * POSTGRES C Backend Interface 5 * 6 * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group 7 * Portions Copyright (c) 1994, Regents of the University of California 8 * 9 * 10 * IDENTIFICATION 11 * src/backend/tcop/postgres.c 12 * 13 * NOTES 14 * this is the "main" module of the postgres backend and 15 * hence the main module of the "traffic cop". 16 * 17 *------------------------------------------------------------------------- 18 */ 19 20 #include "postgres.h" 21 22 #include <fcntl.h> 23 #include <limits.h> 24 #include <signal.h> 25 #include <unistd.h> 26 #include <sys/socket.h> 27 #ifdef HAVE_SYS_SELECT_H 28 #include <sys/select.h> 29 #endif 30 #ifdef HAVE_SYS_RESOURCE_H 31 #include <sys/time.h> 32 #include <sys/resource.h> 33 #endif 34 35 #ifndef HAVE_GETRUSAGE 36 #include "rusagestub.h" 37 #endif 38 39 #include "access/parallel.h" 40 #include "access/printtup.h" 41 #include "access/xact.h" 42 #include "catalog/pg_type.h" 43 #include "commands/async.h" 44 #include "commands/prepare.h" 45 #include "executor/spi.h" 46 #include "jit/jit.h" 47 #include "libpq/libpq.h" 48 #include "libpq/pqformat.h" 49 #include "libpq/pqsignal.h" 50 #include "miscadmin.h" 51 #include "nodes/print.h" 52 #include "optimizer/optimizer.h" 53 #include "pgstat.h" 54 #include "pg_trace.h" 55 #include "parser/analyze.h" 56 #include "parser/parser.h" 57 #include "pg_getopt.h" 58 #include "postmaster/autovacuum.h" 59 #include "postmaster/postmaster.h" 60 #include "replication/logicallauncher.h" 61 #include "replication/logicalworker.h" 62 #include "replication/slot.h" 63 #include "replication/walsender.h" 64 #include "rewrite/rewriteHandler.h" 65 #include "storage/bufmgr.h" 66 #include "storage/ipc.h" 67 #include "storage/proc.h" 68 #include "storage/procsignal.h" 69 #include "storage/sinval.h" 70 #include "tcop/fastpath.h" 71 #include "tcop/pquery.h" 72 #include "tcop/tcopprot.h" 73 #include "tcop/utility.h" 74 #include "utils/lsyscache.h" 75 #include "utils/memutils.h" 76 #include "utils/ps_status.h" 77 #include "utils/snapmgr.h" 78 #include "utils/timeout.h" 79 #include "utils/timestamp.h" 80 #include "mb/pg_wchar.h" 81 82 83 /* ---------------- 84 * global variables 85 * ---------------- 86 */ 87 const char *debug_query_string; /* client-supplied query string */ 88 89 /* Note: whereToSendOutput is initialized for the bootstrap/standalone case */ 90 CommandDest whereToSendOutput = DestDebug; 91 92 /* flag for logging end of session */ 93 bool Log_disconnections = false; 94 95 int log_statement = LOGSTMT_NONE; 96 97 /* GUC variable for maximum stack depth (measured in kilobytes) */ 98 int max_stack_depth = 100; 99 100 /* wait N seconds to allow attach from a debugger */ 101 int PostAuthDelay = 0; 102 103 104 105 /* ---------------- 106 * private variables 107 * ---------------- 108 */ 109 110 /* max_stack_depth converted to bytes for speed of checking */ 111 static long max_stack_depth_bytes = 100 * 1024L; 112 113 /* 114 * Stack base pointer -- initialized by PostmasterMain and inherited by 115 * subprocesses. This is not static because old versions of PL/Java modify 116 * it directly. Newer versions use set_stack_base(), but we want to stay 117 * binary-compatible for the time being. 118 */ 119 char *stack_base_ptr = NULL; 120 121 /* 122 * On IA64 we also have to remember the register stack base. 123 */ 124 #if defined(__ia64__) || defined(__ia64) 125 char *register_stack_base_ptr = NULL; 126 #endif 127 128 /* 129 * Flag to keep track of whether we have started a transaction. 130 * For extended query protocol this has to be remembered across messages. 131 */ 132 static bool xact_started = false; 133 134 /* 135 * Flag to indicate that we are doing the outer loop's read-from-client, 136 * as opposed to any random read from client that might happen within 137 * commands like COPY FROM STDIN. 138 */ 139 static bool DoingCommandRead = false; 140 141 /* 142 * Flags to implement skip-till-Sync-after-error behavior for messages of 143 * the extended query protocol. 144 */ 145 static bool doing_extended_query_message = false; 146 static bool ignore_till_sync = false; 147 148 /* 149 * Flag to keep track of whether statement timeout timer is active. 150 */ 151 static bool stmt_timeout_active = false; 152 153 /* 154 * If an unnamed prepared statement exists, it's stored here. 155 * We keep it separate from the hashtable kept by commands/prepare.c 156 * in order to reduce overhead for short-lived queries. 157 */ 158 static CachedPlanSource *unnamed_stmt_psrc = NULL; 159 160 /* assorted command-line switches */ 161 static const char *userDoption = NULL; /* -D switch */ 162 static bool EchoQuery = false; /* -E switch */ 163 static bool UseSemiNewlineNewline = false; /* -j switch */ 164 165 /* whether or not, and why, we were canceled by conflict with recovery */ 166 static bool RecoveryConflictPending = false; 167 static bool RecoveryConflictRetryable = true; 168 static ProcSignalReason RecoveryConflictReason; 169 170 /* reused buffer to pass to SendRowDescriptionMessage() */ 171 static MemoryContext row_description_context = NULL; 172 static StringInfoData row_description_buf; 173 174 /* ---------------------------------------------------------------- 175 * decls for routines only used in this file 176 * ---------------------------------------------------------------- 177 */ 178 static int InteractiveBackend(StringInfo inBuf); 179 static int interactive_getc(void); 180 static int SocketBackend(StringInfo inBuf); 181 static int ReadCommand(StringInfo inBuf); 182 static void forbidden_in_wal_sender(char firstchar); 183 static List *pg_rewrite_query(Query *query); 184 static bool check_log_statement(List *stmt_list); 185 static int errdetail_execute(List *raw_parsetree_list); 186 static int errdetail_params(ParamListInfo params); 187 static int errdetail_abort(void); 188 static int errdetail_recovery_conflict(void); 189 static void start_xact_command(void); 190 static void finish_xact_command(void); 191 static bool IsTransactionExitStmt(Node *parsetree); 192 static bool IsTransactionExitStmtList(List *pstmts); 193 static bool IsTransactionStmtList(List *pstmts); 194 static void drop_unnamed_stmt(void); 195 static void log_disconnections(int code, Datum arg); 196 static void enable_statement_timeout(void); 197 static void disable_statement_timeout(void); 198 199 200 /* ---------------------------------------------------------------- 201 * routines to obtain user input 202 * ---------------------------------------------------------------- 203 */ 204 205 /* ---------------- 206 * InteractiveBackend() is called for user interactive connections 207 * 208 * the string entered by the user is placed in its parameter inBuf, 209 * and we act like a Q message was received. 210 * 211 * EOF is returned if end-of-file input is seen; time to shut down. 212 * ---------------- 213 */ 214 215 static int 216 InteractiveBackend(StringInfo inBuf) 217 { 218 int c; /* character read from getc() */ 219 220 /* 221 * display a prompt and obtain input from the user 222 */ 223 printf("backend> "); 224 fflush(stdout); 225 226 resetStringInfo(inBuf); 227 228 /* 229 * Read characters until EOF or the appropriate delimiter is seen. 230 */ 231 while ((c = interactive_getc()) != EOF) 232 { 233 if (c == '\n') 234 { 235 if (UseSemiNewlineNewline) 236 { 237 /* 238 * In -j mode, semicolon followed by two newlines ends the 239 * command; otherwise treat newline as regular character. 240 */ 241 if (inBuf->len > 1 && 242 inBuf->data[inBuf->len - 1] == '\n' && 243 inBuf->data[inBuf->len - 2] == ';') 244 { 245 /* might as well drop the second newline */ 246 break; 247 } 248 } 249 else 250 { 251 /* 252 * In plain mode, newline ends the command unless preceded by 253 * backslash. 254 */ 255 if (inBuf->len > 0 && 256 inBuf->data[inBuf->len - 1] == '\\') 257 { 258 /* discard backslash from inBuf */ 259 inBuf->data[--inBuf->len] = '\0'; 260 /* discard newline too */ 261 continue; 262 } 263 else 264 { 265 /* keep the newline character, but end the command */ 266 appendStringInfoChar(inBuf, '\n'); 267 break; 268 } 269 } 270 } 271 272 /* Not newline, or newline treated as regular character */ 273 appendStringInfoChar(inBuf, (char) c); 274 } 275 276 /* No input before EOF signal means time to quit. */ 277 if (c == EOF && inBuf->len == 0) 278 return EOF; 279 280 /* 281 * otherwise we have a user query so process it. 282 */ 283 284 /* Add '\0' to make it look the same as message case. */ 285 appendStringInfoChar(inBuf, (char) '\0'); 286 287 /* 288 * if the query echo flag was given, print the query.. 289 */ 290 if (EchoQuery) 291 printf("statement: %s\n", inBuf->data); 292 fflush(stdout); 293 294 return 'Q'; 295 } 296 297 /* 298 * interactive_getc -- collect one character from stdin 299 * 300 * Even though we are not reading from a "client" process, we still want to 301 * respond to signals, particularly SIGTERM/SIGQUIT. 302 */ 303 static int 304 interactive_getc(void) 305 { 306 int c; 307 308 /* 309 * This will not process catchup interrupts or notifications while 310 * reading. But those can't really be relevant for a standalone backend 311 * anyway. To properly handle SIGTERM there's a hack in die() that 312 * directly processes interrupts at this stage... 313 */ 314 CHECK_FOR_INTERRUPTS(); 315 316 c = getc(stdin); 317 318 ProcessClientReadInterrupt(false); 319 320 return c; 321 } 322 323 /* ---------------- 324 * SocketBackend() Is called for frontend-backend connections 325 * 326 * Returns the message type code, and loads message body data into inBuf. 327 * 328 * EOF is returned if the connection is lost. 329 * ---------------- 330 */ 331 static int 332 SocketBackend(StringInfo inBuf) 333 { 334 int qtype; 335 336 /* 337 * Get message type code from the frontend. 338 */ 339 HOLD_CANCEL_INTERRUPTS(); 340 pq_startmsgread(); 341 qtype = pq_getbyte(); 342 343 if (qtype == EOF) /* frontend disconnected */ 344 { 345 if (IsTransactionState()) 346 ereport(COMMERROR, 347 (errcode(ERRCODE_CONNECTION_FAILURE), 348 errmsg("unexpected EOF on client connection with an open transaction"))); 349 else 350 { 351 /* 352 * Can't send DEBUG log messages to client at this point. Since 353 * we're disconnecting right away, we don't need to restore 354 * whereToSendOutput. 355 */ 356 whereToSendOutput = DestNone; 357 ereport(DEBUG1, 358 (errcode(ERRCODE_CONNECTION_DOES_NOT_EXIST), 359 errmsg("unexpected EOF on client connection"))); 360 } 361 return qtype; 362 } 363 364 /* 365 * Validate message type code before trying to read body; if we have lost 366 * sync, better to say "command unknown" than to run out of memory because 367 * we used garbage as a length word. 368 * 369 * This also gives us a place to set the doing_extended_query_message flag 370 * as soon as possible. 371 */ 372 switch (qtype) 373 { 374 case 'Q': /* simple query */ 375 doing_extended_query_message = false; 376 if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3) 377 { 378 /* old style without length word; convert */ 379 if (pq_getstring(inBuf)) 380 { 381 if (IsTransactionState()) 382 ereport(COMMERROR, 383 (errcode(ERRCODE_CONNECTION_FAILURE), 384 errmsg("unexpected EOF on client connection with an open transaction"))); 385 else 386 { 387 /* 388 * Can't send DEBUG log messages to client at this 389 * point. Since we're disconnecting right away, we 390 * don't need to restore whereToSendOutput. 391 */ 392 whereToSendOutput = DestNone; 393 ereport(DEBUG1, 394 (errcode(ERRCODE_CONNECTION_DOES_NOT_EXIST), 395 errmsg("unexpected EOF on client connection"))); 396 } 397 return EOF; 398 } 399 } 400 break; 401 402 case 'F': /* fastpath function call */ 403 doing_extended_query_message = false; 404 if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3) 405 { 406 if (GetOldFunctionMessage(inBuf)) 407 { 408 if (IsTransactionState()) 409 ereport(COMMERROR, 410 (errcode(ERRCODE_CONNECTION_FAILURE), 411 errmsg("unexpected EOF on client connection with an open transaction"))); 412 else 413 { 414 /* 415 * Can't send DEBUG log messages to client at this 416 * point. Since we're disconnecting right away, we 417 * don't need to restore whereToSendOutput. 418 */ 419 whereToSendOutput = DestNone; 420 ereport(DEBUG1, 421 (errcode(ERRCODE_CONNECTION_DOES_NOT_EXIST), 422 errmsg("unexpected EOF on client connection"))); 423 } 424 return EOF; 425 } 426 } 427 break; 428 429 case 'X': /* terminate */ 430 doing_extended_query_message = false; 431 ignore_till_sync = false; 432 break; 433 434 case 'B': /* bind */ 435 case 'C': /* close */ 436 case 'D': /* describe */ 437 case 'E': /* execute */ 438 case 'H': /* flush */ 439 case 'P': /* parse */ 440 doing_extended_query_message = true; 441 /* these are only legal in protocol 3 */ 442 if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3) 443 ereport(FATAL, 444 (errcode(ERRCODE_PROTOCOL_VIOLATION), 445 errmsg("invalid frontend message type %d", qtype))); 446 break; 447 448 case 'S': /* sync */ 449 /* stop any active skip-till-Sync */ 450 ignore_till_sync = false; 451 /* mark not-extended, so that a new error doesn't begin skip */ 452 doing_extended_query_message = false; 453 /* only legal in protocol 3 */ 454 if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3) 455 ereport(FATAL, 456 (errcode(ERRCODE_PROTOCOL_VIOLATION), 457 errmsg("invalid frontend message type %d", qtype))); 458 break; 459 460 case 'd': /* copy data */ 461 case 'c': /* copy done */ 462 case 'f': /* copy fail */ 463 doing_extended_query_message = false; 464 /* these are only legal in protocol 3 */ 465 if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3) 466 ereport(FATAL, 467 (errcode(ERRCODE_PROTOCOL_VIOLATION), 468 errmsg("invalid frontend message type %d", qtype))); 469 break; 470 471 default: 472 473 /* 474 * Otherwise we got garbage from the frontend. We treat this as 475 * fatal because we have probably lost message boundary sync, and 476 * there's no good way to recover. 477 */ 478 ereport(FATAL, 479 (errcode(ERRCODE_PROTOCOL_VIOLATION), 480 errmsg("invalid frontend message type %d", qtype))); 481 break; 482 } 483 484 /* 485 * In protocol version 3, all frontend messages have a length word next 486 * after the type code; we can read the message contents independently of 487 * the type. 488 */ 489 if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3) 490 { 491 if (pq_getmessage(inBuf, 0)) 492 return EOF; /* suitable message already logged */ 493 } 494 else 495 pq_endmsgread(); 496 RESUME_CANCEL_INTERRUPTS(); 497 498 return qtype; 499 } 500 501 /* ---------------- 502 * ReadCommand reads a command from either the frontend or 503 * standard input, places it in inBuf, and returns the 504 * message type code (first byte of the message). 505 * EOF is returned if end of file. 506 * ---------------- 507 */ 508 static int 509 ReadCommand(StringInfo inBuf) 510 { 511 int result; 512 513 if (whereToSendOutput == DestRemote) 514 result = SocketBackend(inBuf); 515 else 516 result = InteractiveBackend(inBuf); 517 return result; 518 } 519 520 /* 521 * ProcessClientReadInterrupt() - Process interrupts specific to client reads 522 * 523 * This is called just before and after low-level reads. 524 * 'blocked' is true if no data was available to read and we plan to retry, 525 * false if about to read or done reading. 526 * 527 * Must preserve errno! 528 */ 529 void 530 ProcessClientReadInterrupt(bool blocked) 531 { 532 int save_errno = errno; 533 534 if (DoingCommandRead) 535 { 536 /* Check for general interrupts that arrived before/while reading */ 537 CHECK_FOR_INTERRUPTS(); 538 539 /* Process sinval catchup interrupts, if any */ 540 if (catchupInterruptPending) 541 ProcessCatchupInterrupt(); 542 543 /* Process notify interrupts, if any */ 544 if (notifyInterruptPending) 545 ProcessNotifyInterrupt(); 546 } 547 else if (ProcDiePending) 548 { 549 /* 550 * We're dying. If there is no data available to read, then it's safe 551 * (and sane) to handle that now. If we haven't tried to read yet, 552 * make sure the process latch is set, so that if there is no data 553 * then we'll come back here and die. If we're done reading, also 554 * make sure the process latch is set, as we might've undesirably 555 * cleared it while reading. 556 */ 557 if (blocked) 558 CHECK_FOR_INTERRUPTS(); 559 else 560 SetLatch(MyLatch); 561 } 562 563 errno = save_errno; 564 } 565 566 /* 567 * ProcessClientWriteInterrupt() - Process interrupts specific to client writes 568 * 569 * This is called just before and after low-level writes. 570 * 'blocked' is true if no data could be written and we plan to retry, 571 * false if about to write or done writing. 572 * 573 * Must preserve errno! 574 */ 575 void 576 ProcessClientWriteInterrupt(bool blocked) 577 { 578 int save_errno = errno; 579 580 if (ProcDiePending) 581 { 582 /* 583 * We're dying. If it's not possible to write, then we should handle 584 * that immediately, else a stuck client could indefinitely delay our 585 * response to the signal. If we haven't tried to write yet, make 586 * sure the process latch is set, so that if the write would block 587 * then we'll come back here and die. If we're done writing, also 588 * make sure the process latch is set, as we might've undesirably 589 * cleared it while writing. 590 */ 591 if (blocked) 592 { 593 /* 594 * Don't mess with whereToSendOutput if ProcessInterrupts wouldn't 595 * service ProcDiePending. 596 */ 597 if (InterruptHoldoffCount == 0 && CritSectionCount == 0) 598 { 599 /* 600 * We don't want to send the client the error message, as a) 601 * that would possibly block again, and b) it would likely 602 * lead to loss of protocol sync because we may have already 603 * sent a partial protocol message. 604 */ 605 if (whereToSendOutput == DestRemote) 606 whereToSendOutput = DestNone; 607 608 CHECK_FOR_INTERRUPTS(); 609 } 610 } 611 else 612 SetLatch(MyLatch); 613 } 614 615 errno = save_errno; 616 } 617 618 /* 619 * Do raw parsing (only). 620 * 621 * A list of parsetrees (RawStmt nodes) is returned, since there might be 622 * multiple commands in the given string. 623 * 624 * NOTE: for interactive queries, it is important to keep this routine 625 * separate from the analysis & rewrite stages. Analysis and rewriting 626 * cannot be done in an aborted transaction, since they require access to 627 * database tables. So, we rely on the raw parser to determine whether 628 * we've seen a COMMIT or ABORT command; when we are in abort state, other 629 * commands are not processed any further than the raw parse stage. 630 */ 631 List * 632 pg_parse_query(const char *query_string) 633 { 634 List *raw_parsetree_list; 635 636 TRACE_POSTGRESQL_QUERY_PARSE_START(query_string); 637 638 if (log_parser_stats) 639 ResetUsage(); 640 641 raw_parsetree_list = raw_parser(query_string); 642 643 if (log_parser_stats) 644 ShowUsage("PARSER STATISTICS"); 645 646 #ifdef COPY_PARSE_PLAN_TREES 647 /* Optional debugging check: pass raw parsetrees through copyObject() */ 648 { 649 List *new_list = copyObject(raw_parsetree_list); 650 651 /* This checks both copyObject() and the equal() routines... */ 652 if (!equal(new_list, raw_parsetree_list)) 653 elog(WARNING, "copyObject() failed to produce an equal raw parse tree"); 654 else 655 raw_parsetree_list = new_list; 656 } 657 #endif 658 659 /* 660 * Currently, outfuncs/readfuncs support is missing for many raw parse 661 * tree nodes, so we don't try to implement WRITE_READ_PARSE_PLAN_TREES 662 * here. 663 */ 664 665 TRACE_POSTGRESQL_QUERY_PARSE_DONE(query_string); 666 667 return raw_parsetree_list; 668 } 669 670 /* 671 * Given a raw parsetree (gram.y output), and optionally information about 672 * types of parameter symbols ($n), perform parse analysis and rule rewriting. 673 * 674 * A list of Query nodes is returned, since either the analyzer or the 675 * rewriter might expand one query to several. 676 * 677 * NOTE: for reasons mentioned above, this must be separate from raw parsing. 678 */ 679 List * 680 pg_analyze_and_rewrite(RawStmt *parsetree, const char *query_string, 681 Oid *paramTypes, int numParams, 682 QueryEnvironment *queryEnv) 683 { 684 Query *query; 685 List *querytree_list; 686 687 TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string); 688 689 /* 690 * (1) Perform parse analysis. 691 */ 692 if (log_parser_stats) 693 ResetUsage(); 694 695 query = parse_analyze(parsetree, query_string, paramTypes, numParams, 696 queryEnv); 697 698 if (log_parser_stats) 699 ShowUsage("PARSE ANALYSIS STATISTICS"); 700 701 /* 702 * (2) Rewrite the queries, as necessary 703 */ 704 querytree_list = pg_rewrite_query(query); 705 706 TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string); 707 708 return querytree_list; 709 } 710 711 /* 712 * Do parse analysis and rewriting. This is the same as pg_analyze_and_rewrite 713 * except that external-parameter resolution is determined by parser callback 714 * hooks instead of a fixed list of parameter datatypes. 715 */ 716 List * 717 pg_analyze_and_rewrite_params(RawStmt *parsetree, 718 const char *query_string, 719 ParserSetupHook parserSetup, 720 void *parserSetupArg, 721 QueryEnvironment *queryEnv) 722 { 723 ParseState *pstate; 724 Query *query; 725 List *querytree_list; 726 727 Assert(query_string != NULL); /* required as of 8.4 */ 728 729 TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string); 730 731 /* 732 * (1) Perform parse analysis. 733 */ 734 if (log_parser_stats) 735 ResetUsage(); 736 737 pstate = make_parsestate(NULL); 738 pstate->p_sourcetext = query_string; 739 pstate->p_queryEnv = queryEnv; 740 (*parserSetup) (pstate, parserSetupArg); 741 742 query = transformTopLevelStmt(pstate, parsetree); 743 744 if (post_parse_analyze_hook) 745 (*post_parse_analyze_hook) (pstate, query); 746 747 free_parsestate(pstate); 748 749 if (log_parser_stats) 750 ShowUsage("PARSE ANALYSIS STATISTICS"); 751 752 /* 753 * (2) Rewrite the queries, as necessary 754 */ 755 querytree_list = pg_rewrite_query(query); 756 757 TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string); 758 759 return querytree_list; 760 } 761 762 /* 763 * Perform rewriting of a query produced by parse analysis. 764 * 765 * Note: query must just have come from the parser, because we do not do 766 * AcquireRewriteLocks() on it. 767 */ 768 static List * 769 pg_rewrite_query(Query *query) 770 { 771 List *querytree_list; 772 773 if (Debug_print_parse) 774 elog_node_display(LOG, "parse tree", query, 775 Debug_pretty_print); 776 777 if (log_parser_stats) 778 ResetUsage(); 779 780 if (query->commandType == CMD_UTILITY) 781 { 782 /* don't rewrite utilities, just dump 'em into result list */ 783 querytree_list = list_make1(query); 784 } 785 else 786 { 787 /* rewrite regular queries */ 788 querytree_list = QueryRewrite(query); 789 } 790 791 if (log_parser_stats) 792 ShowUsage("REWRITER STATISTICS"); 793 794 #ifdef COPY_PARSE_PLAN_TREES 795 /* Optional debugging check: pass querytree through copyObject() */ 796 { 797 List *new_list; 798 799 new_list = copyObject(querytree_list); 800 /* This checks both copyObject() and the equal() routines... */ 801 if (!equal(new_list, querytree_list)) 802 elog(WARNING, "copyObject() failed to produce equal parse tree"); 803 else 804 querytree_list = new_list; 805 } 806 #endif 807 808 #ifdef WRITE_READ_PARSE_PLAN_TREES 809 /* Optional debugging check: pass querytree through outfuncs/readfuncs */ 810 { 811 List *new_list = NIL; 812 ListCell *lc; 813 814 /* 815 * We currently lack outfuncs/readfuncs support for most utility 816 * statement types, so only attempt to write/read non-utility queries. 817 */ 818 foreach(lc, querytree_list) 819 { 820 Query *query = castNode(Query, lfirst(lc)); 821 822 if (query->commandType != CMD_UTILITY) 823 { 824 char *str = nodeToString(query); 825 Query *new_query = stringToNodeWithLocations(str); 826 827 /* 828 * queryId is not saved in stored rules, but we must preserve 829 * it here to avoid breaking pg_stat_statements. 830 */ 831 new_query->queryId = query->queryId; 832 833 new_list = lappend(new_list, new_query); 834 pfree(str); 835 } 836 else 837 new_list = lappend(new_list, query); 838 } 839 840 /* This checks both outfuncs/readfuncs and the equal() routines... */ 841 if (!equal(new_list, querytree_list)) 842 elog(WARNING, "outfuncs/readfuncs failed to produce equal parse tree"); 843 else 844 querytree_list = new_list; 845 } 846 #endif 847 848 if (Debug_print_rewritten) 849 elog_node_display(LOG, "rewritten parse tree", querytree_list, 850 Debug_pretty_print); 851 852 return querytree_list; 853 } 854 855 856 /* 857 * Generate a plan for a single already-rewritten query. 858 * This is a thin wrapper around planner() and takes the same parameters. 859 */ 860 PlannedStmt * 861 pg_plan_query(Query *querytree, int cursorOptions, ParamListInfo boundParams) 862 { 863 PlannedStmt *plan; 864 865 /* Utility commands have no plans. */ 866 if (querytree->commandType == CMD_UTILITY) 867 return NULL; 868 869 /* Planner must have a snapshot in case it calls user-defined functions. */ 870 Assert(ActiveSnapshotSet()); 871 872 TRACE_POSTGRESQL_QUERY_PLAN_START(); 873 874 if (log_planner_stats) 875 ResetUsage(); 876 877 /* call the optimizer */ 878 plan = planner(querytree, cursorOptions, boundParams); 879 880 if (log_planner_stats) 881 ShowUsage("PLANNER STATISTICS"); 882 883 #ifdef COPY_PARSE_PLAN_TREES 884 /* Optional debugging check: pass plan tree through copyObject() */ 885 { 886 PlannedStmt *new_plan = copyObject(plan); 887 888 /* 889 * equal() currently does not have routines to compare Plan nodes, so 890 * don't try to test equality here. Perhaps fix someday? 891 */ 892 #ifdef NOT_USED 893 /* This checks both copyObject() and the equal() routines... */ 894 if (!equal(new_plan, plan)) 895 elog(WARNING, "copyObject() failed to produce an equal plan tree"); 896 else 897 #endif 898 plan = new_plan; 899 } 900 #endif 901 902 #ifdef WRITE_READ_PARSE_PLAN_TREES 903 /* Optional debugging check: pass plan tree through outfuncs/readfuncs */ 904 { 905 char *str; 906 PlannedStmt *new_plan; 907 908 str = nodeToString(plan); 909 new_plan = stringToNodeWithLocations(str); 910 pfree(str); 911 912 /* 913 * equal() currently does not have routines to compare Plan nodes, so 914 * don't try to test equality here. Perhaps fix someday? 915 */ 916 #ifdef NOT_USED 917 /* This checks both outfuncs/readfuncs and the equal() routines... */ 918 if (!equal(new_plan, plan)) 919 elog(WARNING, "outfuncs/readfuncs failed to produce an equal plan tree"); 920 else 921 #endif 922 plan = new_plan; 923 } 924 #endif 925 926 /* 927 * Print plan if debugging. 928 */ 929 if (Debug_print_plan) 930 elog_node_display(LOG, "plan", plan, Debug_pretty_print); 931 932 TRACE_POSTGRESQL_QUERY_PLAN_DONE(); 933 934 return plan; 935 } 936 937 /* 938 * Generate plans for a list of already-rewritten queries. 939 * 940 * For normal optimizable statements, invoke the planner. For utility 941 * statements, just make a wrapper PlannedStmt node. 942 * 943 * The result is a list of PlannedStmt nodes. 944 */ 945 List * 946 pg_plan_queries(List *querytrees, int cursorOptions, ParamListInfo boundParams) 947 { 948 List *stmt_list = NIL; 949 ListCell *query_list; 950 951 foreach(query_list, querytrees) 952 { 953 Query *query = lfirst_node(Query, query_list); 954 PlannedStmt *stmt; 955 956 if (query->commandType == CMD_UTILITY) 957 { 958 /* Utility commands require no planning. */ 959 stmt = makeNode(PlannedStmt); 960 stmt->commandType = CMD_UTILITY; 961 stmt->canSetTag = query->canSetTag; 962 stmt->utilityStmt = query->utilityStmt; 963 stmt->stmt_location = query->stmt_location; 964 stmt->stmt_len = query->stmt_len; 965 } 966 else 967 { 968 stmt = pg_plan_query(query, cursorOptions, boundParams); 969 } 970 971 stmt_list = lappend(stmt_list, stmt); 972 } 973 974 return stmt_list; 975 } 976 977 978 /* 979 * exec_simple_query 980 * 981 * Execute a "simple Query" protocol message. 982 */ 983 static void 984 exec_simple_query(const char *query_string) 985 { 986 CommandDest dest = whereToSendOutput; 987 MemoryContext oldcontext; 988 List *parsetree_list; 989 ListCell *parsetree_item; 990 bool save_log_statement_stats = log_statement_stats; 991 bool was_logged = false; 992 bool use_implicit_block; 993 char msec_str[32]; 994 995 /* 996 * Report query to various monitoring facilities. 997 */ 998 debug_query_string = query_string; 999 1000 pgstat_report_activity(STATE_RUNNING, query_string); 1001 1002 TRACE_POSTGRESQL_QUERY_START(query_string); 1003 1004 /* 1005 * We use save_log_statement_stats so ShowUsage doesn't report incorrect 1006 * results because ResetUsage wasn't called. 1007 */ 1008 if (save_log_statement_stats) 1009 ResetUsage(); 1010 1011 /* 1012 * Start up a transaction command. All queries generated by the 1013 * query_string will be in this same command block, *unless* we find a 1014 * BEGIN/COMMIT/ABORT statement; we have to force a new xact command after 1015 * one of those, else bad things will happen in xact.c. (Note that this 1016 * will normally change current memory context.) 1017 */ 1018 start_xact_command(); 1019 1020 /* 1021 * Zap any pre-existing unnamed statement. (While not strictly necessary, 1022 * it seems best to define simple-Query mode as if it used the unnamed 1023 * statement and portal; this ensures we recover any storage used by prior 1024 * unnamed operations.) 1025 */ 1026 drop_unnamed_stmt(); 1027 1028 /* 1029 * Switch to appropriate context for constructing parsetrees. 1030 */ 1031 oldcontext = MemoryContextSwitchTo(MessageContext); 1032 1033 /* 1034 * Do basic parsing of the query or queries (this should be safe even if 1035 * we are in aborted transaction state!) 1036 */ 1037 parsetree_list = pg_parse_query(query_string); 1038 1039 /* Log immediately if dictated by log_statement */ 1040 if (check_log_statement(parsetree_list)) 1041 { 1042 ereport(LOG, 1043 (errmsg("statement: %s", query_string), 1044 errhidestmt(true), 1045 errdetail_execute(parsetree_list))); 1046 was_logged = true; 1047 } 1048 1049 /* 1050 * Switch back to transaction context to enter the loop. 1051 */ 1052 MemoryContextSwitchTo(oldcontext); 1053 1054 /* 1055 * For historical reasons, if multiple SQL statements are given in a 1056 * single "simple Query" message, we execute them as a single transaction, 1057 * unless explicit transaction control commands are included to make 1058 * portions of the list be separate transactions. To represent this 1059 * behavior properly in the transaction machinery, we use an "implicit" 1060 * transaction block. 1061 */ 1062 use_implicit_block = (list_length(parsetree_list) > 1); 1063 1064 /* 1065 * Run through the raw parsetree(s) and process each one. 1066 */ 1067 foreach(parsetree_item, parsetree_list) 1068 { 1069 RawStmt *parsetree = lfirst_node(RawStmt, parsetree_item); 1070 bool snapshot_set = false; 1071 const char *commandTag; 1072 char completionTag[COMPLETION_TAG_BUFSIZE]; 1073 List *querytree_list, 1074 *plantree_list; 1075 Portal portal; 1076 DestReceiver *receiver; 1077 int16 format; 1078 1079 /* 1080 * Get the command name for use in status display (it also becomes the 1081 * default completion tag, down inside PortalRun). Set ps_status and 1082 * do any special start-of-SQL-command processing needed by the 1083 * destination. 1084 */ 1085 commandTag = CreateCommandTag(parsetree->stmt); 1086 1087 set_ps_display(commandTag, false); 1088 1089 BeginCommand(commandTag, dest); 1090 1091 /* 1092 * If we are in an aborted transaction, reject all commands except 1093 * COMMIT/ABORT. It is important that this test occur before we try 1094 * to do parse analysis, rewrite, or planning, since all those phases 1095 * try to do database accesses, which may fail in abort state. (It 1096 * might be safe to allow some additional utility commands in this 1097 * state, but not many...) 1098 */ 1099 if (IsAbortedTransactionBlockState() && 1100 !IsTransactionExitStmt(parsetree->stmt)) 1101 ereport(ERROR, 1102 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION), 1103 errmsg("current transaction is aborted, " 1104 "commands ignored until end of transaction block"), 1105 errdetail_abort())); 1106 1107 /* Make sure we are in a transaction command */ 1108 start_xact_command(); 1109 1110 /* 1111 * If using an implicit transaction block, and we're not already in a 1112 * transaction block, start an implicit block to force this statement 1113 * to be grouped together with any following ones. (We must do this 1114 * each time through the loop; otherwise, a COMMIT/ROLLBACK in the 1115 * list would cause later statements to not be grouped.) 1116 */ 1117 if (use_implicit_block) 1118 BeginImplicitTransactionBlock(); 1119 1120 /* If we got a cancel signal in parsing or prior command, quit */ 1121 CHECK_FOR_INTERRUPTS(); 1122 1123 /* 1124 * Set up a snapshot if parse analysis/planning will need one. 1125 */ 1126 if (analyze_requires_snapshot(parsetree)) 1127 { 1128 PushActiveSnapshot(GetTransactionSnapshot()); 1129 snapshot_set = true; 1130 } 1131 1132 /* 1133 * OK to analyze, rewrite, and plan this query. 1134 * 1135 * Switch to appropriate context for constructing querytrees (again, 1136 * these must outlive the execution context). 1137 */ 1138 oldcontext = MemoryContextSwitchTo(MessageContext); 1139 1140 querytree_list = pg_analyze_and_rewrite(parsetree, query_string, 1141 NULL, 0, NULL); 1142 1143 plantree_list = pg_plan_queries(querytree_list, 1144 CURSOR_OPT_PARALLEL_OK, NULL); 1145 1146 /* Done with the snapshot used for parsing/planning */ 1147 if (snapshot_set) 1148 PopActiveSnapshot(); 1149 1150 /* If we got a cancel signal in analysis or planning, quit */ 1151 CHECK_FOR_INTERRUPTS(); 1152 1153 /* 1154 * Create unnamed portal to run the query or queries in. If there 1155 * already is one, silently drop it. 1156 */ 1157 portal = CreatePortal("", true, true); 1158 /* Don't display the portal in pg_cursors */ 1159 portal->visible = false; 1160 1161 /* 1162 * We don't have to copy anything into the portal, because everything 1163 * we are passing here is in MessageContext, which will outlive the 1164 * portal anyway. 1165 */ 1166 PortalDefineQuery(portal, 1167 NULL, 1168 query_string, 1169 commandTag, 1170 plantree_list, 1171 NULL); 1172 1173 /* 1174 * Start the portal. No parameters here. 1175 */ 1176 PortalStart(portal, NULL, 0, InvalidSnapshot); 1177 1178 /* 1179 * Select the appropriate output format: text unless we are doing a 1180 * FETCH from a binary cursor. (Pretty grotty to have to do this here 1181 * --- but it avoids grottiness in other places. Ah, the joys of 1182 * backward compatibility...) 1183 */ 1184 format = 0; /* TEXT is default */ 1185 if (IsA(parsetree->stmt, FetchStmt)) 1186 { 1187 FetchStmt *stmt = (FetchStmt *) parsetree->stmt; 1188 1189 if (!stmt->ismove) 1190 { 1191 Portal fportal = GetPortalByName(stmt->portalname); 1192 1193 if (PortalIsValid(fportal) && 1194 (fportal->cursorOptions & CURSOR_OPT_BINARY)) 1195 format = 1; /* BINARY */ 1196 } 1197 } 1198 PortalSetResultFormat(portal, 1, &format); 1199 1200 /* 1201 * Now we can create the destination receiver object. 1202 */ 1203 receiver = CreateDestReceiver(dest); 1204 if (dest == DestRemote) 1205 SetRemoteDestReceiverParams(receiver, portal); 1206 1207 /* 1208 * Switch back to transaction context for execution. 1209 */ 1210 MemoryContextSwitchTo(oldcontext); 1211 1212 /* 1213 * Run the portal to completion, and then drop it (and the receiver). 1214 */ 1215 (void) PortalRun(portal, 1216 FETCH_ALL, 1217 true, /* always top level */ 1218 true, 1219 receiver, 1220 receiver, 1221 completionTag); 1222 1223 receiver->rDestroy(receiver); 1224 1225 PortalDrop(portal, false); 1226 1227 if (lnext(parsetree_item) == NULL) 1228 { 1229 /* 1230 * If this is the last parsetree of the query string, close down 1231 * transaction statement before reporting command-complete. This 1232 * is so that any end-of-transaction errors are reported before 1233 * the command-complete message is issued, to avoid confusing 1234 * clients who will expect either a command-complete message or an 1235 * error, not one and then the other. Also, if we're using an 1236 * implicit transaction block, we must close that out first. 1237 */ 1238 if (use_implicit_block) 1239 EndImplicitTransactionBlock(); 1240 finish_xact_command(); 1241 } 1242 else if (IsA(parsetree->stmt, TransactionStmt)) 1243 { 1244 /* 1245 * If this was a transaction control statement, commit it. We will 1246 * start a new xact command for the next command. 1247 */ 1248 finish_xact_command(); 1249 } 1250 else 1251 { 1252 /* 1253 * We need a CommandCounterIncrement after every query, except 1254 * those that start or end a transaction block. 1255 */ 1256 CommandCounterIncrement(); 1257 } 1258 1259 /* 1260 * Tell client that we're done with this query. Note we emit exactly 1261 * one EndCommand report for each raw parsetree, thus one for each SQL 1262 * command the client sent, regardless of rewriting. (But a command 1263 * aborted by error will not send an EndCommand report at all.) 1264 */ 1265 EndCommand(completionTag, dest); 1266 } /* end loop over parsetrees */ 1267 1268 /* 1269 * Close down transaction statement, if one is open. (This will only do 1270 * something if the parsetree list was empty; otherwise the last loop 1271 * iteration already did it.) 1272 */ 1273 finish_xact_command(); 1274 1275 /* 1276 * If there were no parsetrees, return EmptyQueryResponse message. 1277 */ 1278 if (!parsetree_list) 1279 NullCommand(dest); 1280 1281 /* 1282 * Emit duration logging if appropriate. 1283 */ 1284 switch (check_log_duration(msec_str, was_logged)) 1285 { 1286 case 1: 1287 ereport(LOG, 1288 (errmsg("duration: %s ms", msec_str), 1289 errhidestmt(true))); 1290 break; 1291 case 2: 1292 ereport(LOG, 1293 (errmsg("duration: %s ms statement: %s", 1294 msec_str, query_string), 1295 errhidestmt(true), 1296 errdetail_execute(parsetree_list))); 1297 break; 1298 } 1299 1300 if (save_log_statement_stats) 1301 ShowUsage("QUERY STATISTICS"); 1302 1303 TRACE_POSTGRESQL_QUERY_DONE(query_string); 1304 1305 debug_query_string = NULL; 1306 } 1307 1308 /* 1309 * exec_parse_message 1310 * 1311 * Execute a "Parse" protocol message. 1312 */ 1313 static void 1314 exec_parse_message(const char *query_string, /* string to execute */ 1315 const char *stmt_name, /* name for prepared stmt */ 1316 Oid *paramTypes, /* parameter types */ 1317 int numParams) /* number of parameters */ 1318 { 1319 MemoryContext unnamed_stmt_context = NULL; 1320 MemoryContext oldcontext; 1321 List *parsetree_list; 1322 RawStmt *raw_parse_tree; 1323 const char *commandTag; 1324 List *querytree_list; 1325 CachedPlanSource *psrc; 1326 bool is_named; 1327 bool save_log_statement_stats = log_statement_stats; 1328 char msec_str[32]; 1329 1330 /* 1331 * Report query to various monitoring facilities. 1332 */ 1333 debug_query_string = query_string; 1334 1335 pgstat_report_activity(STATE_RUNNING, query_string); 1336 1337 set_ps_display("PARSE", false); 1338 1339 if (save_log_statement_stats) 1340 ResetUsage(); 1341 1342 ereport(DEBUG2, 1343 (errmsg("parse %s: %s", 1344 *stmt_name ? stmt_name : "<unnamed>", 1345 query_string))); 1346 1347 /* 1348 * Start up a transaction command so we can run parse analysis etc. (Note 1349 * that this will normally change current memory context.) Nothing happens 1350 * if we are already in one. This also arms the statement timeout if 1351 * necessary. 1352 */ 1353 start_xact_command(); 1354 1355 /* 1356 * Switch to appropriate context for constructing parsetrees. 1357 * 1358 * We have two strategies depending on whether the prepared statement is 1359 * named or not. For a named prepared statement, we do parsing in 1360 * MessageContext and copy the finished trees into the prepared 1361 * statement's plancache entry; then the reset of MessageContext releases 1362 * temporary space used by parsing and rewriting. For an unnamed prepared 1363 * statement, we assume the statement isn't going to hang around long, so 1364 * getting rid of temp space quickly is probably not worth the costs of 1365 * copying parse trees. So in this case, we create the plancache entry's 1366 * query_context here, and do all the parsing work therein. 1367 */ 1368 is_named = (stmt_name[0] != '\0'); 1369 if (is_named) 1370 { 1371 /* Named prepared statement --- parse in MessageContext */ 1372 oldcontext = MemoryContextSwitchTo(MessageContext); 1373 } 1374 else 1375 { 1376 /* Unnamed prepared statement --- release any prior unnamed stmt */ 1377 drop_unnamed_stmt(); 1378 /* Create context for parsing */ 1379 unnamed_stmt_context = 1380 AllocSetContextCreate(MessageContext, 1381 "unnamed prepared statement", 1382 ALLOCSET_DEFAULT_SIZES); 1383 oldcontext = MemoryContextSwitchTo(unnamed_stmt_context); 1384 } 1385 1386 /* 1387 * Do basic parsing of the query or queries (this should be safe even if 1388 * we are in aborted transaction state!) 1389 */ 1390 parsetree_list = pg_parse_query(query_string); 1391 1392 /* 1393 * We only allow a single user statement in a prepared statement. This is 1394 * mainly to keep the protocol simple --- otherwise we'd need to worry 1395 * about multiple result tupdescs and things like that. 1396 */ 1397 if (list_length(parsetree_list) > 1) 1398 ereport(ERROR, 1399 (errcode(ERRCODE_SYNTAX_ERROR), 1400 errmsg("cannot insert multiple commands into a prepared statement"))); 1401 1402 if (parsetree_list != NIL) 1403 { 1404 Query *query; 1405 bool snapshot_set = false; 1406 1407 raw_parse_tree = linitial_node(RawStmt, parsetree_list); 1408 1409 /* 1410 * Get the command name for possible use in status display. 1411 */ 1412 commandTag = CreateCommandTag(raw_parse_tree->stmt); 1413 1414 /* 1415 * If we are in an aborted transaction, reject all commands except 1416 * COMMIT/ROLLBACK. It is important that this test occur before we 1417 * try to do parse analysis, rewrite, or planning, since all those 1418 * phases try to do database accesses, which may fail in abort state. 1419 * (It might be safe to allow some additional utility commands in this 1420 * state, but not many...) 1421 */ 1422 if (IsAbortedTransactionBlockState() && 1423 !IsTransactionExitStmt(raw_parse_tree->stmt)) 1424 ereport(ERROR, 1425 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION), 1426 errmsg("current transaction is aborted, " 1427 "commands ignored until end of transaction block"), 1428 errdetail_abort())); 1429 1430 /* 1431 * Create the CachedPlanSource before we do parse analysis, since it 1432 * needs to see the unmodified raw parse tree. 1433 */ 1434 psrc = CreateCachedPlan(raw_parse_tree, query_string, commandTag); 1435 1436 /* 1437 * Set up a snapshot if parse analysis will need one. 1438 */ 1439 if (analyze_requires_snapshot(raw_parse_tree)) 1440 { 1441 PushActiveSnapshot(GetTransactionSnapshot()); 1442 snapshot_set = true; 1443 } 1444 1445 /* 1446 * Analyze and rewrite the query. Note that the originally specified 1447 * parameter set is not required to be complete, so we have to use 1448 * parse_analyze_varparams(). 1449 */ 1450 if (log_parser_stats) 1451 ResetUsage(); 1452 1453 query = parse_analyze_varparams(raw_parse_tree, 1454 query_string, 1455 ¶mTypes, 1456 &numParams); 1457 1458 /* 1459 * Check all parameter types got determined. 1460 */ 1461 for (int i = 0; i < numParams; i++) 1462 { 1463 Oid ptype = paramTypes[i]; 1464 1465 if (ptype == InvalidOid || ptype == UNKNOWNOID) 1466 ereport(ERROR, 1467 (errcode(ERRCODE_INDETERMINATE_DATATYPE), 1468 errmsg("could not determine data type of parameter $%d", 1469 i + 1))); 1470 } 1471 1472 if (log_parser_stats) 1473 ShowUsage("PARSE ANALYSIS STATISTICS"); 1474 1475 querytree_list = pg_rewrite_query(query); 1476 1477 /* Done with the snapshot used for parsing */ 1478 if (snapshot_set) 1479 PopActiveSnapshot(); 1480 } 1481 else 1482 { 1483 /* Empty input string. This is legal. */ 1484 raw_parse_tree = NULL; 1485 commandTag = NULL; 1486 psrc = CreateCachedPlan(raw_parse_tree, query_string, commandTag); 1487 querytree_list = NIL; 1488 } 1489 1490 /* 1491 * CachedPlanSource must be a direct child of MessageContext before we 1492 * reparent unnamed_stmt_context under it, else we have a disconnected 1493 * circular subgraph. Klugy, but less so than flipping contexts even more 1494 * above. 1495 */ 1496 if (unnamed_stmt_context) 1497 MemoryContextSetParent(psrc->context, MessageContext); 1498 1499 /* Finish filling in the CachedPlanSource */ 1500 CompleteCachedPlan(psrc, 1501 querytree_list, 1502 unnamed_stmt_context, 1503 paramTypes, 1504 numParams, 1505 NULL, 1506 NULL, 1507 CURSOR_OPT_PARALLEL_OK, /* allow parallel mode */ 1508 true); /* fixed result */ 1509 1510 /* If we got a cancel signal during analysis, quit */ 1511 CHECK_FOR_INTERRUPTS(); 1512 1513 if (is_named) 1514 { 1515 /* 1516 * Store the query as a prepared statement. 1517 */ 1518 StorePreparedStatement(stmt_name, psrc, false); 1519 } 1520 else 1521 { 1522 /* 1523 * We just save the CachedPlanSource into unnamed_stmt_psrc. 1524 */ 1525 SaveCachedPlan(psrc); 1526 unnamed_stmt_psrc = psrc; 1527 } 1528 1529 MemoryContextSwitchTo(oldcontext); 1530 1531 /* 1532 * We do NOT close the open transaction command here; that only happens 1533 * when the client sends Sync. Instead, do CommandCounterIncrement just 1534 * in case something happened during parse/plan. 1535 */ 1536 CommandCounterIncrement(); 1537 1538 /* 1539 * Send ParseComplete. 1540 */ 1541 if (whereToSendOutput == DestRemote) 1542 pq_putemptymessage('1'); 1543 1544 /* 1545 * Emit duration logging if appropriate. 1546 */ 1547 switch (check_log_duration(msec_str, false)) 1548 { 1549 case 1: 1550 ereport(LOG, 1551 (errmsg("duration: %s ms", msec_str), 1552 errhidestmt(true))); 1553 break; 1554 case 2: 1555 ereport(LOG, 1556 (errmsg("duration: %s ms parse %s: %s", 1557 msec_str, 1558 *stmt_name ? stmt_name : "<unnamed>", 1559 query_string), 1560 errhidestmt(true))); 1561 break; 1562 } 1563 1564 if (save_log_statement_stats) 1565 ShowUsage("PARSE MESSAGE STATISTICS"); 1566 1567 debug_query_string = NULL; 1568 } 1569 1570 /* 1571 * exec_bind_message 1572 * 1573 * Process a "Bind" message to create a portal from a prepared statement 1574 */ 1575 static void 1576 exec_bind_message(StringInfo input_message) 1577 { 1578 const char *portal_name; 1579 const char *stmt_name; 1580 int numPFormats; 1581 int16 *pformats = NULL; 1582 int numParams; 1583 int numRFormats; 1584 int16 *rformats = NULL; 1585 CachedPlanSource *psrc; 1586 CachedPlan *cplan; 1587 Portal portal; 1588 char *query_string; 1589 char *saved_stmt_name; 1590 ParamListInfo params; 1591 MemoryContext oldContext; 1592 bool save_log_statement_stats = log_statement_stats; 1593 bool snapshot_set = false; 1594 char msec_str[32]; 1595 1596 /* Get the fixed part of the message */ 1597 portal_name = pq_getmsgstring(input_message); 1598 stmt_name = pq_getmsgstring(input_message); 1599 1600 ereport(DEBUG2, 1601 (errmsg("bind %s to %s", 1602 *portal_name ? portal_name : "<unnamed>", 1603 *stmt_name ? stmt_name : "<unnamed>"))); 1604 1605 /* Find prepared statement */ 1606 if (stmt_name[0] != '\0') 1607 { 1608 PreparedStatement *pstmt; 1609 1610 pstmt = FetchPreparedStatement(stmt_name, true); 1611 psrc = pstmt->plansource; 1612 } 1613 else 1614 { 1615 /* special-case the unnamed statement */ 1616 psrc = unnamed_stmt_psrc; 1617 if (!psrc) 1618 ereport(ERROR, 1619 (errcode(ERRCODE_UNDEFINED_PSTATEMENT), 1620 errmsg("unnamed prepared statement does not exist"))); 1621 } 1622 1623 /* 1624 * Report query to various monitoring facilities. 1625 */ 1626 debug_query_string = psrc->query_string; 1627 1628 pgstat_report_activity(STATE_RUNNING, psrc->query_string); 1629 1630 set_ps_display("BIND", false); 1631 1632 if (save_log_statement_stats) 1633 ResetUsage(); 1634 1635 /* 1636 * Start up a transaction command so we can call functions etc. (Note that 1637 * this will normally change current memory context.) Nothing happens if 1638 * we are already in one. This also arms the statement timeout if 1639 * necessary. 1640 */ 1641 start_xact_command(); 1642 1643 /* Switch back to message context */ 1644 MemoryContextSwitchTo(MessageContext); 1645 1646 /* Get the parameter format codes */ 1647 numPFormats = pq_getmsgint(input_message, 2); 1648 if (numPFormats > 0) 1649 { 1650 pformats = (int16 *) palloc(numPFormats * sizeof(int16)); 1651 for (int i = 0; i < numPFormats; i++) 1652 pformats[i] = pq_getmsgint(input_message, 2); 1653 } 1654 1655 /* Get the parameter value count */ 1656 numParams = pq_getmsgint(input_message, 2); 1657 1658 if (numPFormats > 1 && numPFormats != numParams) 1659 ereport(ERROR, 1660 (errcode(ERRCODE_PROTOCOL_VIOLATION), 1661 errmsg("bind message has %d parameter formats but %d parameters", 1662 numPFormats, numParams))); 1663 1664 if (numParams != psrc->num_params) 1665 ereport(ERROR, 1666 (errcode(ERRCODE_PROTOCOL_VIOLATION), 1667 errmsg("bind message supplies %d parameters, but prepared statement \"%s\" requires %d", 1668 numParams, stmt_name, psrc->num_params))); 1669 1670 /* 1671 * If we are in aborted transaction state, the only portals we can 1672 * actually run are those containing COMMIT or ROLLBACK commands. We 1673 * disallow binding anything else to avoid problems with infrastructure 1674 * that expects to run inside a valid transaction. We also disallow 1675 * binding any parameters, since we can't risk calling user-defined I/O 1676 * functions. 1677 */ 1678 if (IsAbortedTransactionBlockState() && 1679 (!(psrc->raw_parse_tree && 1680 IsTransactionExitStmt(psrc->raw_parse_tree->stmt)) || 1681 numParams != 0)) 1682 ereport(ERROR, 1683 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION), 1684 errmsg("current transaction is aborted, " 1685 "commands ignored until end of transaction block"), 1686 errdetail_abort())); 1687 1688 /* 1689 * Create the portal. Allow silent replacement of an existing portal only 1690 * if the unnamed portal is specified. 1691 */ 1692 if (portal_name[0] == '\0') 1693 portal = CreatePortal(portal_name, true, true); 1694 else 1695 portal = CreatePortal(portal_name, false, false); 1696 1697 /* 1698 * Prepare to copy stuff into the portal's memory context. We do all this 1699 * copying first, because it could possibly fail (out-of-memory) and we 1700 * don't want a failure to occur between GetCachedPlan and 1701 * PortalDefineQuery; that would result in leaking our plancache refcount. 1702 */ 1703 oldContext = MemoryContextSwitchTo(portal->portalContext); 1704 1705 /* Copy the plan's query string into the portal */ 1706 query_string = pstrdup(psrc->query_string); 1707 1708 /* Likewise make a copy of the statement name, unless it's unnamed */ 1709 if (stmt_name[0]) 1710 saved_stmt_name = pstrdup(stmt_name); 1711 else 1712 saved_stmt_name = NULL; 1713 1714 /* 1715 * Set a snapshot if we have parameters to fetch (since the input 1716 * functions might need it) or the query isn't a utility command (and 1717 * hence could require redoing parse analysis and planning). We keep the 1718 * snapshot active till we're done, so that plancache.c doesn't have to 1719 * take new ones. 1720 */ 1721 if (numParams > 0 || 1722 (psrc->raw_parse_tree && 1723 analyze_requires_snapshot(psrc->raw_parse_tree))) 1724 { 1725 PushActiveSnapshot(GetTransactionSnapshot()); 1726 snapshot_set = true; 1727 } 1728 1729 /* 1730 * Fetch parameters, if any, and store in the portal's memory context. 1731 */ 1732 if (numParams > 0) 1733 { 1734 params = makeParamList(numParams); 1735 1736 for (int paramno = 0; paramno < numParams; paramno++) 1737 { 1738 Oid ptype = psrc->param_types[paramno]; 1739 int32 plength; 1740 Datum pval; 1741 bool isNull; 1742 StringInfoData pbuf; 1743 char csave; 1744 int16 pformat; 1745 1746 plength = pq_getmsgint(input_message, 4); 1747 isNull = (plength == -1); 1748 1749 if (!isNull) 1750 { 1751 const char *pvalue = pq_getmsgbytes(input_message, plength); 1752 1753 /* 1754 * Rather than copying data around, we just set up a phony 1755 * StringInfo pointing to the correct portion of the message 1756 * buffer. We assume we can scribble on the message buffer so 1757 * as to maintain the convention that StringInfos have a 1758 * trailing null. This is grotty but is a big win when 1759 * dealing with very large parameter strings. 1760 */ 1761 pbuf.data = unconstify(char *, pvalue); 1762 pbuf.maxlen = plength + 1; 1763 pbuf.len = plength; 1764 pbuf.cursor = 0; 1765 1766 csave = pbuf.data[plength]; 1767 pbuf.data[plength] = '\0'; 1768 } 1769 else 1770 { 1771 pbuf.data = NULL; /* keep compiler quiet */ 1772 csave = 0; 1773 } 1774 1775 if (numPFormats > 1) 1776 pformat = pformats[paramno]; 1777 else if (numPFormats > 0) 1778 pformat = pformats[0]; 1779 else 1780 pformat = 0; /* default = text */ 1781 1782 if (pformat == 0) /* text mode */ 1783 { 1784 Oid typinput; 1785 Oid typioparam; 1786 char *pstring; 1787 1788 getTypeInputInfo(ptype, &typinput, &typioparam); 1789 1790 /* 1791 * We have to do encoding conversion before calling the 1792 * typinput routine. 1793 */ 1794 if (isNull) 1795 pstring = NULL; 1796 else 1797 pstring = pg_client_to_server(pbuf.data, plength); 1798 1799 pval = OidInputFunctionCall(typinput, pstring, typioparam, -1); 1800 1801 /* Free result of encoding conversion, if any */ 1802 if (pstring && pstring != pbuf.data) 1803 pfree(pstring); 1804 } 1805 else if (pformat == 1) /* binary mode */ 1806 { 1807 Oid typreceive; 1808 Oid typioparam; 1809 StringInfo bufptr; 1810 1811 /* 1812 * Call the parameter type's binary input converter 1813 */ 1814 getTypeBinaryInputInfo(ptype, &typreceive, &typioparam); 1815 1816 if (isNull) 1817 bufptr = NULL; 1818 else 1819 bufptr = &pbuf; 1820 1821 pval = OidReceiveFunctionCall(typreceive, bufptr, typioparam, -1); 1822 1823 /* Trouble if it didn't eat the whole buffer */ 1824 if (!isNull && pbuf.cursor != pbuf.len) 1825 ereport(ERROR, 1826 (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION), 1827 errmsg("incorrect binary data format in bind parameter %d", 1828 paramno + 1))); 1829 } 1830 else 1831 { 1832 ereport(ERROR, 1833 (errcode(ERRCODE_INVALID_PARAMETER_VALUE), 1834 errmsg("unsupported format code: %d", 1835 pformat))); 1836 pval = 0; /* keep compiler quiet */ 1837 } 1838 1839 /* Restore message buffer contents */ 1840 if (!isNull) 1841 pbuf.data[plength] = csave; 1842 1843 params->params[paramno].value = pval; 1844 params->params[paramno].isnull = isNull; 1845 1846 /* 1847 * We mark the params as CONST. This ensures that any custom plan 1848 * makes full use of the parameter values. 1849 */ 1850 params->params[paramno].pflags = PARAM_FLAG_CONST; 1851 params->params[paramno].ptype = ptype; 1852 } 1853 } 1854 else 1855 params = NULL; 1856 1857 /* Done storing stuff in portal's context */ 1858 MemoryContextSwitchTo(oldContext); 1859 1860 /* Get the result format codes */ 1861 numRFormats = pq_getmsgint(input_message, 2); 1862 if (numRFormats > 0) 1863 { 1864 rformats = (int16 *) palloc(numRFormats * sizeof(int16)); 1865 for (int i = 0; i < numRFormats; i++) 1866 rformats[i] = pq_getmsgint(input_message, 2); 1867 } 1868 1869 pq_getmsgend(input_message); 1870 1871 /* 1872 * Obtain a plan from the CachedPlanSource. Any cruft from (re)planning 1873 * will be generated in MessageContext. The plan refcount will be 1874 * assigned to the Portal, so it will be released at portal destruction. 1875 */ 1876 cplan = GetCachedPlan(psrc, params, false, NULL); 1877 1878 /* 1879 * Now we can define the portal. 1880 * 1881 * DO NOT put any code that could possibly throw an error between the 1882 * above GetCachedPlan call and here. 1883 */ 1884 PortalDefineQuery(portal, 1885 saved_stmt_name, 1886 query_string, 1887 psrc->commandTag, 1888 cplan->stmt_list, 1889 cplan); 1890 1891 /* Done with the snapshot used for parameter I/O and parsing/planning */ 1892 if (snapshot_set) 1893 PopActiveSnapshot(); 1894 1895 /* 1896 * And we're ready to start portal execution. 1897 */ 1898 PortalStart(portal, params, 0, InvalidSnapshot); 1899 1900 /* 1901 * Apply the result format requests to the portal. 1902 */ 1903 PortalSetResultFormat(portal, numRFormats, rformats); 1904 1905 /* 1906 * Send BindComplete. 1907 */ 1908 if (whereToSendOutput == DestRemote) 1909 pq_putemptymessage('2'); 1910 1911 /* 1912 * Emit duration logging if appropriate. 1913 */ 1914 switch (check_log_duration(msec_str, false)) 1915 { 1916 case 1: 1917 ereport(LOG, 1918 (errmsg("duration: %s ms", msec_str), 1919 errhidestmt(true))); 1920 break; 1921 case 2: 1922 ereport(LOG, 1923 (errmsg("duration: %s ms bind %s%s%s: %s", 1924 msec_str, 1925 *stmt_name ? stmt_name : "<unnamed>", 1926 *portal_name ? "/" : "", 1927 *portal_name ? portal_name : "", 1928 psrc->query_string), 1929 errhidestmt(true), 1930 errdetail_params(params))); 1931 break; 1932 } 1933 1934 if (save_log_statement_stats) 1935 ShowUsage("BIND MESSAGE STATISTICS"); 1936 1937 debug_query_string = NULL; 1938 } 1939 1940 /* 1941 * exec_execute_message 1942 * 1943 * Process an "Execute" message for a portal 1944 */ 1945 static void 1946 exec_execute_message(const char *portal_name, long max_rows) 1947 { 1948 CommandDest dest; 1949 DestReceiver *receiver; 1950 Portal portal; 1951 bool completed; 1952 char completionTag[COMPLETION_TAG_BUFSIZE]; 1953 const char *sourceText; 1954 const char *prepStmtName; 1955 ParamListInfo portalParams; 1956 bool save_log_statement_stats = log_statement_stats; 1957 bool is_xact_command; 1958 bool execute_is_fetch; 1959 bool was_logged = false; 1960 char msec_str[32]; 1961 1962 /* Adjust destination to tell printtup.c what to do */ 1963 dest = whereToSendOutput; 1964 if (dest == DestRemote) 1965 dest = DestRemoteExecute; 1966 1967 portal = GetPortalByName(portal_name); 1968 if (!PortalIsValid(portal)) 1969 ereport(ERROR, 1970 (errcode(ERRCODE_UNDEFINED_CURSOR), 1971 errmsg("portal \"%s\" does not exist", portal_name))); 1972 1973 /* 1974 * If the original query was a null string, just return 1975 * EmptyQueryResponse. 1976 */ 1977 if (portal->commandTag == NULL) 1978 { 1979 Assert(portal->stmts == NIL); 1980 NullCommand(dest); 1981 return; 1982 } 1983 1984 /* Does the portal contain a transaction command? */ 1985 is_xact_command = IsTransactionStmtList(portal->stmts); 1986 1987 /* 1988 * We must copy the sourceText and prepStmtName into MessageContext in 1989 * case the portal is destroyed during finish_xact_command. Can avoid the 1990 * copy if it's not an xact command, though. 1991 */ 1992 if (is_xact_command) 1993 { 1994 sourceText = pstrdup(portal->sourceText); 1995 if (portal->prepStmtName) 1996 prepStmtName = pstrdup(portal->prepStmtName); 1997 else 1998 prepStmtName = "<unnamed>"; 1999 2000 /* 2001 * An xact command shouldn't have any parameters, which is a good 2002 * thing because they wouldn't be around after finish_xact_command. 2003 */ 2004 portalParams = NULL; 2005 } 2006 else 2007 { 2008 sourceText = portal->sourceText; 2009 if (portal->prepStmtName) 2010 prepStmtName = portal->prepStmtName; 2011 else 2012 prepStmtName = "<unnamed>"; 2013 portalParams = portal->portalParams; 2014 } 2015 2016 /* 2017 * Report query to various monitoring facilities. 2018 */ 2019 debug_query_string = sourceText; 2020 2021 pgstat_report_activity(STATE_RUNNING, sourceText); 2022 2023 set_ps_display(portal->commandTag, false); 2024 2025 if (save_log_statement_stats) 2026 ResetUsage(); 2027 2028 BeginCommand(portal->commandTag, dest); 2029 2030 /* 2031 * Create dest receiver in MessageContext (we don't want it in transaction 2032 * context, because that may get deleted if portal contains VACUUM). 2033 */ 2034 receiver = CreateDestReceiver(dest); 2035 if (dest == DestRemoteExecute) 2036 SetRemoteDestReceiverParams(receiver, portal); 2037 2038 /* 2039 * Ensure we are in a transaction command (this should normally be the 2040 * case already due to prior BIND). 2041 */ 2042 start_xact_command(); 2043 2044 /* 2045 * If we re-issue an Execute protocol request against an existing portal, 2046 * then we are only fetching more rows rather than completely re-executing 2047 * the query from the start. atStart is never reset for a v3 portal, so we 2048 * are safe to use this check. 2049 */ 2050 execute_is_fetch = !portal->atStart; 2051 2052 /* Log immediately if dictated by log_statement */ 2053 if (check_log_statement(portal->stmts)) 2054 { 2055 ereport(LOG, 2056 (errmsg("%s %s%s%s: %s", 2057 execute_is_fetch ? 2058 _("execute fetch from") : 2059 _("execute"), 2060 prepStmtName, 2061 *portal_name ? "/" : "", 2062 *portal_name ? portal_name : "", 2063 sourceText), 2064 errhidestmt(true), 2065 errdetail_params(portalParams))); 2066 was_logged = true; 2067 } 2068 2069 /* 2070 * If we are in aborted transaction state, the only portals we can 2071 * actually run are those containing COMMIT or ROLLBACK commands. 2072 */ 2073 if (IsAbortedTransactionBlockState() && 2074 !IsTransactionExitStmtList(portal->stmts)) 2075 ereport(ERROR, 2076 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION), 2077 errmsg("current transaction is aborted, " 2078 "commands ignored until end of transaction block"), 2079 errdetail_abort())); 2080 2081 /* Check for cancel signal before we start execution */ 2082 CHECK_FOR_INTERRUPTS(); 2083 2084 /* 2085 * Okay to run the portal. 2086 */ 2087 if (max_rows <= 0) 2088 max_rows = FETCH_ALL; 2089 2090 completed = PortalRun(portal, 2091 max_rows, 2092 true, /* always top level */ 2093 !execute_is_fetch && max_rows == FETCH_ALL, 2094 receiver, 2095 receiver, 2096 completionTag); 2097 2098 receiver->rDestroy(receiver); 2099 2100 if (completed) 2101 { 2102 if (is_xact_command) 2103 { 2104 /* 2105 * If this was a transaction control statement, commit it. We 2106 * will start a new xact command for the next command (if any). 2107 */ 2108 finish_xact_command(); 2109 } 2110 else 2111 { 2112 /* 2113 * We need a CommandCounterIncrement after every query, except 2114 * those that start or end a transaction block. 2115 */ 2116 CommandCounterIncrement(); 2117 2118 /* full command has been executed, reset timeout */ 2119 disable_statement_timeout(); 2120 } 2121 2122 /* Send appropriate CommandComplete to client */ 2123 EndCommand(completionTag, dest); 2124 } 2125 else 2126 { 2127 /* Portal run not complete, so send PortalSuspended */ 2128 if (whereToSendOutput == DestRemote) 2129 pq_putemptymessage('s'); 2130 } 2131 2132 /* 2133 * Emit duration logging if appropriate. 2134 */ 2135 switch (check_log_duration(msec_str, was_logged)) 2136 { 2137 case 1: 2138 ereport(LOG, 2139 (errmsg("duration: %s ms", msec_str), 2140 errhidestmt(true))); 2141 break; 2142 case 2: 2143 ereport(LOG, 2144 (errmsg("duration: %s ms %s %s%s%s: %s", 2145 msec_str, 2146 execute_is_fetch ? 2147 _("execute fetch from") : 2148 _("execute"), 2149 prepStmtName, 2150 *portal_name ? "/" : "", 2151 *portal_name ? portal_name : "", 2152 sourceText), 2153 errhidestmt(true), 2154 errdetail_params(portalParams))); 2155 break; 2156 } 2157 2158 if (save_log_statement_stats) 2159 ShowUsage("EXECUTE MESSAGE STATISTICS"); 2160 2161 debug_query_string = NULL; 2162 } 2163 2164 /* 2165 * check_log_statement 2166 * Determine whether command should be logged because of log_statement 2167 * 2168 * stmt_list can be either raw grammar output or a list of planned 2169 * statements 2170 */ 2171 static bool 2172 check_log_statement(List *stmt_list) 2173 { 2174 ListCell *stmt_item; 2175 2176 if (log_statement == LOGSTMT_NONE) 2177 return false; 2178 if (log_statement == LOGSTMT_ALL) 2179 return true; 2180 2181 /* Else we have to inspect the statement(s) to see whether to log */ 2182 foreach(stmt_item, stmt_list) 2183 { 2184 Node *stmt = (Node *) lfirst(stmt_item); 2185 2186 if (GetCommandLogLevel(stmt) <= log_statement) 2187 return true; 2188 } 2189 2190 return false; 2191 } 2192 2193 /* 2194 * check_log_duration 2195 * Determine whether current command's duration should be logged 2196 * We also check if this statement in this transaction must be logged 2197 * (regardless of its duration). 2198 * 2199 * Returns: 2200 * 0 if no logging is needed 2201 * 1 if just the duration should be logged 2202 * 2 if duration and query details should be logged 2203 * 2204 * If logging is needed, the duration in msec is formatted into msec_str[], 2205 * which must be a 32-byte buffer. 2206 * 2207 * was_logged should be true if caller already logged query details (this 2208 * essentially prevents 2 from being returned). 2209 */ 2210 int 2211 check_log_duration(char *msec_str, bool was_logged) 2212 { 2213 if (log_duration || log_min_duration_statement >= 0 || xact_is_sampled) 2214 { 2215 long secs; 2216 int usecs; 2217 int msecs; 2218 bool exceeded; 2219 2220 TimestampDifference(GetCurrentStatementStartTimestamp(), 2221 GetCurrentTimestamp(), 2222 &secs, &usecs); 2223 msecs = usecs / 1000; 2224 2225 /* 2226 * This odd-looking test for log_min_duration_statement being exceeded 2227 * is designed to avoid integer overflow with very long durations: 2228 * don't compute secs * 1000 until we've verified it will fit in int. 2229 */ 2230 exceeded = (log_min_duration_statement == 0 || 2231 (log_min_duration_statement > 0 && 2232 (secs > log_min_duration_statement / 1000 || 2233 secs * 1000 + msecs >= log_min_duration_statement))); 2234 2235 if (exceeded || log_duration || xact_is_sampled) 2236 { 2237 snprintf(msec_str, 32, "%ld.%03d", 2238 secs * 1000 + msecs, usecs % 1000); 2239 if ((exceeded || xact_is_sampled) && !was_logged) 2240 return 2; 2241 else 2242 return 1; 2243 } 2244 } 2245 2246 return 0; 2247 } 2248 2249 /* 2250 * errdetail_execute 2251 * 2252 * Add an errdetail() line showing the query referenced by an EXECUTE, if any. 2253 * The argument is the raw parsetree list. 2254 */ 2255 static int 2256 errdetail_execute(List *raw_parsetree_list) 2257 { 2258 ListCell *parsetree_item; 2259 2260 foreach(parsetree_item, raw_parsetree_list) 2261 { 2262 RawStmt *parsetree = lfirst_node(RawStmt, parsetree_item); 2263 2264 if (IsA(parsetree->stmt, ExecuteStmt)) 2265 { 2266 ExecuteStmt *stmt = (ExecuteStmt *) parsetree->stmt; 2267 PreparedStatement *pstmt; 2268 2269 pstmt = FetchPreparedStatement(stmt->name, false); 2270 if (pstmt) 2271 { 2272 errdetail("prepare: %s", pstmt->plansource->query_string); 2273 return 0; 2274 } 2275 } 2276 } 2277 2278 return 0; 2279 } 2280 2281 /* 2282 * errdetail_params 2283 * 2284 * Add an errdetail() line showing bind-parameter data, if available. 2285 */ 2286 static int 2287 errdetail_params(ParamListInfo params) 2288 { 2289 /* We mustn't call user-defined I/O functions when in an aborted xact */ 2290 if (params && params->numParams > 0 && !IsAbortedTransactionBlockState()) 2291 { 2292 StringInfoData param_str; 2293 MemoryContext oldcontext; 2294 2295 /* This code doesn't support dynamic param lists */ 2296 Assert(params->paramFetch == NULL); 2297 2298 /* Make sure any trash is generated in MessageContext */ 2299 oldcontext = MemoryContextSwitchTo(MessageContext); 2300 2301 initStringInfo(¶m_str); 2302 2303 for (int paramno = 0; paramno < params->numParams; paramno++) 2304 { 2305 ParamExternData *prm = ¶ms->params[paramno]; 2306 Oid typoutput; 2307 bool typisvarlena; 2308 char *pstring; 2309 char *p; 2310 2311 appendStringInfo(¶m_str, "%s$%d = ", 2312 paramno > 0 ? ", " : "", 2313 paramno + 1); 2314 2315 if (prm->isnull || !OidIsValid(prm->ptype)) 2316 { 2317 appendStringInfoString(¶m_str, "NULL"); 2318 continue; 2319 } 2320 2321 getTypeOutputInfo(prm->ptype, &typoutput, &typisvarlena); 2322 2323 pstring = OidOutputFunctionCall(typoutput, prm->value); 2324 2325 appendStringInfoCharMacro(¶m_str, '\''); 2326 for (p = pstring; *p; p++) 2327 { 2328 if (*p == '\'') /* double single quotes */ 2329 appendStringInfoCharMacro(¶m_str, *p); 2330 appendStringInfoCharMacro(¶m_str, *p); 2331 } 2332 appendStringInfoCharMacro(¶m_str, '\''); 2333 2334 pfree(pstring); 2335 } 2336 2337 errdetail("parameters: %s", param_str.data); 2338 2339 pfree(param_str.data); 2340 2341 MemoryContextSwitchTo(oldcontext); 2342 } 2343 2344 return 0; 2345 } 2346 2347 /* 2348 * errdetail_abort 2349 * 2350 * Add an errdetail() line showing abort reason, if any. 2351 */ 2352 static int 2353 errdetail_abort(void) 2354 { 2355 if (MyProc->recoveryConflictPending) 2356 errdetail("abort reason: recovery conflict"); 2357 2358 return 0; 2359 } 2360 2361 /* 2362 * errdetail_recovery_conflict 2363 * 2364 * Add an errdetail() line showing conflict source. 2365 */ 2366 static int 2367 errdetail_recovery_conflict(void) 2368 { 2369 switch (RecoveryConflictReason) 2370 { 2371 case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN: 2372 errdetail("User was holding shared buffer pin for too long."); 2373 break; 2374 case PROCSIG_RECOVERY_CONFLICT_LOCK: 2375 errdetail("User was holding a relation lock for too long."); 2376 break; 2377 case PROCSIG_RECOVERY_CONFLICT_TABLESPACE: 2378 errdetail("User was or might have been using tablespace that must be dropped."); 2379 break; 2380 case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT: 2381 errdetail("User query might have needed to see row versions that must be removed."); 2382 break; 2383 case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK: 2384 errdetail("User transaction caused buffer deadlock with recovery."); 2385 break; 2386 case PROCSIG_RECOVERY_CONFLICT_DATABASE: 2387 errdetail("User was connected to a database that must be dropped."); 2388 break; 2389 default: 2390 break; 2391 /* no errdetail */ 2392 } 2393 2394 return 0; 2395 } 2396 2397 /* 2398 * exec_describe_statement_message 2399 * 2400 * Process a "Describe" message for a prepared statement 2401 */ 2402 static void 2403 exec_describe_statement_message(const char *stmt_name) 2404 { 2405 CachedPlanSource *psrc; 2406 2407 /* 2408 * Start up a transaction command. (Note that this will normally change 2409 * current memory context.) Nothing happens if we are already in one. 2410 */ 2411 start_xact_command(); 2412 2413 /* Switch back to message context */ 2414 MemoryContextSwitchTo(MessageContext); 2415 2416 /* Find prepared statement */ 2417 if (stmt_name[0] != '\0') 2418 { 2419 PreparedStatement *pstmt; 2420 2421 pstmt = FetchPreparedStatement(stmt_name, true); 2422 psrc = pstmt->plansource; 2423 } 2424 else 2425 { 2426 /* special-case the unnamed statement */ 2427 psrc = unnamed_stmt_psrc; 2428 if (!psrc) 2429 ereport(ERROR, 2430 (errcode(ERRCODE_UNDEFINED_PSTATEMENT), 2431 errmsg("unnamed prepared statement does not exist"))); 2432 } 2433 2434 /* Prepared statements shouldn't have changeable result descs */ 2435 Assert(psrc->fixed_result); 2436 2437 /* 2438 * If we are in aborted transaction state, we can't run 2439 * SendRowDescriptionMessage(), because that needs catalog accesses. 2440 * Hence, refuse to Describe statements that return data. (We shouldn't 2441 * just refuse all Describes, since that might break the ability of some 2442 * clients to issue COMMIT or ROLLBACK commands, if they use code that 2443 * blindly Describes whatever it does.) We can Describe parameters 2444 * without doing anything dangerous, so we don't restrict that. 2445 */ 2446 if (IsAbortedTransactionBlockState() && 2447 psrc->resultDesc) 2448 ereport(ERROR, 2449 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION), 2450 errmsg("current transaction is aborted, " 2451 "commands ignored until end of transaction block"), 2452 errdetail_abort())); 2453 2454 if (whereToSendOutput != DestRemote) 2455 return; /* can't actually do anything... */ 2456 2457 /* 2458 * First describe the parameters... 2459 */ 2460 pq_beginmessage_reuse(&row_description_buf, 't'); /* parameter description 2461 * message type */ 2462 pq_sendint16(&row_description_buf, psrc->num_params); 2463 2464 for (int i = 0; i < psrc->num_params; i++) 2465 { 2466 Oid ptype = psrc->param_types[i]; 2467 2468 pq_sendint32(&row_description_buf, (int) ptype); 2469 } 2470 pq_endmessage_reuse(&row_description_buf); 2471 2472 /* 2473 * Next send RowDescription or NoData to describe the result... 2474 */ 2475 if (psrc->resultDesc) 2476 { 2477 List *tlist; 2478 2479 /* Get the plan's primary targetlist */ 2480 tlist = CachedPlanGetTargetList(psrc, NULL); 2481 2482 SendRowDescriptionMessage(&row_description_buf, 2483 psrc->resultDesc, 2484 tlist, 2485 NULL); 2486 } 2487 else 2488 pq_putemptymessage('n'); /* NoData */ 2489 2490 } 2491 2492 /* 2493 * exec_describe_portal_message 2494 * 2495 * Process a "Describe" message for a portal 2496 */ 2497 static void 2498 exec_describe_portal_message(const char *portal_name) 2499 { 2500 Portal portal; 2501 2502 /* 2503 * Start up a transaction command. (Note that this will normally change 2504 * current memory context.) Nothing happens if we are already in one. 2505 */ 2506 start_xact_command(); 2507 2508 /* Switch back to message context */ 2509 MemoryContextSwitchTo(MessageContext); 2510 2511 portal = GetPortalByName(portal_name); 2512 if (!PortalIsValid(portal)) 2513 ereport(ERROR, 2514 (errcode(ERRCODE_UNDEFINED_CURSOR), 2515 errmsg("portal \"%s\" does not exist", portal_name))); 2516 2517 /* 2518 * If we are in aborted transaction state, we can't run 2519 * SendRowDescriptionMessage(), because that needs catalog accesses. 2520 * Hence, refuse to Describe portals that return data. (We shouldn't just 2521 * refuse all Describes, since that might break the ability of some 2522 * clients to issue COMMIT or ROLLBACK commands, if they use code that 2523 * blindly Describes whatever it does.) 2524 */ 2525 if (IsAbortedTransactionBlockState() && 2526 portal->tupDesc) 2527 ereport(ERROR, 2528 (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION), 2529 errmsg("current transaction is aborted, " 2530 "commands ignored until end of transaction block"), 2531 errdetail_abort())); 2532 2533 if (whereToSendOutput != DestRemote) 2534 return; /* can't actually do anything... */ 2535 2536 if (portal->tupDesc) 2537 SendRowDescriptionMessage(&row_description_buf, 2538 portal->tupDesc, 2539 FetchPortalTargetList(portal), 2540 portal->formats); 2541 else 2542 pq_putemptymessage('n'); /* NoData */ 2543 } 2544 2545 2546 /* 2547 * Convenience routines for starting/committing a single command. 2548 */ 2549 static void 2550 start_xact_command(void) 2551 { 2552 if (!xact_started) 2553 { 2554 StartTransactionCommand(); 2555 2556 xact_started = true; 2557 } 2558 2559 /* 2560 * Start statement timeout if necessary. Note that this'll intentionally 2561 * not reset the clock on an already started timeout, to avoid the timing 2562 * overhead when start_xact_command() is invoked repeatedly, without an 2563 * interceding finish_xact_command() (e.g. parse/bind/execute). If that's 2564 * not desired, the timeout has to be disabled explicitly. 2565 */ 2566 enable_statement_timeout(); 2567 } 2568 2569 static void 2570 finish_xact_command(void) 2571 { 2572 /* cancel active statement timeout after each command */ 2573 disable_statement_timeout(); 2574 2575 if (xact_started) 2576 { 2577 CommitTransactionCommand(); 2578 2579 #ifdef MEMORY_CONTEXT_CHECKING 2580 /* Check all memory contexts that weren't freed during commit */ 2581 /* (those that were, were checked before being deleted) */ 2582 MemoryContextCheck(TopMemoryContext); 2583 #endif 2584 2585 #ifdef SHOW_MEMORY_STATS 2586 /* Print mem stats after each commit for leak tracking */ 2587 MemoryContextStats(TopMemoryContext); 2588 #endif 2589 2590 xact_started = false; 2591 } 2592 } 2593 2594 2595 /* 2596 * Convenience routines for checking whether a statement is one of the 2597 * ones that we allow in transaction-aborted state. 2598 */ 2599 2600 /* Test a bare parsetree */ 2601 static bool 2602 IsTransactionExitStmt(Node *parsetree) 2603 { 2604 if (parsetree && IsA(parsetree, TransactionStmt)) 2605 { 2606 TransactionStmt *stmt = (TransactionStmt *) parsetree; 2607 2608 if (stmt->kind == TRANS_STMT_COMMIT || 2609 stmt->kind == TRANS_STMT_PREPARE || 2610 stmt->kind == TRANS_STMT_ROLLBACK || 2611 stmt->kind == TRANS_STMT_ROLLBACK_TO) 2612 return true; 2613 } 2614 return false; 2615 } 2616 2617 /* Test a list that contains PlannedStmt nodes */ 2618 static bool 2619 IsTransactionExitStmtList(List *pstmts) 2620 { 2621 if (list_length(pstmts) == 1) 2622 { 2623 PlannedStmt *pstmt = linitial_node(PlannedStmt, pstmts); 2624 2625 if (pstmt->commandType == CMD_UTILITY && 2626 IsTransactionExitStmt(pstmt->utilityStmt)) 2627 return true; 2628 } 2629 return false; 2630 } 2631 2632 /* Test a list that contains PlannedStmt nodes */ 2633 static bool 2634 IsTransactionStmtList(List *pstmts) 2635 { 2636 if (list_length(pstmts) == 1) 2637 { 2638 PlannedStmt *pstmt = linitial_node(PlannedStmt, pstmts); 2639 2640 if (pstmt->commandType == CMD_UTILITY && 2641 IsA(pstmt->utilityStmt, TransactionStmt)) 2642 return true; 2643 } 2644 return false; 2645 } 2646 2647 /* Release any existing unnamed prepared statement */ 2648 static void 2649 drop_unnamed_stmt(void) 2650 { 2651 /* paranoia to avoid a dangling pointer in case of error */ 2652 if (unnamed_stmt_psrc) 2653 { 2654 CachedPlanSource *psrc = unnamed_stmt_psrc; 2655 2656 unnamed_stmt_psrc = NULL; 2657 DropCachedPlan(psrc); 2658 } 2659 } 2660 2661 2662 /* -------------------------------- 2663 * signal handler routines used in PostgresMain() 2664 * -------------------------------- 2665 */ 2666 2667 /* 2668 * quickdie() occurs when signalled SIGQUIT by the postmaster. 2669 * 2670 * Some backend has bought the farm, 2671 * so we need to stop what we're doing and exit. 2672 */ 2673 void 2674 quickdie(SIGNAL_ARGS) 2675 { 2676 sigaddset(&BlockSig, SIGQUIT); /* prevent nested calls */ 2677 PG_SETMASK(&BlockSig); 2678 2679 /* 2680 * Prevent interrupts while exiting; though we just blocked signals that 2681 * would queue new interrupts, one may have been pending. We don't want a 2682 * quickdie() downgraded to a mere query cancel. 2683 */ 2684 HOLD_INTERRUPTS(); 2685 2686 /* 2687 * If we're aborting out of client auth, don't risk trying to send 2688 * anything to the client; we will likely violate the protocol, not to 2689 * mention that we may have interrupted the guts of OpenSSL or some 2690 * authentication library. 2691 */ 2692 if (ClientAuthInProgress && whereToSendOutput == DestRemote) 2693 whereToSendOutput = DestNone; 2694 2695 /* 2696 * Notify the client before exiting, to give a clue on what happened. 2697 * 2698 * It's dubious to call ereport() from a signal handler. It is certainly 2699 * not async-signal safe. But it seems better to try, than to disconnect 2700 * abruptly and leave the client wondering what happened. It's remotely 2701 * possible that we crash or hang while trying to send the message, but 2702 * receiving a SIGQUIT is a sign that something has already gone badly 2703 * wrong, so there's not much to lose. Assuming the postmaster is still 2704 * running, it will SIGKILL us soon if we get stuck for some reason. 2705 * 2706 * Ideally this should be ereport(FATAL), but then we'd not get control 2707 * back... 2708 */ 2709 ereport(WARNING, 2710 (errcode(ERRCODE_CRASH_SHUTDOWN), 2711 errmsg("terminating connection because of crash of another server process"), 2712 errdetail("The postmaster has commanded this server process to roll back" 2713 " the current transaction and exit, because another" 2714 " server process exited abnormally and possibly corrupted" 2715 " shared memory."), 2716 errhint("In a moment you should be able to reconnect to the" 2717 " database and repeat your command."))); 2718 2719 /* 2720 * We DO NOT want to run proc_exit() or atexit() callbacks -- we're here 2721 * because shared memory may be corrupted, so we don't want to try to 2722 * clean up our transaction. Just nail the windows shut and get out of 2723 * town. The callbacks wouldn't be safe to run from a signal handler, 2724 * anyway. 2725 * 2726 * Note we do _exit(2) not _exit(0). This is to force the postmaster into 2727 * a system reset cycle if someone sends a manual SIGQUIT to a random 2728 * backend. This is necessary precisely because we don't clean up our 2729 * shared memory state. (The "dead man switch" mechanism in pmsignal.c 2730 * should ensure the postmaster sees this as a crash, too, but no harm in 2731 * being doubly sure.) 2732 */ 2733 _exit(2); 2734 } 2735 2736 /* 2737 * Shutdown signal from postmaster: abort transaction and exit 2738 * at soonest convenient time 2739 */ 2740 void 2741 die(SIGNAL_ARGS) 2742 { 2743 int save_errno = errno; 2744 2745 /* Don't joggle the elbow of proc_exit */ 2746 if (!proc_exit_inprogress) 2747 { 2748 InterruptPending = true; 2749 ProcDiePending = true; 2750 } 2751 2752 /* If we're still here, waken anything waiting on the process latch */ 2753 SetLatch(MyLatch); 2754 2755 /* 2756 * If we're in single user mode, we want to quit immediately - we can't 2757 * rely on latches as they wouldn't work when stdin/stdout is a file. 2758 * Rather ugly, but it's unlikely to be worthwhile to invest much more 2759 * effort just for the benefit of single user mode. 2760 */ 2761 if (DoingCommandRead && whereToSendOutput != DestRemote) 2762 ProcessInterrupts(); 2763 2764 errno = save_errno; 2765 } 2766 2767 /* 2768 * Query-cancel signal from postmaster: abort current transaction 2769 * at soonest convenient time 2770 */ 2771 void 2772 StatementCancelHandler(SIGNAL_ARGS) 2773 { 2774 int save_errno = errno; 2775 2776 /* 2777 * Don't joggle the elbow of proc_exit 2778 */ 2779 if (!proc_exit_inprogress) 2780 { 2781 InterruptPending = true; 2782 QueryCancelPending = true; 2783 } 2784 2785 /* If we're still here, waken anything waiting on the process latch */ 2786 SetLatch(MyLatch); 2787 2788 errno = save_errno; 2789 } 2790 2791 /* signal handler for floating point exception */ 2792 void 2793 FloatExceptionHandler(SIGNAL_ARGS) 2794 { 2795 /* We're not returning, so no need to save errno */ 2796 ereport(ERROR, 2797 (errcode(ERRCODE_FLOATING_POINT_EXCEPTION), 2798 errmsg("floating-point exception"), 2799 errdetail("An invalid floating-point operation was signaled. " 2800 "This probably means an out-of-range result or an " 2801 "invalid operation, such as division by zero."))); 2802 } 2803 2804 /* 2805 * SIGHUP: set flag to re-read config file at next convenient time. 2806 * 2807 * Sets the ConfigReloadPending flag, which should be checked at convenient 2808 * places inside main loops. (Better than doing the reading in the signal 2809 * handler, ey?) 2810 */ 2811 void 2812 PostgresSigHupHandler(SIGNAL_ARGS) 2813 { 2814 int save_errno = errno; 2815 2816 ConfigReloadPending = true; 2817 SetLatch(MyLatch); 2818 2819 errno = save_errno; 2820 } 2821 2822 /* 2823 * RecoveryConflictInterrupt: out-of-line portion of recovery conflict 2824 * handling following receipt of SIGUSR1. Designed to be similar to die() 2825 * and StatementCancelHandler(). Called only by a normal user backend 2826 * that begins a transaction during recovery. 2827 */ 2828 void 2829 RecoveryConflictInterrupt(ProcSignalReason reason) 2830 { 2831 int save_errno = errno; 2832 2833 /* 2834 * Don't joggle the elbow of proc_exit 2835 */ 2836 if (!proc_exit_inprogress) 2837 { 2838 RecoveryConflictReason = reason; 2839 switch (reason) 2840 { 2841 case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK: 2842 2843 /* 2844 * If we aren't waiting for a lock we can never deadlock. 2845 */ 2846 if (!IsWaitingForLock()) 2847 return; 2848 2849 /* Intentional fall through to check wait for pin */ 2850 /* FALLTHROUGH */ 2851 2852 case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN: 2853 2854 /* 2855 * If PROCSIG_RECOVERY_CONFLICT_BUFFERPIN is requested but we 2856 * aren't blocking the Startup process there is nothing more 2857 * to do. 2858 * 2859 * When PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK is 2860 * requested, if we're waiting for locks and the startup 2861 * process is not waiting for buffer pin (i.e., also waiting 2862 * for locks), we set the flag so that ProcSleep() will check 2863 * for deadlocks. 2864 */ 2865 if (!HoldingBufferPinThatDelaysRecovery()) 2866 { 2867 if (reason == PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK && 2868 GetStartupBufferPinWaitBufId() < 0) 2869 CheckDeadLockAlert(); 2870 return; 2871 } 2872 2873 MyProc->recoveryConflictPending = true; 2874 2875 /* Intentional fall through to error handling */ 2876 /* FALLTHROUGH */ 2877 2878 case PROCSIG_RECOVERY_CONFLICT_LOCK: 2879 case PROCSIG_RECOVERY_CONFLICT_TABLESPACE: 2880 case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT: 2881 2882 /* 2883 * If we aren't in a transaction any longer then ignore. 2884 */ 2885 if (!IsTransactionOrTransactionBlock()) 2886 return; 2887 2888 /* 2889 * If we can abort just the current subtransaction then we are 2890 * OK to throw an ERROR to resolve the conflict. Otherwise 2891 * drop through to the FATAL case. 2892 * 2893 * XXX other times that we can throw just an ERROR *may* be 2894 * PROCSIG_RECOVERY_CONFLICT_LOCK if no locks are held in 2895 * parent transactions 2896 * 2897 * PROCSIG_RECOVERY_CONFLICT_SNAPSHOT if no snapshots are held 2898 * by parent transactions and the transaction is not 2899 * transaction-snapshot mode 2900 * 2901 * PROCSIG_RECOVERY_CONFLICT_TABLESPACE if no temp files or 2902 * cursors open in parent transactions 2903 */ 2904 if (!IsSubTransaction()) 2905 { 2906 /* 2907 * If we already aborted then we no longer need to cancel. 2908 * We do this here since we do not wish to ignore aborted 2909 * subtransactions, which must cause FATAL, currently. 2910 */ 2911 if (IsAbortedTransactionBlockState()) 2912 return; 2913 2914 RecoveryConflictPending = true; 2915 QueryCancelPending = true; 2916 InterruptPending = true; 2917 break; 2918 } 2919 2920 /* Intentional fall through to session cancel */ 2921 /* FALLTHROUGH */ 2922 2923 case PROCSIG_RECOVERY_CONFLICT_DATABASE: 2924 RecoveryConflictPending = true; 2925 ProcDiePending = true; 2926 InterruptPending = true; 2927 break; 2928 2929 default: 2930 elog(FATAL, "unrecognized conflict mode: %d", 2931 (int) reason); 2932 } 2933 2934 Assert(RecoveryConflictPending && (QueryCancelPending || ProcDiePending)); 2935 2936 /* 2937 * All conflicts apart from database cause dynamic errors where the 2938 * command or transaction can be retried at a later point with some 2939 * potential for success. No need to reset this, since non-retryable 2940 * conflict errors are currently FATAL. 2941 */ 2942 if (reason == PROCSIG_RECOVERY_CONFLICT_DATABASE) 2943 RecoveryConflictRetryable = false; 2944 } 2945 2946 /* 2947 * Set the process latch. This function essentially emulates signal 2948 * handlers like die() and StatementCancelHandler() and it seems prudent 2949 * to behave similarly as they do. 2950 */ 2951 SetLatch(MyLatch); 2952 2953 errno = save_errno; 2954 } 2955 2956 /* 2957 * ProcessInterrupts: out-of-line portion of CHECK_FOR_INTERRUPTS() macro 2958 * 2959 * If an interrupt condition is pending, and it's safe to service it, 2960 * then clear the flag and accept the interrupt. Called only when 2961 * InterruptPending is true. 2962 * 2963 * Note: if INTERRUPTS_CAN_BE_PROCESSED() is true, then ProcessInterrupts 2964 * is guaranteed to clear the InterruptPending flag before returning. 2965 * (This is not the same as guaranteeing that it's still clear when we 2966 * return; another interrupt could have arrived. But we promise that 2967 * any pre-existing one will have been serviced.) 2968 */ 2969 void 2970 ProcessInterrupts(void) 2971 { 2972 /* OK to accept any interrupts now? */ 2973 if (InterruptHoldoffCount != 0 || CritSectionCount != 0) 2974 return; 2975 InterruptPending = false; 2976 2977 if (ProcDiePending) 2978 { 2979 ProcDiePending = false; 2980 QueryCancelPending = false; /* ProcDie trumps QueryCancel */ 2981 LockErrorCleanup(); 2982 /* As in quickdie, don't risk sending to client during auth */ 2983 if (ClientAuthInProgress && whereToSendOutput == DestRemote) 2984 whereToSendOutput = DestNone; 2985 if (ClientAuthInProgress) 2986 ereport(FATAL, 2987 (errcode(ERRCODE_QUERY_CANCELED), 2988 errmsg("canceling authentication due to timeout"))); 2989 else if (IsAutoVacuumWorkerProcess()) 2990 ereport(FATAL, 2991 (errcode(ERRCODE_ADMIN_SHUTDOWN), 2992 errmsg("terminating autovacuum process due to administrator command"))); 2993 else if (IsLogicalWorker()) 2994 ereport(FATAL, 2995 (errcode(ERRCODE_ADMIN_SHUTDOWN), 2996 errmsg("terminating logical replication worker due to administrator command"))); 2997 else if (IsLogicalLauncher()) 2998 { 2999 ereport(DEBUG1, 3000 (errmsg("logical replication launcher shutting down"))); 3001 3002 /* 3003 * The logical replication launcher can be stopped at any time. 3004 * Use exit status 1 so the background worker is restarted. 3005 */ 3006 proc_exit(1); 3007 } 3008 else if (RecoveryConflictPending && RecoveryConflictRetryable) 3009 { 3010 pgstat_report_recovery_conflict(RecoveryConflictReason); 3011 ereport(FATAL, 3012 (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), 3013 errmsg("terminating connection due to conflict with recovery"), 3014 errdetail_recovery_conflict())); 3015 } 3016 else if (RecoveryConflictPending) 3017 { 3018 /* Currently there is only one non-retryable recovery conflict */ 3019 Assert(RecoveryConflictReason == PROCSIG_RECOVERY_CONFLICT_DATABASE); 3020 pgstat_report_recovery_conflict(RecoveryConflictReason); 3021 ereport(FATAL, 3022 (errcode(ERRCODE_DATABASE_DROPPED), 3023 errmsg("terminating connection due to conflict with recovery"), 3024 errdetail_recovery_conflict())); 3025 } 3026 else 3027 ereport(FATAL, 3028 (errcode(ERRCODE_ADMIN_SHUTDOWN), 3029 errmsg("terminating connection due to administrator command"))); 3030 } 3031 if (ClientConnectionLost) 3032 { 3033 QueryCancelPending = false; /* lost connection trumps QueryCancel */ 3034 LockErrorCleanup(); 3035 /* don't send to client, we already know the connection to be dead. */ 3036 whereToSendOutput = DestNone; 3037 ereport(FATAL, 3038 (errcode(ERRCODE_CONNECTION_FAILURE), 3039 errmsg("connection to client lost"))); 3040 } 3041 3042 /* 3043 * If a recovery conflict happens while we are waiting for input from the 3044 * client, the client is presumably just sitting idle in a transaction, 3045 * preventing recovery from making progress. Terminate the connection to 3046 * dislodge it. 3047 */ 3048 if (RecoveryConflictPending && DoingCommandRead) 3049 { 3050 QueryCancelPending = false; /* this trumps QueryCancel */ 3051 RecoveryConflictPending = false; 3052 LockErrorCleanup(); 3053 pgstat_report_recovery_conflict(RecoveryConflictReason); 3054 ereport(FATAL, 3055 (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), 3056 errmsg("terminating connection due to conflict with recovery"), 3057 errdetail_recovery_conflict(), 3058 errhint("In a moment you should be able to reconnect to the" 3059 " database and repeat your command."))); 3060 } 3061 3062 /* 3063 * Don't allow query cancel interrupts while reading input from the 3064 * client, because we might lose sync in the FE/BE protocol. (Die 3065 * interrupts are OK, because we won't read any further messages from the 3066 * client in that case.) 3067 */ 3068 if (QueryCancelPending && QueryCancelHoldoffCount != 0) 3069 { 3070 /* 3071 * Re-arm InterruptPending so that we process the cancel request as 3072 * soon as we're done reading the message. (XXX this is seriously 3073 * ugly: it complicates INTERRUPTS_CAN_BE_PROCESSED(), and it means we 3074 * can't use that macro directly as the initial test in this function, 3075 * meaning that this code also creates opportunities for other bugs to 3076 * appear.) 3077 */ 3078 InterruptPending = true; 3079 } 3080 else if (QueryCancelPending) 3081 { 3082 bool lock_timeout_occurred; 3083 bool stmt_timeout_occurred; 3084 3085 QueryCancelPending = false; 3086 3087 /* 3088 * If LOCK_TIMEOUT and STATEMENT_TIMEOUT indicators are both set, we 3089 * need to clear both, so always fetch both. 3090 */ 3091 lock_timeout_occurred = get_timeout_indicator(LOCK_TIMEOUT, true); 3092 stmt_timeout_occurred = get_timeout_indicator(STATEMENT_TIMEOUT, true); 3093 3094 /* 3095 * If both were set, we want to report whichever timeout completed 3096 * earlier; this ensures consistent behavior if the machine is slow 3097 * enough that the second timeout triggers before we get here. A tie 3098 * is arbitrarily broken in favor of reporting a lock timeout. 3099 */ 3100 if (lock_timeout_occurred && stmt_timeout_occurred && 3101 get_timeout_finish_time(STATEMENT_TIMEOUT) < get_timeout_finish_time(LOCK_TIMEOUT)) 3102 lock_timeout_occurred = false; /* report stmt timeout */ 3103 3104 if (lock_timeout_occurred) 3105 { 3106 LockErrorCleanup(); 3107 ereport(ERROR, 3108 (errcode(ERRCODE_LOCK_NOT_AVAILABLE), 3109 errmsg("canceling statement due to lock timeout"))); 3110 } 3111 if (stmt_timeout_occurred) 3112 { 3113 LockErrorCleanup(); 3114 ereport(ERROR, 3115 (errcode(ERRCODE_QUERY_CANCELED), 3116 errmsg("canceling statement due to statement timeout"))); 3117 } 3118 if (IsAutoVacuumWorkerProcess()) 3119 { 3120 LockErrorCleanup(); 3121 ereport(ERROR, 3122 (errcode(ERRCODE_QUERY_CANCELED), 3123 errmsg("canceling autovacuum task"))); 3124 } 3125 if (RecoveryConflictPending) 3126 { 3127 RecoveryConflictPending = false; 3128 LockErrorCleanup(); 3129 pgstat_report_recovery_conflict(RecoveryConflictReason); 3130 ereport(ERROR, 3131 (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), 3132 errmsg("canceling statement due to conflict with recovery"), 3133 errdetail_recovery_conflict())); 3134 } 3135 3136 /* 3137 * If we are reading a command from the client, just ignore the cancel 3138 * request --- sending an extra error message won't accomplish 3139 * anything. Otherwise, go ahead and throw the error. 3140 */ 3141 if (!DoingCommandRead) 3142 { 3143 LockErrorCleanup(); 3144 ereport(ERROR, 3145 (errcode(ERRCODE_QUERY_CANCELED), 3146 errmsg("canceling statement due to user request"))); 3147 } 3148 } 3149 3150 if (IdleInTransactionSessionTimeoutPending) 3151 { 3152 /* Has the timeout setting changed since last we looked? */ 3153 if (IdleInTransactionSessionTimeout > 0) 3154 ereport(FATAL, 3155 (errcode(ERRCODE_IDLE_IN_TRANSACTION_SESSION_TIMEOUT), 3156 errmsg("terminating connection due to idle-in-transaction timeout"))); 3157 else 3158 IdleInTransactionSessionTimeoutPending = false; 3159 3160 } 3161 3162 if (ParallelMessagePending) 3163 HandleParallelMessages(); 3164 } 3165 3166 3167 /* 3168 * IA64-specific code to fetch the AR.BSP register for stack depth checks. 3169 * 3170 * We currently support gcc, icc, and HP-UX's native compiler here. 3171 * 3172 * Note: while icc accepts gcc asm blocks on x86[_64], this is not true on 3173 * ia64 (at least not in icc versions before 12.x). So we have to carry a 3174 * separate implementation for it. 3175 */ 3176 #if defined(__ia64__) || defined(__ia64) 3177 3178 #if defined(__hpux) && !defined(__GNUC__) && !defined(__INTEL_COMPILER) 3179 /* Assume it's HP-UX native compiler */ 3180 #include <ia64/sys/inline.h> 3181 #define ia64_get_bsp() ((char *) (_Asm_mov_from_ar(_AREG_BSP, _NO_FENCE))) 3182 #elif defined(__INTEL_COMPILER) 3183 /* icc */ 3184 #include <asm/ia64regs.h> 3185 #define ia64_get_bsp() ((char *) __getReg(_IA64_REG_AR_BSP)) 3186 #else 3187 /* gcc */ 3188 static __inline__ char * 3189 ia64_get_bsp(void) 3190 { 3191 char *ret; 3192 3193 /* the ;; is a "stop", seems to be required before fetching BSP */ 3194 __asm__ __volatile__( 3195 ";;\n" 3196 " mov %0=ar.bsp \n" 3197 : "=r"(ret)); 3198 3199 return ret; 3200 } 3201 #endif 3202 #endif /* IA64 */ 3203 3204 3205 /* 3206 * set_stack_base: set up reference point for stack depth checking 3207 * 3208 * Returns the old reference point, if any. 3209 */ 3210 pg_stack_base_t 3211 set_stack_base(void) 3212 { 3213 char stack_base; 3214 pg_stack_base_t old; 3215 3216 #if defined(__ia64__) || defined(__ia64) 3217 old.stack_base_ptr = stack_base_ptr; 3218 old.register_stack_base_ptr = register_stack_base_ptr; 3219 #else 3220 old = stack_base_ptr; 3221 #endif 3222 3223 /* Set up reference point for stack depth checking */ 3224 stack_base_ptr = &stack_base; 3225 #if defined(__ia64__) || defined(__ia64) 3226 register_stack_base_ptr = ia64_get_bsp(); 3227 #endif 3228 3229 return old; 3230 } 3231 3232 /* 3233 * restore_stack_base: restore reference point for stack depth checking 3234 * 3235 * This can be used after set_stack_base() to restore the old value. This 3236 * is currently only used in PL/Java. When PL/Java calls a backend function 3237 * from different thread, the thread's stack is at a different location than 3238 * the main thread's stack, so it sets the base pointer before the call, and 3239 * restores it afterwards. 3240 */ 3241 void 3242 restore_stack_base(pg_stack_base_t base) 3243 { 3244 #if defined(__ia64__) || defined(__ia64) 3245 stack_base_ptr = base.stack_base_ptr; 3246 register_stack_base_ptr = base.register_stack_base_ptr; 3247 #else 3248 stack_base_ptr = base; 3249 #endif 3250 } 3251 3252 /* 3253 * check_stack_depth/stack_is_too_deep: check for excessively deep recursion 3254 * 3255 * This should be called someplace in any recursive routine that might possibly 3256 * recurse deep enough to overflow the stack. Most Unixen treat stack 3257 * overflow as an unrecoverable SIGSEGV, so we want to error out ourselves 3258 * before hitting the hardware limit. 3259 * 3260 * check_stack_depth() just throws an error summarily. stack_is_too_deep() 3261 * can be used by code that wants to handle the error condition itself. 3262 */ 3263 void 3264 check_stack_depth(void) 3265 { 3266 if (stack_is_too_deep()) 3267 { 3268 ereport(ERROR, 3269 (errcode(ERRCODE_STATEMENT_TOO_COMPLEX), 3270 errmsg("stack depth limit exceeded"), 3271 errhint("Increase the configuration parameter \"max_stack_depth\" (currently %dkB), " 3272 "after ensuring the platform's stack depth limit is adequate.", 3273 max_stack_depth))); 3274 } 3275 } 3276 3277 bool 3278 stack_is_too_deep(void) 3279 { 3280 char stack_top_loc; 3281 long stack_depth; 3282 3283 /* 3284 * Compute distance from reference point to my local variables 3285 */ 3286 stack_depth = (long) (stack_base_ptr - &stack_top_loc); 3287 3288 /* 3289 * Take abs value, since stacks grow up on some machines, down on others 3290 */ 3291 if (stack_depth < 0) 3292 stack_depth = -stack_depth; 3293 3294 /* 3295 * Trouble? 3296 * 3297 * The test on stack_base_ptr prevents us from erroring out if called 3298 * during process setup or in a non-backend process. Logically it should 3299 * be done first, but putting it here avoids wasting cycles during normal 3300 * cases. 3301 */ 3302 if (stack_depth > max_stack_depth_bytes && 3303 stack_base_ptr != NULL) 3304 return true; 3305 3306 /* 3307 * On IA64 there is a separate "register" stack that requires its own 3308 * independent check. For this, we have to measure the change in the 3309 * "BSP" pointer from PostgresMain to here. Logic is just as above, 3310 * except that we know IA64's register stack grows up. 3311 * 3312 * Note we assume that the same max_stack_depth applies to both stacks. 3313 */ 3314 #if defined(__ia64__) || defined(__ia64) 3315 stack_depth = (long) (ia64_get_bsp() - register_stack_base_ptr); 3316 3317 if (stack_depth > max_stack_depth_bytes && 3318 register_stack_base_ptr != NULL) 3319 return true; 3320 #endif /* IA64 */ 3321 3322 return false; 3323 } 3324 3325 /* GUC check hook for max_stack_depth */ 3326 bool 3327 check_max_stack_depth(int *newval, void **extra, GucSource source) 3328 { 3329 long newval_bytes = *newval * 1024L; 3330 long stack_rlimit = get_stack_depth_rlimit(); 3331 3332 if (stack_rlimit > 0 && newval_bytes > stack_rlimit - STACK_DEPTH_SLOP) 3333 { 3334 GUC_check_errdetail("\"max_stack_depth\" must not exceed %ldkB.", 3335 (stack_rlimit - STACK_DEPTH_SLOP) / 1024L); 3336 GUC_check_errhint("Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent."); 3337 return false; 3338 } 3339 return true; 3340 } 3341 3342 /* GUC assign hook for max_stack_depth */ 3343 void 3344 assign_max_stack_depth(int newval, void *extra) 3345 { 3346 long newval_bytes = newval * 1024L; 3347 3348 max_stack_depth_bytes = newval_bytes; 3349 } 3350 3351 3352 /* 3353 * set_debug_options --- apply "-d N" command line option 3354 * 3355 * -d is not quite the same as setting log_min_messages because it enables 3356 * other output options. 3357 */ 3358 void 3359 set_debug_options(int debug_flag, GucContext context, GucSource source) 3360 { 3361 if (debug_flag > 0) 3362 { 3363 char debugstr[64]; 3364 3365 sprintf(debugstr, "debug%d", debug_flag); 3366 SetConfigOption("log_min_messages", debugstr, context, source); 3367 } 3368 else 3369 SetConfigOption("log_min_messages", "notice", context, source); 3370 3371 if (debug_flag >= 1 && context == PGC_POSTMASTER) 3372 { 3373 SetConfigOption("log_connections", "true", context, source); 3374 SetConfigOption("log_disconnections", "true", context, source); 3375 } 3376 if (debug_flag >= 2) 3377 SetConfigOption("log_statement", "all", context, source); 3378 if (debug_flag >= 3) 3379 SetConfigOption("debug_print_parse", "true", context, source); 3380 if (debug_flag >= 4) 3381 SetConfigOption("debug_print_plan", "true", context, source); 3382 if (debug_flag >= 5) 3383 SetConfigOption("debug_print_rewritten", "true", context, source); 3384 } 3385 3386 3387 bool 3388 set_plan_disabling_options(const char *arg, GucContext context, GucSource source) 3389 { 3390 const char *tmp = NULL; 3391 3392 switch (arg[0]) 3393 { 3394 case 's': /* seqscan */ 3395 tmp = "enable_seqscan"; 3396 break; 3397 case 'i': /* indexscan */ 3398 tmp = "enable_indexscan"; 3399 break; 3400 case 'o': /* indexonlyscan */ 3401 tmp = "enable_indexonlyscan"; 3402 break; 3403 case 'b': /* bitmapscan */ 3404 tmp = "enable_bitmapscan"; 3405 break; 3406 case 't': /* tidscan */ 3407 tmp = "enable_tidscan"; 3408 break; 3409 case 'n': /* nestloop */ 3410 tmp = "enable_nestloop"; 3411 break; 3412 case 'm': /* mergejoin */ 3413 tmp = "enable_mergejoin"; 3414 break; 3415 case 'h': /* hashjoin */ 3416 tmp = "enable_hashjoin"; 3417 break; 3418 } 3419 if (tmp) 3420 { 3421 SetConfigOption(tmp, "false", context, source); 3422 return true; 3423 } 3424 else 3425 return false; 3426 } 3427 3428 3429 const char * 3430 get_stats_option_name(const char *arg) 3431 { 3432 switch (arg[0]) 3433 { 3434 case 'p': 3435 if (optarg[1] == 'a') /* "parser" */ 3436 return "log_parser_stats"; 3437 else if (optarg[1] == 'l') /* "planner" */ 3438 return "log_planner_stats"; 3439 break; 3440 3441 case 'e': /* "executor" */ 3442 return "log_executor_stats"; 3443 break; 3444 } 3445 3446 return NULL; 3447 } 3448 3449 3450 /* ---------------------------------------------------------------- 3451 * process_postgres_switches 3452 * Parse command line arguments for PostgresMain 3453 * 3454 * This is called twice, once for the "secure" options coming from the 3455 * postmaster or command line, and once for the "insecure" options coming 3456 * from the client's startup packet. The latter have the same syntax but 3457 * may be restricted in what they can do. 3458 * 3459 * argv[0] is ignored in either case (it's assumed to be the program name). 3460 * 3461 * ctx is PGC_POSTMASTER for secure options, PGC_BACKEND for insecure options 3462 * coming from the client, or PGC_SU_BACKEND for insecure options coming from 3463 * a superuser client. 3464 * 3465 * If a database name is present in the command line arguments, it's 3466 * returned into *dbname (this is allowed only if *dbname is initially NULL). 3467 * ---------------------------------------------------------------- 3468 */ 3469 void 3470 process_postgres_switches(int argc, char *argv[], GucContext ctx, 3471 const char **dbname) 3472 { 3473 bool secure = (ctx == PGC_POSTMASTER); 3474 int errs = 0; 3475 GucSource gucsource; 3476 int flag; 3477 3478 if (secure) 3479 { 3480 gucsource = PGC_S_ARGV; /* switches came from command line */ 3481 3482 /* Ignore the initial --single argument, if present */ 3483 if (argc > 1 && strcmp(argv[1], "--single") == 0) 3484 { 3485 argv++; 3486 argc--; 3487 } 3488 } 3489 else 3490 { 3491 gucsource = PGC_S_CLIENT; /* switches came from client */ 3492 } 3493 3494 #ifdef HAVE_INT_OPTERR 3495 3496 /* 3497 * Turn this off because it's either printed to stderr and not the log 3498 * where we'd want it, or argv[0] is now "--single", which would make for 3499 * a weird error message. We print our own error message below. 3500 */ 3501 opterr = 0; 3502 #endif 3503 3504 /* 3505 * Parse command-line options. CAUTION: keep this in sync with 3506 * postmaster/postmaster.c (the option sets should not conflict) and with 3507 * the common help() function in main/main.c. 3508 */ 3509 while ((flag = getopt(argc, argv, "B:bc:C:D:d:EeFf:h:ijk:lN:nOo:Pp:r:S:sTt:v:W:-:")) != -1) 3510 { 3511 switch (flag) 3512 { 3513 case 'B': 3514 SetConfigOption("shared_buffers", optarg, ctx, gucsource); 3515 break; 3516 3517 case 'b': 3518 /* Undocumented flag used for binary upgrades */ 3519 if (secure) 3520 IsBinaryUpgrade = true; 3521 break; 3522 3523 case 'C': 3524 /* ignored for consistency with the postmaster */ 3525 break; 3526 3527 case 'D': 3528 if (secure) 3529 userDoption = strdup(optarg); 3530 break; 3531 3532 case 'd': 3533 set_debug_options(atoi(optarg), ctx, gucsource); 3534 break; 3535 3536 case 'E': 3537 if (secure) 3538 EchoQuery = true; 3539 break; 3540 3541 case 'e': 3542 SetConfigOption("datestyle", "euro", ctx, gucsource); 3543 break; 3544 3545 case 'F': 3546 SetConfigOption("fsync", "false", ctx, gucsource); 3547 break; 3548 3549 case 'f': 3550 if (!set_plan_disabling_options(optarg, ctx, gucsource)) 3551 errs++; 3552 break; 3553 3554 case 'h': 3555 SetConfigOption("listen_addresses", optarg, ctx, gucsource); 3556 break; 3557 3558 case 'i': 3559 SetConfigOption("listen_addresses", "*", ctx, gucsource); 3560 break; 3561 3562 case 'j': 3563 if (secure) 3564 UseSemiNewlineNewline = true; 3565 break; 3566 3567 case 'k': 3568 SetConfigOption("unix_socket_directories", optarg, ctx, gucsource); 3569 break; 3570 3571 case 'l': 3572 SetConfigOption("ssl", "true", ctx, gucsource); 3573 break; 3574 3575 case 'N': 3576 SetConfigOption("max_connections", optarg, ctx, gucsource); 3577 break; 3578 3579 case 'n': 3580 /* ignored for consistency with postmaster */ 3581 break; 3582 3583 case 'O': 3584 SetConfigOption("allow_system_table_mods", "true", ctx, gucsource); 3585 break; 3586 3587 case 'o': 3588 errs++; 3589 break; 3590 3591 case 'P': 3592 SetConfigOption("ignore_system_indexes", "true", ctx, gucsource); 3593 break; 3594 3595 case 'p': 3596 SetConfigOption("port", optarg, ctx, gucsource); 3597 break; 3598 3599 case 'r': 3600 /* send output (stdout and stderr) to the given file */ 3601 if (secure) 3602 strlcpy(OutputFileName, optarg, MAXPGPATH); 3603 break; 3604 3605 case 'S': 3606 SetConfigOption("work_mem", optarg, ctx, gucsource); 3607 break; 3608 3609 case 's': 3610 SetConfigOption("log_statement_stats", "true", ctx, gucsource); 3611 break; 3612 3613 case 'T': 3614 /* ignored for consistency with the postmaster */ 3615 break; 3616 3617 case 't': 3618 { 3619 const char *tmp = get_stats_option_name(optarg); 3620 3621 if (tmp) 3622 SetConfigOption(tmp, "true", ctx, gucsource); 3623 else 3624 errs++; 3625 break; 3626 } 3627 3628 case 'v': 3629 3630 /* 3631 * -v is no longer used in normal operation, since 3632 * FrontendProtocol is already set before we get here. We keep 3633 * the switch only for possible use in standalone operation, 3634 * in case we ever support using normal FE/BE protocol with a 3635 * standalone backend. 3636 */ 3637 if (secure) 3638 FrontendProtocol = (ProtocolVersion) atoi(optarg); 3639 break; 3640 3641 case 'W': 3642 SetConfigOption("post_auth_delay", optarg, ctx, gucsource); 3643 break; 3644 3645 case 'c': 3646 case '-': 3647 { 3648 char *name, 3649 *value; 3650 3651 ParseLongOption(optarg, &name, &value); 3652 if (!value) 3653 { 3654 if (flag == '-') 3655 ereport(ERROR, 3656 (errcode(ERRCODE_SYNTAX_ERROR), 3657 errmsg("--%s requires a value", 3658 optarg))); 3659 else 3660 ereport(ERROR, 3661 (errcode(ERRCODE_SYNTAX_ERROR), 3662 errmsg("-c %s requires a value", 3663 optarg))); 3664 } 3665 SetConfigOption(name, value, ctx, gucsource); 3666 free(name); 3667 if (value) 3668 free(value); 3669 break; 3670 } 3671 3672 default: 3673 errs++; 3674 break; 3675 } 3676 3677 if (errs) 3678 break; 3679 } 3680 3681 /* 3682 * Optional database name should be there only if *dbname is NULL. 3683 */ 3684 if (!errs && dbname && *dbname == NULL && argc - optind >= 1) 3685 *dbname = strdup(argv[optind++]); 3686 3687 if (errs || argc != optind) 3688 { 3689 if (errs) 3690 optind--; /* complain about the previous argument */ 3691 3692 /* spell the error message a bit differently depending on context */ 3693 if (IsUnderPostmaster) 3694 ereport(FATAL, 3695 errcode(ERRCODE_SYNTAX_ERROR), 3696 errmsg("invalid command-line argument for server process: %s", argv[optind]), 3697 errhint("Try \"%s --help\" for more information.", progname)); 3698 else 3699 ereport(FATAL, 3700 errcode(ERRCODE_SYNTAX_ERROR), 3701 errmsg("%s: invalid command-line argument: %s", 3702 progname, argv[optind]), 3703 errhint("Try \"%s --help\" for more information.", progname)); 3704 } 3705 3706 /* 3707 * Reset getopt(3) library so that it will work correctly in subprocesses 3708 * or when this function is called a second time with another array. 3709 */ 3710 optind = 1; 3711 #ifdef HAVE_INT_OPTRESET 3712 optreset = 1; /* some systems need this too */ 3713 #endif 3714 } 3715 3716 3717 /* ---------------------------------------------------------------- 3718 * PostgresMain 3719 * postgres main loop -- all backends, interactive or otherwise start here 3720 * 3721 * argc/argv are the command line arguments to be used. (When being forked 3722 * by the postmaster, these are not the original argv array of the process.) 3723 * dbname is the name of the database to connect to, or NULL if the database 3724 * name should be extracted from the command line arguments or defaulted. 3725 * username is the PostgreSQL user name to be used for the session. 3726 * ---------------------------------------------------------------- 3727 */ 3728 void 3729 PostgresMain(int argc, char *argv[], 3730 const char *dbname, 3731 const char *username) 3732 { 3733 int firstchar; 3734 StringInfoData input_message; 3735 sigjmp_buf local_sigjmp_buf; 3736 volatile bool send_ready_for_query = true; 3737 bool disable_idle_in_transaction_timeout = false; 3738 3739 /* Initialize startup process environment if necessary. */ 3740 if (!IsUnderPostmaster) 3741 InitStandaloneProcess(argv[0]); 3742 3743 SetProcessingMode(InitProcessing); 3744 3745 /* 3746 * Set default values for command-line options. 3747 */ 3748 if (!IsUnderPostmaster) 3749 InitializeGUCOptions(); 3750 3751 /* 3752 * Parse command-line options. 3753 */ 3754 process_postgres_switches(argc, argv, PGC_POSTMASTER, &dbname); 3755 3756 /* Must have gotten a database name, or have a default (the username) */ 3757 if (dbname == NULL) 3758 { 3759 dbname = username; 3760 if (dbname == NULL) 3761 ereport(FATAL, 3762 (errcode(ERRCODE_INVALID_PARAMETER_VALUE), 3763 errmsg("%s: no database nor user name specified", 3764 progname))); 3765 } 3766 3767 /* Acquire configuration parameters, unless inherited from postmaster */ 3768 if (!IsUnderPostmaster) 3769 { 3770 if (!SelectConfigFiles(userDoption, progname)) 3771 proc_exit(1); 3772 } 3773 3774 /* 3775 * Set up signal handlers and masks. 3776 * 3777 * Note that postmaster blocked all signals before forking child process, 3778 * so there is no race condition whereby we might receive a signal before 3779 * we have set up the handler. 3780 * 3781 * Also note: it's best not to use any signals that are SIG_IGNored in the 3782 * postmaster. If such a signal arrives before we are able to change the 3783 * handler to non-SIG_IGN, it'll get dropped. Instead, make a dummy 3784 * handler in the postmaster to reserve the signal. (Of course, this isn't 3785 * an issue for signals that are locally generated, such as SIGALRM and 3786 * SIGPIPE.) 3787 */ 3788 if (am_walsender) 3789 WalSndSignals(); 3790 else 3791 { 3792 pqsignal(SIGHUP, PostgresSigHupHandler); /* set flag to read config 3793 * file */ 3794 pqsignal(SIGINT, StatementCancelHandler); /* cancel current query */ 3795 pqsignal(SIGTERM, die); /* cancel current query and exit */ 3796 3797 /* 3798 * In a standalone backend, SIGQUIT can be generated from the keyboard 3799 * easily, while SIGTERM cannot, so we make both signals do die() 3800 * rather than quickdie(). 3801 */ 3802 if (IsUnderPostmaster) 3803 pqsignal(SIGQUIT, quickdie); /* hard crash time */ 3804 else 3805 pqsignal(SIGQUIT, die); /* cancel current query and exit */ 3806 InitializeTimeouts(); /* establishes SIGALRM handler */ 3807 3808 /* 3809 * Ignore failure to write to frontend. Note: if frontend closes 3810 * connection, we will notice it and exit cleanly when control next 3811 * returns to outer loop. This seems safer than forcing exit in the 3812 * midst of output during who-knows-what operation... 3813 */ 3814 pqsignal(SIGPIPE, SIG_IGN); 3815 pqsignal(SIGUSR1, procsignal_sigusr1_handler); 3816 pqsignal(SIGUSR2, SIG_IGN); 3817 pqsignal(SIGFPE, FloatExceptionHandler); 3818 3819 /* 3820 * Reset some signals that are accepted by postmaster but not by 3821 * backend 3822 */ 3823 pqsignal(SIGCHLD, SIG_DFL); /* system() requires this on some 3824 * platforms */ 3825 } 3826 3827 pqinitmask(); 3828 3829 if (IsUnderPostmaster) 3830 { 3831 /* We allow SIGQUIT (quickdie) at all times */ 3832 sigdelset(&BlockSig, SIGQUIT); 3833 } 3834 3835 PG_SETMASK(&BlockSig); /* block everything except SIGQUIT */ 3836 3837 if (!IsUnderPostmaster) 3838 { 3839 /* 3840 * Validate we have been given a reasonable-looking DataDir (if under 3841 * postmaster, assume postmaster did this already). 3842 */ 3843 checkDataDir(); 3844 3845 /* Change into DataDir (if under postmaster, was done already) */ 3846 ChangeToDataDir(); 3847 3848 /* 3849 * Create lockfile for data directory. 3850 */ 3851 CreateDataDirLockFile(false); 3852 3853 /* read control file (error checking and contains config ) */ 3854 LocalProcessControlFile(false); 3855 3856 /* Initialize MaxBackends (if under postmaster, was done already) */ 3857 InitializeMaxBackends(); 3858 } 3859 3860 /* Early initialization */ 3861 BaseInit(); 3862 3863 /* 3864 * Create a per-backend PGPROC struct in shared memory, except in the 3865 * EXEC_BACKEND case where this was done in SubPostmasterMain. We must do 3866 * this before we can use LWLocks (and in the EXEC_BACKEND case we already 3867 * had to do some stuff with LWLocks). 3868 */ 3869 #ifdef EXEC_BACKEND 3870 if (!IsUnderPostmaster) 3871 InitProcess(); 3872 #else 3873 InitProcess(); 3874 #endif 3875 3876 /* We need to allow SIGINT, etc during the initial transaction */ 3877 PG_SETMASK(&UnBlockSig); 3878 3879 /* 3880 * General initialization. 3881 * 3882 * NOTE: if you are tempted to add code in this vicinity, consider putting 3883 * it inside InitPostgres() instead. In particular, anything that 3884 * involves database access should be there, not here. 3885 */ 3886 InitPostgres(dbname, InvalidOid, username, InvalidOid, NULL, false); 3887 3888 /* 3889 * If the PostmasterContext is still around, recycle the space; we don't 3890 * need it anymore after InitPostgres completes. Note this does not trash 3891 * *MyProcPort, because ConnCreate() allocated that space with malloc() 3892 * ... else we'd need to copy the Port data first. Also, subsidiary data 3893 * such as the username isn't lost either; see ProcessStartupPacket(). 3894 */ 3895 if (PostmasterContext) 3896 { 3897 MemoryContextDelete(PostmasterContext); 3898 PostmasterContext = NULL; 3899 } 3900 3901 SetProcessingMode(NormalProcessing); 3902 3903 /* 3904 * Now all GUC states are fully set up. Report them to client if 3905 * appropriate. 3906 */ 3907 BeginReportingGUCOptions(); 3908 3909 /* 3910 * Also set up handler to log session end; we have to wait till now to be 3911 * sure Log_disconnections has its final value. 3912 */ 3913 if (IsUnderPostmaster && Log_disconnections) 3914 on_proc_exit(log_disconnections, 0); 3915 3916 /* Perform initialization specific to a WAL sender process. */ 3917 if (am_walsender) 3918 InitWalSender(); 3919 3920 /* 3921 * process any libraries that should be preloaded at backend start (this 3922 * likewise can't be done until GUC settings are complete) 3923 */ 3924 process_session_preload_libraries(); 3925 3926 /* 3927 * Send this backend's cancellation info to the frontend. 3928 */ 3929 if (whereToSendOutput == DestRemote) 3930 { 3931 StringInfoData buf; 3932 3933 pq_beginmessage(&buf, 'K'); 3934 pq_sendint32(&buf, (int32) MyProcPid); 3935 pq_sendint32(&buf, (int32) MyCancelKey); 3936 pq_endmessage(&buf); 3937 /* Need not flush since ReadyForQuery will do it. */ 3938 } 3939 3940 /* Welcome banner for standalone case */ 3941 if (whereToSendOutput == DestDebug) 3942 printf("\nPostgreSQL stand-alone backend %s\n", PG_VERSION); 3943 3944 /* 3945 * Create the memory context we will use in the main loop. 3946 * 3947 * MessageContext is reset once per iteration of the main loop, ie, upon 3948 * completion of processing of each command message from the client. 3949 */ 3950 MessageContext = AllocSetContextCreate(TopMemoryContext, 3951 "MessageContext", 3952 ALLOCSET_DEFAULT_SIZES); 3953 3954 /* 3955 * Create memory context and buffer used for RowDescription messages. As 3956 * SendRowDescriptionMessage(), via exec_describe_statement_message(), is 3957 * frequently executed for ever single statement, we don't want to 3958 * allocate a separate buffer every time. 3959 */ 3960 row_description_context = AllocSetContextCreate(TopMemoryContext, 3961 "RowDescriptionContext", 3962 ALLOCSET_DEFAULT_SIZES); 3963 MemoryContextSwitchTo(row_description_context); 3964 initStringInfo(&row_description_buf); 3965 MemoryContextSwitchTo(TopMemoryContext); 3966 3967 /* 3968 * Remember stand-alone backend startup time 3969 */ 3970 if (!IsUnderPostmaster) 3971 PgStartTime = GetCurrentTimestamp(); 3972 3973 /* 3974 * POSTGRES main processing loop begins here 3975 * 3976 * If an exception is encountered, processing resumes here so we abort the 3977 * current transaction and start a new one. 3978 * 3979 * You might wonder why this isn't coded as an infinite loop around a 3980 * PG_TRY construct. The reason is that this is the bottom of the 3981 * exception stack, and so with PG_TRY there would be no exception handler 3982 * in force at all during the CATCH part. By leaving the outermost setjmp 3983 * always active, we have at least some chance of recovering from an error 3984 * during error recovery. (If we get into an infinite loop thereby, it 3985 * will soon be stopped by overflow of elog.c's internal state stack.) 3986 * 3987 * Note that we use sigsetjmp(..., 1), so that this function's signal mask 3988 * (to wit, UnBlockSig) will be restored when longjmp'ing to here. This 3989 * is essential in case we longjmp'd out of a signal handler on a platform 3990 * where that leaves the signal blocked. It's not redundant with the 3991 * unblock in AbortTransaction() because the latter is only called if we 3992 * were inside a transaction. 3993 */ 3994 3995 if (sigsetjmp(local_sigjmp_buf, 1) != 0) 3996 { 3997 /* 3998 * NOTE: if you are tempted to add more code in this if-block, 3999 * consider the high probability that it should be in 4000 * AbortTransaction() instead. The only stuff done directly here 4001 * should be stuff that is guaranteed to apply *only* for outer-level 4002 * error recovery, such as adjusting the FE/BE protocol status. 4003 */ 4004 4005 /* Since not using PG_TRY, must reset error stack by hand */ 4006 error_context_stack = NULL; 4007 4008 /* Prevent interrupts while cleaning up */ 4009 HOLD_INTERRUPTS(); 4010 4011 /* 4012 * Forget any pending QueryCancel request, since we're returning to 4013 * the idle loop anyway, and cancel any active timeout requests. (In 4014 * future we might want to allow some timeout requests to survive, but 4015 * at minimum it'd be necessary to do reschedule_timeouts(), in case 4016 * we got here because of a query cancel interrupting the SIGALRM 4017 * interrupt handler.) Note in particular that we must clear the 4018 * statement and lock timeout indicators, to prevent any future plain 4019 * query cancels from being misreported as timeouts in case we're 4020 * forgetting a timeout cancel. 4021 */ 4022 disable_all_timeouts(false); 4023 QueryCancelPending = false; /* second to avoid race condition */ 4024 stmt_timeout_active = false; 4025 4026 /* Not reading from the client anymore. */ 4027 DoingCommandRead = false; 4028 4029 /* Make sure libpq is in a good state */ 4030 pq_comm_reset(); 4031 4032 /* Report the error to the client and/or server log */ 4033 EmitErrorReport(); 4034 4035 /* 4036 * Make sure debug_query_string gets reset before we possibly clobber 4037 * the storage it points at. 4038 */ 4039 debug_query_string = NULL; 4040 4041 /* 4042 * Abort the current transaction in order to recover. 4043 */ 4044 AbortCurrentTransaction(); 4045 4046 if (am_walsender) 4047 WalSndErrorCleanup(); 4048 4049 PortalErrorCleanup(); 4050 SPICleanup(); 4051 4052 /* 4053 * We can't release replication slots inside AbortTransaction() as we 4054 * need to be able to start and abort transactions while having a slot 4055 * acquired. But we never need to hold them across top level errors, 4056 * so releasing here is fine. There's another cleanup in ProcKill() 4057 * ensuring we'll correctly cleanup on FATAL errors as well. 4058 */ 4059 if (MyReplicationSlot != NULL) 4060 ReplicationSlotRelease(); 4061 4062 /* We also want to cleanup temporary slots on error. */ 4063 ReplicationSlotCleanup(); 4064 4065 jit_reset_after_error(); 4066 4067 /* 4068 * Now return to normal top-level context and clear ErrorContext for 4069 * next time. 4070 */ 4071 MemoryContextSwitchTo(TopMemoryContext); 4072 FlushErrorState(); 4073 4074 /* 4075 * If we were handling an extended-query-protocol message, initiate 4076 * skip till next Sync. This also causes us not to issue 4077 * ReadyForQuery (until we get Sync). 4078 */ 4079 if (doing_extended_query_message) 4080 ignore_till_sync = true; 4081 4082 /* We don't have a transaction command open anymore */ 4083 xact_started = false; 4084 4085 /* 4086 * If an error occurred while we were reading a message from the 4087 * client, we have potentially lost track of where the previous 4088 * message ends and the next one begins. Even though we have 4089 * otherwise recovered from the error, we cannot safely read any more 4090 * messages from the client, so there isn't much we can do with the 4091 * connection anymore. 4092 */ 4093 if (pq_is_reading_msg()) 4094 ereport(FATAL, 4095 (errcode(ERRCODE_PROTOCOL_VIOLATION), 4096 errmsg("terminating connection because protocol synchronization was lost"))); 4097 4098 /* Now we can allow interrupts again */ 4099 RESUME_INTERRUPTS(); 4100 } 4101 4102 /* We can now handle ereport(ERROR) */ 4103 PG_exception_stack = &local_sigjmp_buf; 4104 4105 if (!ignore_till_sync) 4106 send_ready_for_query = true; /* initially, or after error */ 4107 4108 /* 4109 * Non-error queries loop here. 4110 */ 4111 4112 for (;;) 4113 { 4114 /* 4115 * At top of loop, reset extended-query-message flag, so that any 4116 * errors encountered in "idle" state don't provoke skip. 4117 */ 4118 doing_extended_query_message = false; 4119 4120 /* 4121 * Release storage left over from prior query cycle, and create a new 4122 * query input buffer in the cleared MessageContext. 4123 */ 4124 MemoryContextSwitchTo(MessageContext); 4125 MemoryContextResetAndDeleteChildren(MessageContext); 4126 4127 initStringInfo(&input_message); 4128 4129 /* 4130 * Also consider releasing our catalog snapshot if any, so that it's 4131 * not preventing advance of global xmin while we wait for the client. 4132 */ 4133 InvalidateCatalogSnapshotConditionally(); 4134 4135 /* 4136 * (1) If we've reached idle state, tell the frontend we're ready for 4137 * a new query. 4138 * 4139 * Note: this includes fflush()'ing the last of the prior output. 4140 * 4141 * This is also a good time to send collected statistics to the 4142 * collector, and to update the PS stats display. We avoid doing 4143 * those every time through the message loop because it'd slow down 4144 * processing of batched messages, and because we don't want to report 4145 * uncommitted updates (that confuses autovacuum). The notification 4146 * processor wants a call too, if we are not in a transaction block. 4147 */ 4148 if (send_ready_for_query) 4149 { 4150 if (IsAbortedTransactionBlockState()) 4151 { 4152 set_ps_display("idle in transaction (aborted)", false); 4153 pgstat_report_activity(STATE_IDLEINTRANSACTION_ABORTED, NULL); 4154 4155 /* Start the idle-in-transaction timer */ 4156 if (IdleInTransactionSessionTimeout > 0) 4157 { 4158 disable_idle_in_transaction_timeout = true; 4159 enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT, 4160 IdleInTransactionSessionTimeout); 4161 } 4162 } 4163 else if (IsTransactionOrTransactionBlock()) 4164 { 4165 set_ps_display("idle in transaction", false); 4166 pgstat_report_activity(STATE_IDLEINTRANSACTION, NULL); 4167 4168 /* Start the idle-in-transaction timer */ 4169 if (IdleInTransactionSessionTimeout > 0) 4170 { 4171 disable_idle_in_transaction_timeout = true; 4172 enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT, 4173 IdleInTransactionSessionTimeout); 4174 } 4175 } 4176 else 4177 { 4178 /* Send out notify signals and transmit self-notifies */ 4179 ProcessCompletedNotifies(); 4180 4181 /* 4182 * Also process incoming notifies, if any. This is mostly to 4183 * ensure stable behavior in tests: if any notifies were 4184 * received during the just-finished transaction, they'll be 4185 * seen by the client before ReadyForQuery is. 4186 */ 4187 if (notifyInterruptPending) 4188 ProcessNotifyInterrupt(); 4189 4190 pgstat_report_stat(false); 4191 4192 set_ps_display("idle", false); 4193 pgstat_report_activity(STATE_IDLE, NULL); 4194 } 4195 4196 ReadyForQuery(whereToSendOutput); 4197 send_ready_for_query = false; 4198 } 4199 4200 /* 4201 * (2) Allow asynchronous signals to be executed immediately if they 4202 * come in while we are waiting for client input. (This must be 4203 * conditional since we don't want, say, reads on behalf of COPY FROM 4204 * STDIN doing the same thing.) 4205 */ 4206 DoingCommandRead = true; 4207 4208 /* 4209 * (3) read a command (loop blocks here) 4210 */ 4211 firstchar = ReadCommand(&input_message); 4212 4213 /* 4214 * (4) turn off the idle-in-transaction timeout, if active. We do 4215 * this before step (5) so that any last-moment timeout is certain to 4216 * be detected in step (5). 4217 */ 4218 if (disable_idle_in_transaction_timeout) 4219 { 4220 disable_timeout(IDLE_IN_TRANSACTION_SESSION_TIMEOUT, false); 4221 disable_idle_in_transaction_timeout = false; 4222 } 4223 4224 /* 4225 * (5) disable async signal conditions again. 4226 * 4227 * Query cancel is supposed to be a no-op when there is no query in 4228 * progress, so if a query cancel arrived while we were idle, just 4229 * reset QueryCancelPending. ProcessInterrupts() has that effect when 4230 * it's called when DoingCommandRead is set, so check for interrupts 4231 * before resetting DoingCommandRead. 4232 */ 4233 CHECK_FOR_INTERRUPTS(); 4234 DoingCommandRead = false; 4235 4236 /* 4237 * (6) check for any other interesting events that happened while we 4238 * slept. 4239 */ 4240 if (ConfigReloadPending) 4241 { 4242 ConfigReloadPending = false; 4243 ProcessConfigFile(PGC_SIGHUP); 4244 } 4245 4246 /* 4247 * (7) process the command. But ignore it if we're skipping till 4248 * Sync. 4249 */ 4250 if (ignore_till_sync && firstchar != EOF) 4251 continue; 4252 4253 switch (firstchar) 4254 { 4255 case 'Q': /* simple query */ 4256 { 4257 const char *query_string; 4258 4259 /* Set statement_timestamp() */ 4260 SetCurrentStatementStartTimestamp(); 4261 4262 query_string = pq_getmsgstring(&input_message); 4263 pq_getmsgend(&input_message); 4264 4265 if (am_walsender) 4266 { 4267 if (!exec_replication_command(query_string)) 4268 exec_simple_query(query_string); 4269 } 4270 else 4271 exec_simple_query(query_string); 4272 4273 send_ready_for_query = true; 4274 } 4275 break; 4276 4277 case 'P': /* parse */ 4278 { 4279 const char *stmt_name; 4280 const char *query_string; 4281 int numParams; 4282 Oid *paramTypes = NULL; 4283 4284 forbidden_in_wal_sender(firstchar); 4285 4286 /* Set statement_timestamp() */ 4287 SetCurrentStatementStartTimestamp(); 4288 4289 stmt_name = pq_getmsgstring(&input_message); 4290 query_string = pq_getmsgstring(&input_message); 4291 numParams = pq_getmsgint(&input_message, 2); 4292 if (numParams > 0) 4293 { 4294 paramTypes = (Oid *) palloc(numParams * sizeof(Oid)); 4295 for (int i = 0; i < numParams; i++) 4296 paramTypes[i] = pq_getmsgint(&input_message, 4); 4297 } 4298 pq_getmsgend(&input_message); 4299 4300 exec_parse_message(query_string, stmt_name, 4301 paramTypes, numParams); 4302 } 4303 break; 4304 4305 case 'B': /* bind */ 4306 forbidden_in_wal_sender(firstchar); 4307 4308 /* Set statement_timestamp() */ 4309 SetCurrentStatementStartTimestamp(); 4310 4311 /* 4312 * this message is complex enough that it seems best to put 4313 * the field extraction out-of-line 4314 */ 4315 exec_bind_message(&input_message); 4316 break; 4317 4318 case 'E': /* execute */ 4319 { 4320 const char *portal_name; 4321 int max_rows; 4322 4323 forbidden_in_wal_sender(firstchar); 4324 4325 /* Set statement_timestamp() */ 4326 SetCurrentStatementStartTimestamp(); 4327 4328 portal_name = pq_getmsgstring(&input_message); 4329 max_rows = pq_getmsgint(&input_message, 4); 4330 pq_getmsgend(&input_message); 4331 4332 exec_execute_message(portal_name, max_rows); 4333 } 4334 break; 4335 4336 case 'F': /* fastpath function call */ 4337 forbidden_in_wal_sender(firstchar); 4338 4339 /* Set statement_timestamp() */ 4340 SetCurrentStatementStartTimestamp(); 4341 4342 /* Report query to various monitoring facilities. */ 4343 pgstat_report_activity(STATE_FASTPATH, NULL); 4344 set_ps_display("<FASTPATH>", false); 4345 4346 /* start an xact for this function invocation */ 4347 start_xact_command(); 4348 4349 /* 4350 * Note: we may at this point be inside an aborted 4351 * transaction. We can't throw error for that until we've 4352 * finished reading the function-call message, so 4353 * HandleFunctionRequest() must check for it after doing so. 4354 * Be careful not to do anything that assumes we're inside a 4355 * valid transaction here. 4356 */ 4357 4358 /* switch back to message context */ 4359 MemoryContextSwitchTo(MessageContext); 4360 4361 HandleFunctionRequest(&input_message); 4362 4363 /* commit the function-invocation transaction */ 4364 finish_xact_command(); 4365 4366 send_ready_for_query = true; 4367 break; 4368 4369 case 'C': /* close */ 4370 { 4371 int close_type; 4372 const char *close_target; 4373 4374 forbidden_in_wal_sender(firstchar); 4375 4376 close_type = pq_getmsgbyte(&input_message); 4377 close_target = pq_getmsgstring(&input_message); 4378 pq_getmsgend(&input_message); 4379 4380 switch (close_type) 4381 { 4382 case 'S': 4383 if (close_target[0] != '\0') 4384 DropPreparedStatement(close_target, false); 4385 else 4386 { 4387 /* special-case the unnamed statement */ 4388 drop_unnamed_stmt(); 4389 } 4390 break; 4391 case 'P': 4392 { 4393 Portal portal; 4394 4395 portal = GetPortalByName(close_target); 4396 if (PortalIsValid(portal)) 4397 PortalDrop(portal, false); 4398 } 4399 break; 4400 default: 4401 ereport(ERROR, 4402 (errcode(ERRCODE_PROTOCOL_VIOLATION), 4403 errmsg("invalid CLOSE message subtype %d", 4404 close_type))); 4405 break; 4406 } 4407 4408 if (whereToSendOutput == DestRemote) 4409 pq_putemptymessage('3'); /* CloseComplete */ 4410 } 4411 break; 4412 4413 case 'D': /* describe */ 4414 { 4415 int describe_type; 4416 const char *describe_target; 4417 4418 forbidden_in_wal_sender(firstchar); 4419 4420 /* Set statement_timestamp() (needed for xact) */ 4421 SetCurrentStatementStartTimestamp(); 4422 4423 describe_type = pq_getmsgbyte(&input_message); 4424 describe_target = pq_getmsgstring(&input_message); 4425 pq_getmsgend(&input_message); 4426 4427 switch (describe_type) 4428 { 4429 case 'S': 4430 exec_describe_statement_message(describe_target); 4431 break; 4432 case 'P': 4433 exec_describe_portal_message(describe_target); 4434 break; 4435 default: 4436 ereport(ERROR, 4437 (errcode(ERRCODE_PROTOCOL_VIOLATION), 4438 errmsg("invalid DESCRIBE message subtype %d", 4439 describe_type))); 4440 break; 4441 } 4442 } 4443 break; 4444 4445 case 'H': /* flush */ 4446 pq_getmsgend(&input_message); 4447 if (whereToSendOutput == DestRemote) 4448 pq_flush(); 4449 break; 4450 4451 case 'S': /* sync */ 4452 pq_getmsgend(&input_message); 4453 finish_xact_command(); 4454 send_ready_for_query = true; 4455 break; 4456 4457 /* 4458 * 'X' means that the frontend is closing down the socket. EOF 4459 * means unexpected loss of frontend connection. Either way, 4460 * perform normal shutdown. 4461 */ 4462 case 'X': 4463 case EOF: 4464 4465 /* 4466 * Reset whereToSendOutput to prevent ereport from attempting 4467 * to send any more messages to client. 4468 */ 4469 if (whereToSendOutput == DestRemote) 4470 whereToSendOutput = DestNone; 4471 4472 /* 4473 * NOTE: if you are tempted to add more code here, DON'T! 4474 * Whatever you had in mind to do should be set up as an 4475 * on_proc_exit or on_shmem_exit callback, instead. Otherwise 4476 * it will fail to be called during other backend-shutdown 4477 * scenarios. 4478 */ 4479 proc_exit(0); 4480 4481 case 'd': /* copy data */ 4482 case 'c': /* copy done */ 4483 case 'f': /* copy fail */ 4484 4485 /* 4486 * Accept but ignore these messages, per protocol spec; we 4487 * probably got here because a COPY failed, and the frontend 4488 * is still sending data. 4489 */ 4490 break; 4491 4492 default: 4493 ereport(FATAL, 4494 (errcode(ERRCODE_PROTOCOL_VIOLATION), 4495 errmsg("invalid frontend message type %d", 4496 firstchar))); 4497 } 4498 } /* end of input-reading loop */ 4499 } 4500 4501 /* 4502 * Throw an error if we're a WAL sender process. 4503 * 4504 * This is used to forbid anything else than simple query protocol messages 4505 * in a WAL sender process. 'firstchar' specifies what kind of a forbidden 4506 * message was received, and is used to construct the error message. 4507 */ 4508 static void 4509 forbidden_in_wal_sender(char firstchar) 4510 { 4511 if (am_walsender) 4512 { 4513 if (firstchar == 'F') 4514 ereport(ERROR, 4515 (errcode(ERRCODE_PROTOCOL_VIOLATION), 4516 errmsg("fastpath function calls not supported in a replication connection"))); 4517 else 4518 ereport(ERROR, 4519 (errcode(ERRCODE_PROTOCOL_VIOLATION), 4520 errmsg("extended query protocol not supported in a replication connection"))); 4521 } 4522 } 4523 4524 4525 /* 4526 * Obtain platform stack depth limit (in bytes) 4527 * 4528 * Return -1 if unknown 4529 */ 4530 long 4531 get_stack_depth_rlimit(void) 4532 { 4533 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_STACK) 4534 static long val = 0; 4535 4536 /* This won't change after process launch, so check just once */ 4537 if (val == 0) 4538 { 4539 struct rlimit rlim; 4540 4541 if (getrlimit(RLIMIT_STACK, &rlim) < 0) 4542 val = -1; 4543 else if (rlim.rlim_cur == RLIM_INFINITY) 4544 val = LONG_MAX; 4545 /* rlim_cur is probably of an unsigned type, so check for overflow */ 4546 else if (rlim.rlim_cur >= LONG_MAX) 4547 val = LONG_MAX; 4548 else 4549 val = rlim.rlim_cur; 4550 } 4551 return val; 4552 #else /* no getrlimit */ 4553 #if defined(WIN32) || defined(__CYGWIN__) 4554 /* On Windows we set the backend stack size in src/backend/Makefile */ 4555 return WIN32_STACK_RLIMIT; 4556 #else /* not windows ... give up */ 4557 return -1; 4558 #endif 4559 #endif 4560 } 4561 4562 4563 static struct rusage Save_r; 4564 static struct timeval Save_t; 4565 4566 void 4567 ResetUsage(void) 4568 { 4569 getrusage(RUSAGE_SELF, &Save_r); 4570 gettimeofday(&Save_t, NULL); 4571 } 4572 4573 void 4574 ShowUsage(const char *title) 4575 { 4576 StringInfoData str; 4577 struct timeval user, 4578 sys; 4579 struct timeval elapse_t; 4580 struct rusage r; 4581 4582 getrusage(RUSAGE_SELF, &r); 4583 gettimeofday(&elapse_t, NULL); 4584 memcpy((char *) &user, (char *) &r.ru_utime, sizeof(user)); 4585 memcpy((char *) &sys, (char *) &r.ru_stime, sizeof(sys)); 4586 if (elapse_t.tv_usec < Save_t.tv_usec) 4587 { 4588 elapse_t.tv_sec--; 4589 elapse_t.tv_usec += 1000000; 4590 } 4591 if (r.ru_utime.tv_usec < Save_r.ru_utime.tv_usec) 4592 { 4593 r.ru_utime.tv_sec--; 4594 r.ru_utime.tv_usec += 1000000; 4595 } 4596 if (r.ru_stime.tv_usec < Save_r.ru_stime.tv_usec) 4597 { 4598 r.ru_stime.tv_sec--; 4599 r.ru_stime.tv_usec += 1000000; 4600 } 4601 4602 /* 4603 * The only stats we don't show here are ixrss, idrss, isrss. It takes 4604 * some work to interpret them, and most platforms don't fill them in. 4605 */ 4606 initStringInfo(&str); 4607 4608 appendStringInfoString(&str, "! system usage stats:\n"); 4609 appendStringInfo(&str, 4610 "!\t%ld.%06ld s user, %ld.%06ld s system, %ld.%06ld s elapsed\n", 4611 (long) (r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec), 4612 (long) (r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec), 4613 (long) (r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec), 4614 (long) (r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec), 4615 (long) (elapse_t.tv_sec - Save_t.tv_sec), 4616 (long) (elapse_t.tv_usec - Save_t.tv_usec)); 4617 appendStringInfo(&str, 4618 "!\t[%ld.%06ld s user, %ld.%06ld s system total]\n", 4619 (long) user.tv_sec, 4620 (long) user.tv_usec, 4621 (long) sys.tv_sec, 4622 (long) sys.tv_usec); 4623 #if defined(HAVE_GETRUSAGE) 4624 appendStringInfo(&str, 4625 "!\t%ld kB max resident size\n", 4626 #if defined(__darwin__) 4627 /* in bytes on macOS */ 4628 r.ru_maxrss / 1024 4629 #else 4630 /* in kilobytes on most other platforms */ 4631 r.ru_maxrss 4632 #endif 4633 ); 4634 appendStringInfo(&str, 4635 "!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n", 4636 r.ru_inblock - Save_r.ru_inblock, 4637 /* they only drink coffee at dec */ 4638 r.ru_oublock - Save_r.ru_oublock, 4639 r.ru_inblock, r.ru_oublock); 4640 appendStringInfo(&str, 4641 "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n", 4642 r.ru_majflt - Save_r.ru_majflt, 4643 r.ru_minflt - Save_r.ru_minflt, 4644 r.ru_majflt, r.ru_minflt, 4645 r.ru_nswap - Save_r.ru_nswap, 4646 r.ru_nswap); 4647 appendStringInfo(&str, 4648 "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n", 4649 r.ru_nsignals - Save_r.ru_nsignals, 4650 r.ru_nsignals, 4651 r.ru_msgrcv - Save_r.ru_msgrcv, 4652 r.ru_msgsnd - Save_r.ru_msgsnd, 4653 r.ru_msgrcv, r.ru_msgsnd); 4654 appendStringInfo(&str, 4655 "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n", 4656 r.ru_nvcsw - Save_r.ru_nvcsw, 4657 r.ru_nivcsw - Save_r.ru_nivcsw, 4658 r.ru_nvcsw, r.ru_nivcsw); 4659 #endif /* HAVE_GETRUSAGE */ 4660 4661 /* remove trailing newline */ 4662 if (str.data[str.len - 1] == '\n') 4663 str.data[--str.len] = '\0'; 4664 4665 ereport(LOG, 4666 (errmsg_internal("%s", title), 4667 errdetail_internal("%s", str.data))); 4668 4669 pfree(str.data); 4670 } 4671 4672 /* 4673 * on_proc_exit handler to log end of session 4674 */ 4675 static void 4676 log_disconnections(int code, Datum arg) 4677 { 4678 Port *port = MyProcPort; 4679 long secs; 4680 int usecs; 4681 int msecs; 4682 int hours, 4683 minutes, 4684 seconds; 4685 4686 TimestampDifference(MyStartTimestamp, 4687 GetCurrentTimestamp(), 4688 &secs, &usecs); 4689 msecs = usecs / 1000; 4690 4691 hours = secs / SECS_PER_HOUR; 4692 secs %= SECS_PER_HOUR; 4693 minutes = secs / SECS_PER_MINUTE; 4694 seconds = secs % SECS_PER_MINUTE; 4695 4696 ereport(LOG, 4697 (errmsg("disconnection: session time: %d:%02d:%02d.%03d " 4698 "user=%s database=%s host=%s%s%s", 4699 hours, minutes, seconds, msecs, 4700 port->user_name, port->database_name, port->remote_host, 4701 port->remote_port[0] ? " port=" : "", port->remote_port))); 4702 } 4703 4704 /* 4705 * Start statement timeout timer, if enabled. 4706 * 4707 * If there's already a timeout running, don't restart the timer. That 4708 * enables compromises between accuracy of timeouts and cost of starting a 4709 * timeout. 4710 */ 4711 static void 4712 enable_statement_timeout(void) 4713 { 4714 /* must be within an xact */ 4715 Assert(xact_started); 4716 4717 if (StatementTimeout > 0) 4718 { 4719 if (!stmt_timeout_active) 4720 { 4721 enable_timeout_after(STATEMENT_TIMEOUT, StatementTimeout); 4722 stmt_timeout_active = true; 4723 } 4724 } 4725 else 4726 disable_timeout(STATEMENT_TIMEOUT, false); 4727 } 4728 4729 /* 4730 * Disable statement timeout, if active. 4731 */ 4732 static void 4733 disable_statement_timeout(void) 4734 { 4735 if (stmt_timeout_active) 4736 { 4737 disable_timeout(STATEMENT_TIMEOUT, false); 4738 4739 stmt_timeout_active = false; 4740 } 4741 } 4742