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
InteractiveBackend(StringInfo inBuf)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
interactive_getc(void)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
SocketBackend(StringInfo inBuf)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
ReadCommand(StringInfo inBuf)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
ProcessClientReadInterrupt(bool blocked)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
ProcessClientWriteInterrupt(bool blocked)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 *
pg_parse_query(const char * query_string)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 *
pg_analyze_and_rewrite(RawStmt * parsetree,const char * query_string,Oid * paramTypes,int numParams,QueryEnvironment * queryEnv)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 *
pg_analyze_and_rewrite_params(RawStmt * parsetree,const char * query_string,ParserSetupHook parserSetup,void * parserSetupArg,QueryEnvironment * queryEnv)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 *
pg_rewrite_query(Query * query)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 *
pg_plan_query(Query * querytree,int cursorOptions,ParamListInfo boundParams)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 *
pg_plan_queries(List * querytrees,int cursorOptions,ParamListInfo boundParams)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
exec_simple_query(const char * query_string)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
exec_parse_message(const char * query_string,const char * stmt_name,Oid * paramTypes,int numParams)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
exec_bind_message(StringInfo input_message)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
exec_execute_message(const char * portal_name,long max_rows)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
check_log_statement(List * stmt_list)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
check_log_duration(char * msec_str,bool was_logged)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
errdetail_execute(List * raw_parsetree_list)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
errdetail_params(ParamListInfo params)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
errdetail_abort(void)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
errdetail_recovery_conflict(void)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
exec_describe_statement_message(const char * stmt_name)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
exec_describe_portal_message(const char * portal_name)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
start_xact_command(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
finish_xact_command(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
IsTransactionExitStmt(Node * parsetree)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
IsTransactionExitStmtList(List * pstmts)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
IsTransactionStmtList(List * pstmts)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
drop_unnamed_stmt(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
quickdie(SIGNAL_ARGS)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
die(SIGNAL_ARGS)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
StatementCancelHandler(SIGNAL_ARGS)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
FloatExceptionHandler(SIGNAL_ARGS)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
PostgresSigHupHandler(SIGNAL_ARGS)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
RecoveryConflictInterrupt(ProcSignalReason reason)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
ProcessInterrupts(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 *
ia64_get_bsp(void)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
set_stack_base(void)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
restore_stack_base(pg_stack_base_t base)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
check_stack_depth(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
stack_is_too_deep(void)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
check_max_stack_depth(int * newval,void ** extra,GucSource source)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
assign_max_stack_depth(int newval,void * extra)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
set_debug_options(int debug_flag,GucContext context,GucSource source)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
set_plan_disabling_options(const char * arg,GucContext context,GucSource source)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 *
get_stats_option_name(const char * arg)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
process_postgres_switches(int argc,char * argv[],GucContext ctx,const char ** dbname)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
PostgresMain(int argc,char * argv[],const char * dbname,const char * username)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
forbidden_in_wal_sender(char firstchar)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
get_stack_depth_rlimit(void)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
ResetUsage(void)4567 ResetUsage(void)
4568 {
4569 getrusage(RUSAGE_SELF, &Save_r);
4570 gettimeofday(&Save_t, NULL);
4571 }
4572
4573 void
ShowUsage(const char * title)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
log_disconnections(int code,Datum arg)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
enable_statement_timeout(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
disable_statement_timeout(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