Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * elog.c
4 : * error logging and reporting
5 : *
6 : * Because of the extremely high rate at which log messages can be generated,
7 : * we need to be mindful of the performance cost of obtaining any information
8 : * that may be logged. Also, it's important to keep in mind that this code may
9 : * get called from within an aborted transaction, in which case operations
10 : * such as syscache lookups are unsafe.
11 : *
12 : * Some notes about recursion and errors during error processing:
13 : *
14 : * We need to be robust about recursive-error scenarios --- for example,
15 : * if we run out of memory, it's important to be able to report that fact.
16 : * There are a number of considerations that go into this.
17 : *
18 : * First, distinguish between re-entrant use and actual recursion. It
19 : * is possible for an error or warning message to be emitted while the
20 : * parameters for an error message are being computed. In this case
21 : * errstart has been called for the outer message, and some field values
22 : * may have already been saved, but we are not actually recursing. We handle
23 : * this by providing a (small) stack of ErrorData records. The inner message
24 : * can be computed and sent without disturbing the state of the outer message.
25 : * (If the inner message is actually an error, this isn't very interesting
26 : * because control won't come back to the outer message generator ... but
27 : * if the inner message is only debug or log data, this is critical.)
28 : *
29 : * Second, actual recursion will occur if an error is reported by one of
30 : * the elog.c routines or something they call. By far the most probable
31 : * scenario of this sort is "out of memory"; and it's also the nastiest
32 : * to handle because we'd likely also run out of memory while trying to
33 : * report this error! Our escape hatch for this case is to reset the
34 : * ErrorContext to empty before trying to process the inner error. Since
35 : * ErrorContext is guaranteed to have at least 8K of space in it (see mcxt.c),
36 : * we should be able to process an "out of memory" message successfully.
37 : * Since we lose the prior error state due to the reset, we won't be able
38 : * to return to processing the original error, but we wouldn't have anyway.
39 : * (NOTE: the escape hatch is not used for recursive situations where the
40 : * inner message is of less than ERROR severity; in that case we just
41 : * try to process it and return normally. Usually this will work, but if
42 : * it ends up in infinite recursion, we will PANIC due to error stack
43 : * overflow.)
44 : *
45 : *
46 : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
47 : * Portions Copyright (c) 1994, Regents of the University of California
48 : *
49 : *
50 : * IDENTIFICATION
51 : * src/backend/utils/error/elog.c
52 : *
53 : *-------------------------------------------------------------------------
54 : */
55 : #include "postgres.h"
56 :
57 : #include <fcntl.h>
58 : #include <time.h>
59 : #include <unistd.h>
60 : #include <signal.h>
61 : #include <ctype.h>
62 : #ifdef HAVE_SYSLOG
63 : #include <syslog.h>
64 : #endif
65 : #ifdef HAVE_EXECINFO_H
66 : #include <execinfo.h>
67 : #endif
68 :
69 : #include "access/xact.h"
70 : #include "common/ip.h"
71 : #include "libpq/libpq.h"
72 : #include "libpq/pqformat.h"
73 : #include "mb/pg_wchar.h"
74 : #include "miscadmin.h"
75 : #include "nodes/miscnodes.h"
76 : #include "pgstat.h"
77 : #include "postmaster/bgworker.h"
78 : #include "postmaster/postmaster.h"
79 : #include "postmaster/syslogger.h"
80 : #include "storage/ipc.h"
81 : #include "storage/proc.h"
82 : #include "tcop/tcopprot.h"
83 : #include "utils/guc_hooks.h"
84 : #include "utils/memutils.h"
85 : #include "utils/ps_status.h"
86 : #include "utils/varlena.h"
87 :
88 :
89 : /* In this module, access gettext() via err_gettext() */
90 : #undef _
91 : #define _(x) err_gettext(x)
92 :
93 :
94 : /* Global variables */
95 : ErrorContextCallback *error_context_stack = NULL;
96 :
97 : sigjmp_buf *PG_exception_stack = NULL;
98 :
99 : /*
100 : * Hook for intercepting messages before they are sent to the server log.
101 : * Note that the hook will not get called for messages that are suppressed
102 : * by log_min_messages. Also note that logging hooks implemented in preload
103 : * libraries will miss any log messages that are generated before the
104 : * library is loaded.
105 : */
106 : emit_log_hook_type emit_log_hook = NULL;
107 :
108 : /* GUC parameters */
109 : int Log_error_verbosity = PGERROR_DEFAULT;
110 : char *Log_line_prefix = NULL; /* format for extra log line info */
111 : int Log_destination = LOG_DESTINATION_STDERR;
112 : char *Log_destination_string = NULL;
113 : bool syslog_sequence_numbers = true;
114 : bool syslog_split_messages = true;
115 :
116 : /* Processed form of backtrace_functions GUC */
117 : static char *backtrace_function_list;
118 :
119 : #ifdef HAVE_SYSLOG
120 :
121 : /*
122 : * Max string length to send to syslog(). Note that this doesn't count the
123 : * sequence-number prefix we add, and of course it doesn't count the prefix
124 : * added by syslog itself. Solaris and sysklogd truncate the final message
125 : * at 1024 bytes, so this value leaves 124 bytes for those prefixes. (Most
126 : * other syslog implementations seem to have limits of 2KB or so.)
127 : */
128 : #ifndef PG_SYSLOG_LIMIT
129 : #define PG_SYSLOG_LIMIT 900
130 : #endif
131 :
132 : static bool openlog_done = false;
133 : static char *syslog_ident = NULL;
134 : static int syslog_facility = LOG_LOCAL0;
135 :
136 : static void write_syslog(int level, const char *line);
137 : #endif
138 :
139 : #ifdef WIN32
140 : static void write_eventlog(int level, const char *line, int len);
141 : #endif
142 :
143 : /* We provide a small stack of ErrorData records for re-entrant cases */
144 : #define ERRORDATA_STACK_SIZE 5
145 :
146 : static ErrorData errordata[ERRORDATA_STACK_SIZE];
147 :
148 : static int errordata_stack_depth = -1; /* index of topmost active frame */
149 :
150 : static int recursion_depth = 0; /* to detect actual recursion */
151 :
152 : /*
153 : * Saved timeval and buffers for formatted timestamps that might be used by
154 : * log_line_prefix, csv logs and JSON logs.
155 : */
156 : static struct timeval saved_timeval;
157 : static bool saved_timeval_set = false;
158 :
159 : #define FORMATTED_TS_LEN 128
160 : static char formatted_start_time[FORMATTED_TS_LEN];
161 : static char formatted_log_time[FORMATTED_TS_LEN];
162 :
163 :
164 : /* Macro for checking errordata_stack_depth is reasonable */
165 : #define CHECK_STACK_DEPTH() \
166 : do { \
167 : if (errordata_stack_depth < 0) \
168 : { \
169 : errordata_stack_depth = -1; \
170 : ereport(ERROR, (errmsg_internal("errstart was not called"))); \
171 : } \
172 : } while (0)
173 :
174 :
175 : static const char *err_gettext(const char *str) pg_attribute_format_arg(1);
176 : static ErrorData *get_error_stack_entry(void);
177 : static void set_stack_entry_domain(ErrorData *edata, const char *domain);
178 : static void set_stack_entry_location(ErrorData *edata,
179 : const char *filename, int lineno,
180 : const char *funcname);
181 : static bool matches_backtrace_functions(const char *funcname);
182 : static pg_noinline void set_backtrace(ErrorData *edata, int num_skip);
183 : static void set_errdata_field(MemoryContextData *cxt, char **ptr, const char *str);
184 : static void FreeErrorDataContents(ErrorData *edata);
185 : static void write_console(const char *line, int len);
186 : static const char *process_log_prefix_padding(const char *p, int *ppadding);
187 : static void log_line_prefix(StringInfo buf, ErrorData *edata);
188 : static void send_message_to_server_log(ErrorData *edata);
189 : static void send_message_to_frontend(ErrorData *edata);
190 : static void append_with_tabs(StringInfo buf, const char *str);
191 :
192 :
193 : /*
194 : * is_log_level_output -- is elevel logically >= log_min_level?
195 : *
196 : * We use this for tests that should consider LOG to sort out-of-order,
197 : * between ERROR and FATAL. Generally this is the right thing for testing
198 : * whether a message should go to the postmaster log, whereas a simple >=
199 : * test is correct for testing whether the message should go to the client.
200 : */
201 : static inline bool
202 91746418 : is_log_level_output(int elevel, int log_min_level)
203 : {
204 91746418 : if (elevel == LOG || elevel == LOG_SERVER_ONLY)
205 : {
206 840082 : if (log_min_level == LOG || log_min_level <= ERROR)
207 840080 : return true;
208 : }
209 90906336 : else if (elevel == WARNING_CLIENT_ONLY)
210 : {
211 : /* never sent to log, regardless of log_min_level */
212 0 : return false;
213 : }
214 90906336 : else if (log_min_level == LOG)
215 : {
216 : /* elevel != LOG */
217 0 : if (elevel >= FATAL)
218 0 : return true;
219 : }
220 : /* Neither is LOG */
221 90906336 : else if (elevel >= log_min_level)
222 354090 : return true;
223 :
224 90552248 : return false;
225 : }
226 :
227 : /*
228 : * Policy-setting subroutines. These are fairly simple, but it seems wise
229 : * to have the code in just one place.
230 : */
231 :
232 : /*
233 : * should_output_to_server --- should message of given elevel go to the log?
234 : */
235 : static inline bool
236 91024448 : should_output_to_server(int elevel)
237 : {
238 91024448 : return is_log_level_output(elevel, log_min_messages);
239 : }
240 :
241 : /*
242 : * should_output_to_client --- should message of given elevel go to the client?
243 : */
244 : static inline bool
245 91023048 : should_output_to_client(int elevel)
246 : {
247 91023048 : if (whereToSendOutput == DestRemote && elevel != LOG_SERVER_ONLY)
248 : {
249 : /*
250 : * client_min_messages is honored only after we complete the
251 : * authentication handshake. This is required both for security
252 : * reasons and because many clients can't handle NOTICE messages
253 : * during authentication.
254 : */
255 42832338 : if (ClientAuthInProgress)
256 220994 : return (elevel >= ERROR);
257 : else
258 42611344 : return (elevel >= client_min_messages || elevel == INFO);
259 : }
260 48190710 : return false;
261 : }
262 :
263 :
264 : /*
265 : * message_level_is_interesting --- would ereport/elog do anything?
266 : *
267 : * Returns true if ereport/elog with this elevel will not be a no-op.
268 : * This is useful to short-circuit any expensive preparatory work that
269 : * might be needed for a logging message. There is no point in
270 : * prepending this to a bare ereport/elog call, however.
271 : */
272 : bool
273 2233682 : message_level_is_interesting(int elevel)
274 : {
275 : /*
276 : * Keep this in sync with the decision-making in errstart().
277 : */
278 4467364 : if (elevel >= ERROR ||
279 4465964 : should_output_to_server(elevel) ||
280 2232282 : should_output_to_client(elevel))
281 3820 : return true;
282 2229862 : return false;
283 : }
284 :
285 :
286 : /*
287 : * in_error_recursion_trouble --- are we at risk of infinite error recursion?
288 : *
289 : * This function exists to provide common control of various fallback steps
290 : * that we take if we think we are facing infinite error recursion. See the
291 : * callers for details.
292 : */
293 : bool
294 3772564 : in_error_recursion_trouble(void)
295 : {
296 : /* Pull the plug if recurse more than once */
297 3772564 : return (recursion_depth > 2);
298 : }
299 :
300 : /*
301 : * One of those fallback steps is to stop trying to localize the error
302 : * message, since there's a significant probability that that's exactly
303 : * what's causing the recursion.
304 : */
305 : static inline const char *
306 1275984 : err_gettext(const char *str)
307 : {
308 : #ifdef ENABLE_NLS
309 1275984 : if (in_error_recursion_trouble())
310 12 : return str;
311 : else
312 1275972 : return gettext(str);
313 : #else
314 : return str;
315 : #endif
316 : }
317 :
318 : /*
319 : * errstart_cold
320 : * A simple wrapper around errstart, but hinted to be "cold". Supporting
321 : * compilers are more likely to move code for branches containing this
322 : * function into an area away from the calling function's code. This can
323 : * result in more commonly executed code being more compact and fitting
324 : * on fewer cache lines.
325 : */
326 : pg_attribute_cold bool
327 42232 : errstart_cold(int elevel, const char *domain)
328 : {
329 42232 : return errstart(elevel, domain);
330 : }
331 :
332 : /*
333 : * errstart --- begin an error-reporting cycle
334 : *
335 : * Create and initialize error stack entry. Subsequently, errmsg() and
336 : * perhaps other routines will be called to further populate the stack entry.
337 : * Finally, errfinish() will be called to actually process the error report.
338 : *
339 : * Returns true in normal case. Returns false to short-circuit the error
340 : * report (if it's a warning or lower and not to be reported anywhere).
341 : */
342 : bool
343 88790766 : errstart(int elevel, const char *domain)
344 : {
345 : ErrorData *edata;
346 : bool output_to_server;
347 88790766 : bool output_to_client = false;
348 : int i;
349 :
350 : /*
351 : * Check some cases in which we want to promote an error into a more
352 : * severe error. None of this logic applies for non-error messages.
353 : */
354 88790766 : if (elevel >= ERROR)
355 : {
356 : /*
357 : * If we are inside a critical section, all errors become PANIC
358 : * errors. See miscadmin.h.
359 : */
360 50796 : if (CritSectionCount > 0)
361 0 : elevel = PANIC;
362 :
363 : /*
364 : * Check reasons for treating ERROR as FATAL:
365 : *
366 : * 1. we have no handler to pass the error to (implies we are in the
367 : * postmaster or in backend startup).
368 : *
369 : * 2. ExitOnAnyError mode switch is set (initdb uses this).
370 : *
371 : * 3. the error occurred after proc_exit has begun to run. (It's
372 : * proc_exit's responsibility to see that this doesn't turn into
373 : * infinite recursion!)
374 : */
375 50796 : if (elevel == ERROR)
376 : {
377 49882 : if (PG_exception_stack == NULL ||
378 49532 : ExitOnAnyError ||
379 : proc_exit_inprogress)
380 350 : elevel = FATAL;
381 : }
382 :
383 : /*
384 : * If the error level is ERROR or more, errfinish is not going to
385 : * return to caller; therefore, if there is any stacked error already
386 : * in progress it will be lost. This is more or less okay, except we
387 : * do not want to have a FATAL or PANIC error downgraded because the
388 : * reporting process was interrupted by a lower-grade error. So check
389 : * the stack and make sure we panic if panic is warranted.
390 : */
391 50798 : for (i = 0; i <= errordata_stack_depth; i++)
392 2 : elevel = Max(elevel, errordata[i].elevel);
393 : }
394 :
395 : /*
396 : * Now decide whether we need to process this report at all; if it's
397 : * warning or less and not enabled for logging, just return false without
398 : * starting up any error logging machinery.
399 : */
400 88790766 : output_to_server = should_output_to_server(elevel);
401 88790766 : output_to_client = should_output_to_client(elevel);
402 88790766 : if (elevel < ERROR && !output_to_server && !output_to_client)
403 88039454 : return false;
404 :
405 : /*
406 : * We need to do some actual work. Make sure that memory context
407 : * initialization has finished, else we can't do anything useful.
408 : */
409 751312 : if (ErrorContext == NULL)
410 : {
411 : /* Oops, hard crash time; very little we can do safely here */
412 0 : write_stderr("error occurred before error message processing is available\n");
413 0 : exit(2);
414 : }
415 :
416 : /*
417 : * Okay, crank up a stack entry to store the info in.
418 : */
419 :
420 751312 : if (recursion_depth++ > 0 && elevel >= ERROR)
421 : {
422 : /*
423 : * Oops, error during error processing. Clear ErrorContext as
424 : * discussed at top of file. We will not return to the original
425 : * error's reporter or handler, so we don't need it.
426 : */
427 0 : MemoryContextReset(ErrorContext);
428 :
429 : /*
430 : * Infinite error recursion might be due to something broken in a
431 : * context traceback routine. Abandon them too. We also abandon
432 : * attempting to print the error statement (which, if long, could
433 : * itself be the source of the recursive failure).
434 : */
435 0 : if (in_error_recursion_trouble())
436 : {
437 0 : error_context_stack = NULL;
438 0 : debug_query_string = NULL;
439 : }
440 : }
441 :
442 : /* Initialize data for this error frame */
443 751312 : edata = get_error_stack_entry();
444 751312 : edata->elevel = elevel;
445 751312 : edata->output_to_server = output_to_server;
446 751312 : edata->output_to_client = output_to_client;
447 751312 : set_stack_entry_domain(edata, domain);
448 : /* Select default errcode based on elevel */
449 751312 : if (elevel >= ERROR)
450 50796 : edata->sqlerrcode = ERRCODE_INTERNAL_ERROR;
451 700516 : else if (elevel >= WARNING)
452 225980 : edata->sqlerrcode = ERRCODE_WARNING;
453 : else
454 474536 : edata->sqlerrcode = ERRCODE_SUCCESSFUL_COMPLETION;
455 :
456 : /*
457 : * Any allocations for this error state level should go into ErrorContext
458 : */
459 751312 : edata->assoc_context = ErrorContext;
460 :
461 751312 : recursion_depth--;
462 751312 : return true;
463 : }
464 :
465 : /*
466 : * errfinish --- end an error-reporting cycle
467 : *
468 : * Produce the appropriate error report(s) and pop the error stack.
469 : *
470 : * If elevel, as passed to errstart(), is ERROR or worse, control does not
471 : * return to the caller. See elog.h for the error level definitions.
472 : */
473 : void
474 751312 : errfinish(const char *filename, int lineno, const char *funcname)
475 : {
476 751312 : ErrorData *edata = &errordata[errordata_stack_depth];
477 : int elevel;
478 : MemoryContext oldcontext;
479 : ErrorContextCallback *econtext;
480 :
481 751312 : recursion_depth++;
482 751312 : CHECK_STACK_DEPTH();
483 :
484 : /* Save the last few bits of error state into the stack entry */
485 751312 : set_stack_entry_location(edata, filename, lineno, funcname);
486 :
487 751312 : elevel = edata->elevel;
488 :
489 : /*
490 : * Do processing in ErrorContext, which we hope has enough reserved space
491 : * to report an error.
492 : */
493 751312 : oldcontext = MemoryContextSwitchTo(ErrorContext);
494 :
495 : /* Collect backtrace, if enabled and we didn't already */
496 751312 : if (!edata->backtrace &&
497 751312 : edata->funcname &&
498 751312 : backtrace_functions &&
499 751312 : matches_backtrace_functions(edata->funcname))
500 0 : set_backtrace(edata, 2);
501 :
502 : /*
503 : * Call any context callback functions. Errors occurring in callback
504 : * functions will be treated as recursive errors --- this ensures we will
505 : * avoid infinite recursion (see errstart).
506 : */
507 889814 : for (econtext = error_context_stack;
508 : econtext != NULL;
509 138502 : econtext = econtext->previous)
510 138502 : econtext->callback(econtext->arg);
511 :
512 : /*
513 : * If ERROR (not more nor less) we pass it off to the current handler.
514 : * Printing it and popping the stack is the responsibility of the handler.
515 : */
516 751312 : if (elevel == ERROR)
517 : {
518 : /*
519 : * We do some minimal cleanup before longjmp'ing so that handlers can
520 : * execute in a reasonably sane state.
521 : *
522 : * Reset InterruptHoldoffCount in case we ereport'd from inside an
523 : * interrupt holdoff section. (We assume here that no handler will
524 : * itself be inside a holdoff section. If necessary, such a handler
525 : * could save and restore InterruptHoldoffCount for itself, but this
526 : * should make life easier for most.)
527 : */
528 49532 : InterruptHoldoffCount = 0;
529 49532 : QueryCancelHoldoffCount = 0;
530 :
531 49532 : CritSectionCount = 0; /* should be unnecessary, but... */
532 :
533 : /*
534 : * Note that we leave CurrentMemoryContext set to ErrorContext. The
535 : * handler should reset it to something else soon.
536 : */
537 :
538 49532 : recursion_depth--;
539 49532 : PG_RE_THROW();
540 : }
541 :
542 : /* Emit the message to the right places */
543 701780 : EmitErrorReport();
544 :
545 : /* Now free up subsidiary data attached to stack entry, and release it */
546 701780 : FreeErrorDataContents(edata);
547 701780 : errordata_stack_depth--;
548 :
549 : /* Exit error-handling context */
550 701780 : MemoryContextSwitchTo(oldcontext);
551 701780 : recursion_depth--;
552 :
553 : /*
554 : * Perform error recovery action as specified by elevel.
555 : */
556 701780 : if (elevel == FATAL)
557 : {
558 : /*
559 : * For a FATAL error, we let proc_exit clean up and exit.
560 : *
561 : * If we just reported a startup failure, the client will disconnect
562 : * on receiving it, so don't send any more to the client.
563 : */
564 1264 : if (PG_exception_stack == NULL && whereToSendOutput == DestRemote)
565 396 : whereToSendOutput = DestNone;
566 :
567 : /*
568 : * fflush here is just to improve the odds that we get to see the
569 : * error message, in case things are so hosed that proc_exit crashes.
570 : * Any other code you might be tempted to add here should probably be
571 : * in an on_proc_exit or on_shmem_exit callback instead.
572 : */
573 1264 : fflush(NULL);
574 :
575 : /*
576 : * Let the cumulative stats system know. Only mark the session as
577 : * terminated by fatal error if there is no other known cause.
578 : */
579 1264 : if (pgStatSessionEndCause == DISCONNECT_NORMAL)
580 850 : pgStatSessionEndCause = DISCONNECT_FATAL;
581 :
582 : /*
583 : * Do normal process-exit cleanup, then return exit code 1 to indicate
584 : * FATAL termination. The postmaster may or may not consider this
585 : * worthy of panic, depending on which subprocess returns it.
586 : */
587 1264 : proc_exit(1);
588 : }
589 :
590 700516 : if (elevel >= PANIC)
591 : {
592 : /*
593 : * Serious crash time. Postmaster will observe SIGABRT process exit
594 : * status and kill the other backends too.
595 : *
596 : * XXX: what if we are *in* the postmaster? abort() won't kill our
597 : * children...
598 : */
599 0 : fflush(NULL);
600 0 : abort();
601 : }
602 :
603 : /*
604 : * Check for cancel/die interrupt first --- this is so that the user can
605 : * stop a query emitting tons of notice or warning messages, even if it's
606 : * in a loop that otherwise fails to check for interrupts.
607 : */
608 700516 : CHECK_FOR_INTERRUPTS();
609 700516 : }
610 :
611 :
612 : /*
613 : * errsave_start --- begin a "soft" error-reporting cycle
614 : *
615 : * If "context" isn't an ErrorSaveContext node, this behaves as
616 : * errstart(ERROR, domain), and the errsave() macro ends up acting
617 : * exactly like ereport(ERROR, ...).
618 : *
619 : * If "context" is an ErrorSaveContext node, but the node creator only wants
620 : * notification of the fact of a soft error without any details, we just set
621 : * the error_occurred flag in the ErrorSaveContext node and return false,
622 : * which will cause us to skip the remaining error processing steps.
623 : *
624 : * Otherwise, create and initialize error stack entry and return true.
625 : * Subsequently, errmsg() and perhaps other routines will be called to further
626 : * populate the stack entry. Finally, errsave_finish() will be called to
627 : * tidy up.
628 : */
629 : bool
630 51986 : errsave_start(struct Node *context, const char *domain)
631 : {
632 : ErrorSaveContext *escontext;
633 : ErrorData *edata;
634 :
635 : /*
636 : * Do we have a context for soft error reporting? If not, just punt to
637 : * errstart().
638 : */
639 51986 : if (context == NULL || !IsA(context, ErrorSaveContext))
640 6436 : return errstart(ERROR, domain);
641 :
642 : /* Report that a soft error was detected */
643 45550 : escontext = (ErrorSaveContext *) context;
644 45550 : escontext->error_occurred = true;
645 :
646 : /* Nothing else to do if caller wants no further details */
647 45550 : if (!escontext->details_wanted)
648 44756 : return false;
649 :
650 : /*
651 : * Okay, crank up a stack entry to store the info in.
652 : */
653 :
654 794 : recursion_depth++;
655 :
656 : /* Initialize data for this error frame */
657 794 : edata = get_error_stack_entry();
658 794 : edata->elevel = LOG; /* signal all is well to errsave_finish */
659 794 : set_stack_entry_domain(edata, domain);
660 : /* Select default errcode based on the assumed elevel of ERROR */
661 794 : edata->sqlerrcode = ERRCODE_INTERNAL_ERROR;
662 :
663 : /*
664 : * Any allocations for this error state level should go into the caller's
665 : * context. We don't need to pollute ErrorContext, or even require it to
666 : * exist, in this code path.
667 : */
668 794 : edata->assoc_context = CurrentMemoryContext;
669 :
670 794 : recursion_depth--;
671 794 : return true;
672 : }
673 :
674 : /*
675 : * errsave_finish --- end a "soft" error-reporting cycle
676 : *
677 : * If errsave_start() decided this was a regular error, behave as
678 : * errfinish(). Otherwise, package up the error details and save
679 : * them in the ErrorSaveContext node.
680 : */
681 : void
682 7230 : errsave_finish(struct Node *context, const char *filename, int lineno,
683 : const char *funcname)
684 : {
685 7230 : ErrorSaveContext *escontext = (ErrorSaveContext *) context;
686 7230 : ErrorData *edata = &errordata[errordata_stack_depth];
687 :
688 : /* verify stack depth before accessing *edata */
689 7230 : CHECK_STACK_DEPTH();
690 :
691 : /*
692 : * If errsave_start punted to errstart, then elevel will be ERROR or
693 : * perhaps even PANIC. Punt likewise to errfinish.
694 : */
695 7230 : if (edata->elevel >= ERROR)
696 : {
697 6436 : errfinish(filename, lineno, funcname);
698 0 : pg_unreachable();
699 : }
700 :
701 : /*
702 : * Else, we should package up the stack entry contents and deliver them to
703 : * the caller.
704 : */
705 794 : recursion_depth++;
706 :
707 : /* Save the last few bits of error state into the stack entry */
708 794 : set_stack_entry_location(edata, filename, lineno, funcname);
709 :
710 : /* Replace the LOG value that errsave_start inserted */
711 794 : edata->elevel = ERROR;
712 :
713 : /*
714 : * We skip calling backtrace and context functions, which are more likely
715 : * to cause trouble than provide useful context; they might act on the
716 : * assumption that a transaction abort is about to occur.
717 : */
718 :
719 : /*
720 : * Make a copy of the error info for the caller. All the subsidiary
721 : * strings are already in the caller's context, so it's sufficient to
722 : * flat-copy the stack entry.
723 : */
724 794 : escontext->error_data = palloc_object(ErrorData);
725 794 : memcpy(escontext->error_data, edata, sizeof(ErrorData));
726 :
727 : /* Exit error-handling context */
728 794 : errordata_stack_depth--;
729 794 : recursion_depth--;
730 794 : }
731 :
732 :
733 : /*
734 : * get_error_stack_entry --- allocate and initialize a new stack entry
735 : *
736 : * The entry should be freed, when we're done with it, by calling
737 : * FreeErrorDataContents() and then decrementing errordata_stack_depth.
738 : *
739 : * Returning the entry's address is just a notational convenience,
740 : * since it had better be errordata[errordata_stack_depth].
741 : *
742 : * Although the error stack is not large, we don't expect to run out of space.
743 : * Using more than one entry implies a new error report during error recovery,
744 : * which is possible but already suggests we're in trouble. If we exhaust the
745 : * stack, almost certainly we are in an infinite loop of errors during error
746 : * recovery, so we give up and PANIC.
747 : *
748 : * (Note that this is distinct from the recursion_depth checks, which
749 : * guard against recursion while handling a single stack entry.)
750 : */
751 : static ErrorData *
752 752218 : get_error_stack_entry(void)
753 : {
754 : ErrorData *edata;
755 :
756 : /* Allocate error frame */
757 752218 : errordata_stack_depth++;
758 752218 : if (unlikely(errordata_stack_depth >= ERRORDATA_STACK_SIZE))
759 : {
760 : /* Wups, stack not big enough */
761 0 : errordata_stack_depth = -1; /* make room on stack */
762 0 : ereport(PANIC, (errmsg_internal("ERRORDATA_STACK_SIZE exceeded")));
763 : }
764 :
765 : /* Initialize error frame to all zeroes/NULLs */
766 752218 : edata = &errordata[errordata_stack_depth];
767 752218 : memset(edata, 0, sizeof(ErrorData));
768 :
769 : /* Save errno immediately to ensure error parameter eval can't change it */
770 752218 : edata->saved_errno = errno;
771 :
772 752218 : return edata;
773 : }
774 :
775 : /*
776 : * set_stack_entry_domain --- fill in the internationalization domain
777 : */
778 : static void
779 752106 : set_stack_entry_domain(ErrorData *edata, const char *domain)
780 : {
781 : /* the default text domain is the backend's */
782 752106 : edata->domain = domain ? domain : PG_TEXTDOMAIN("postgres");
783 : /* initialize context_domain the same way (see set_errcontext_domain()) */
784 752106 : edata->context_domain = edata->domain;
785 752106 : }
786 :
787 : /*
788 : * set_stack_entry_location --- fill in code-location details
789 : *
790 : * Store the values of __FILE__, __LINE__, and __func__ from the call site.
791 : * We make an effort to normalize __FILE__, since compilers are inconsistent
792 : * about how much of the path they'll include, and we'd prefer that the
793 : * behavior not depend on that (especially, that it not vary with build path).
794 : */
795 : static void
796 752106 : set_stack_entry_location(ErrorData *edata,
797 : const char *filename, int lineno,
798 : const char *funcname)
799 : {
800 752106 : if (filename)
801 : {
802 : const char *slash;
803 :
804 : /* keep only base name, useful especially for vpath builds */
805 752106 : slash = strrchr(filename, '/');
806 752106 : if (slash)
807 0 : filename = slash + 1;
808 : /* Some Windows compilers use backslashes in __FILE__ strings */
809 752106 : slash = strrchr(filename, '\\');
810 752106 : if (slash)
811 0 : filename = slash + 1;
812 : }
813 :
814 752106 : edata->filename = filename;
815 752106 : edata->lineno = lineno;
816 752106 : edata->funcname = funcname;
817 752106 : }
818 :
819 : /*
820 : * matches_backtrace_functions --- checks whether the given funcname matches
821 : * backtrace_functions
822 : *
823 : * See check_backtrace_functions.
824 : */
825 : static bool
826 751312 : matches_backtrace_functions(const char *funcname)
827 : {
828 : const char *p;
829 :
830 751312 : if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
831 751312 : return false;
832 :
833 0 : p = backtrace_function_list;
834 : for (;;)
835 : {
836 0 : if (*p == '\0') /* end of backtrace_function_list */
837 0 : break;
838 :
839 0 : if (strcmp(funcname, p) == 0)
840 0 : return true;
841 0 : p += strlen(p) + 1;
842 : }
843 :
844 0 : return false;
845 : }
846 :
847 :
848 : /*
849 : * errcode --- add SQLSTATE error code to the current error
850 : *
851 : * The code is expected to be represented as per MAKE_SQLSTATE().
852 : */
853 : int
854 54716 : errcode(int sqlerrcode)
855 : {
856 54716 : ErrorData *edata = &errordata[errordata_stack_depth];
857 :
858 : /* we don't bother incrementing recursion_depth */
859 54716 : CHECK_STACK_DEPTH();
860 :
861 54716 : edata->sqlerrcode = sqlerrcode;
862 :
863 54716 : return 0; /* return value does not matter */
864 : }
865 :
866 :
867 : /*
868 : * errcode_for_file_access --- add SQLSTATE error code to the current error
869 : *
870 : * The SQLSTATE code is chosen based on the saved errno value. We assume
871 : * that the failing operation was some type of disk file access.
872 : *
873 : * NOTE: the primary error message string should generally include %m
874 : * when this is used.
875 : */
876 : int
877 154 : errcode_for_file_access(void)
878 : {
879 154 : ErrorData *edata = &errordata[errordata_stack_depth];
880 :
881 : /* we don't bother incrementing recursion_depth */
882 154 : CHECK_STACK_DEPTH();
883 :
884 154 : switch (edata->saved_errno)
885 : {
886 : /* Permission-denied failures */
887 8 : case EPERM: /* Not super-user */
888 : case EACCES: /* Permission denied */
889 : #ifdef EROFS
890 : case EROFS: /* Read only file system */
891 : #endif
892 8 : edata->sqlerrcode = ERRCODE_INSUFFICIENT_PRIVILEGE;
893 8 : break;
894 :
895 : /* File not found */
896 102 : case ENOENT: /* No such file or directory */
897 102 : edata->sqlerrcode = ERRCODE_UNDEFINED_FILE;
898 102 : break;
899 :
900 : /* Duplicate file */
901 0 : case EEXIST: /* File exists */
902 0 : edata->sqlerrcode = ERRCODE_DUPLICATE_FILE;
903 0 : break;
904 :
905 : /* Wrong object type or state */
906 4 : case ENOTDIR: /* Not a directory */
907 : case EISDIR: /* Is a directory */
908 : case ENOTEMPTY: /* Directory not empty */
909 4 : edata->sqlerrcode = ERRCODE_WRONG_OBJECT_TYPE;
910 4 : break;
911 :
912 : /* Insufficient resources */
913 0 : case ENOSPC: /* No space left on device */
914 0 : edata->sqlerrcode = ERRCODE_DISK_FULL;
915 0 : break;
916 :
917 0 : case ENOMEM: /* Out of memory */
918 0 : edata->sqlerrcode = ERRCODE_OUT_OF_MEMORY;
919 0 : break;
920 :
921 0 : case ENFILE: /* File table overflow */
922 : case EMFILE: /* Too many open files */
923 0 : edata->sqlerrcode = ERRCODE_INSUFFICIENT_RESOURCES;
924 0 : break;
925 :
926 : /* Hardware failure */
927 16 : case EIO: /* I/O error */
928 16 : edata->sqlerrcode = ERRCODE_IO_ERROR;
929 16 : break;
930 :
931 0 : case ENAMETOOLONG: /* File name too long */
932 0 : edata->sqlerrcode = ERRCODE_FILE_NAME_TOO_LONG;
933 0 : break;
934 :
935 : /* All else is classified as internal errors */
936 24 : default:
937 24 : edata->sqlerrcode = ERRCODE_INTERNAL_ERROR;
938 24 : break;
939 : }
940 :
941 154 : return 0; /* return value does not matter */
942 : }
943 :
944 : /*
945 : * errcode_for_socket_access --- add SQLSTATE error code to the current error
946 : *
947 : * The SQLSTATE code is chosen based on the saved errno value. We assume
948 : * that the failing operation was some type of socket access.
949 : *
950 : * NOTE: the primary error message string should generally include %m
951 : * when this is used.
952 : */
953 : int
954 84 : errcode_for_socket_access(void)
955 : {
956 84 : ErrorData *edata = &errordata[errordata_stack_depth];
957 :
958 : /* we don't bother incrementing recursion_depth */
959 84 : CHECK_STACK_DEPTH();
960 :
961 84 : switch (edata->saved_errno)
962 : {
963 : /* Loss of connection */
964 84 : case ALL_CONNECTION_FAILURE_ERRNOS:
965 84 : edata->sqlerrcode = ERRCODE_CONNECTION_FAILURE;
966 84 : break;
967 :
968 : /* All else is classified as internal errors */
969 0 : default:
970 0 : edata->sqlerrcode = ERRCODE_INTERNAL_ERROR;
971 0 : break;
972 : }
973 :
974 84 : return 0; /* return value does not matter */
975 : }
976 :
977 :
978 : /*
979 : * This macro handles expansion of a format string and associated parameters;
980 : * it's common code for errmsg(), errdetail(), etc. Must be called inside
981 : * a routine that is declared like "const char *fmt, ..." and has an edata
982 : * pointer set up. The message is assigned to edata->targetfield, or
983 : * appended to it if appendval is true. The message is subject to translation
984 : * if translateit is true.
985 : *
986 : * Note: we pstrdup the buffer rather than just transferring its storage
987 : * to the edata field because the buffer might be considerably larger than
988 : * really necessary.
989 : */
990 : #define EVALUATE_MESSAGE(domain, targetfield, appendval, translateit) \
991 : { \
992 : StringInfoData buf; \
993 : /* Internationalize the error format string */ \
994 : if ((translateit) && !in_error_recursion_trouble()) \
995 : fmt = dgettext((domain), fmt); \
996 : initStringInfo(&buf); \
997 : if ((appendval) && edata->targetfield) { \
998 : appendStringInfoString(&buf, edata->targetfield); \
999 : appendStringInfoChar(&buf, '\n'); \
1000 : } \
1001 : /* Generate actual output --- have to use appendStringInfoVA */ \
1002 : for (;;) \
1003 : { \
1004 : va_list args; \
1005 : int needed; \
1006 : errno = edata->saved_errno; \
1007 : va_start(args, fmt); \
1008 : needed = appendStringInfoVA(&buf, fmt, args); \
1009 : va_end(args); \
1010 : if (needed == 0) \
1011 : break; \
1012 : enlargeStringInfo(&buf, needed); \
1013 : } \
1014 : /* Save the completed message into the stack item */ \
1015 : if (edata->targetfield) \
1016 : pfree(edata->targetfield); \
1017 : edata->targetfield = pstrdup(buf.data); \
1018 : pfree(buf.data); \
1019 : }
1020 :
1021 : /*
1022 : * Same as above, except for pluralized error messages. The calling routine
1023 : * must be declared like "const char *fmt_singular, const char *fmt_plural,
1024 : * unsigned long n, ...". Translation is assumed always wanted.
1025 : */
1026 : #define EVALUATE_MESSAGE_PLURAL(domain, targetfield, appendval) \
1027 : { \
1028 : const char *fmt; \
1029 : StringInfoData buf; \
1030 : /* Internationalize the error format string */ \
1031 : if (!in_error_recursion_trouble()) \
1032 : fmt = dngettext((domain), fmt_singular, fmt_plural, n); \
1033 : else \
1034 : fmt = (n == 1 ? fmt_singular : fmt_plural); \
1035 : initStringInfo(&buf); \
1036 : if ((appendval) && edata->targetfield) { \
1037 : appendStringInfoString(&buf, edata->targetfield); \
1038 : appendStringInfoChar(&buf, '\n'); \
1039 : } \
1040 : /* Generate actual output --- have to use appendStringInfoVA */ \
1041 : for (;;) \
1042 : { \
1043 : va_list args; \
1044 : int needed; \
1045 : errno = edata->saved_errno; \
1046 : va_start(args, n); \
1047 : needed = appendStringInfoVA(&buf, fmt, args); \
1048 : va_end(args); \
1049 : if (needed == 0) \
1050 : break; \
1051 : enlargeStringInfo(&buf, needed); \
1052 : } \
1053 : /* Save the completed message into the stack item */ \
1054 : if (edata->targetfield) \
1055 : pfree(edata->targetfield); \
1056 : edata->targetfield = pstrdup(buf.data); \
1057 : pfree(buf.data); \
1058 : }
1059 :
1060 :
1061 : /*
1062 : * errmsg --- add a primary error message text to the current error
1063 : *
1064 : * In addition to the usual %-escapes recognized by printf, "%m" in
1065 : * fmt is replaced by the error message for the caller's value of errno.
1066 : *
1067 : * Note: no newline is needed at the end of the fmt string, since
1068 : * ereport will provide one for the output methods that need it.
1069 : */
1070 : int
1071 592788 : errmsg(const char *fmt,...)
1072 : {
1073 592788 : ErrorData *edata = &errordata[errordata_stack_depth];
1074 : MemoryContext oldcontext;
1075 :
1076 592788 : recursion_depth++;
1077 592788 : CHECK_STACK_DEPTH();
1078 592788 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1079 :
1080 592788 : edata->message_id = fmt;
1081 595006 : EVALUATE_MESSAGE(edata->domain, message, false, true);
1082 :
1083 592788 : MemoryContextSwitchTo(oldcontext);
1084 592788 : recursion_depth--;
1085 592788 : return 0; /* return value does not matter */
1086 : }
1087 :
1088 : /*
1089 : * Add a backtrace to the containing ereport() call. This is intended to be
1090 : * added temporarily during debugging.
1091 : */
1092 : int
1093 0 : errbacktrace(void)
1094 : {
1095 0 : ErrorData *edata = &errordata[errordata_stack_depth];
1096 : MemoryContext oldcontext;
1097 :
1098 0 : recursion_depth++;
1099 0 : CHECK_STACK_DEPTH();
1100 0 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1101 :
1102 0 : set_backtrace(edata, 1);
1103 :
1104 0 : MemoryContextSwitchTo(oldcontext);
1105 0 : recursion_depth--;
1106 :
1107 0 : return 0;
1108 : }
1109 :
1110 : /*
1111 : * Compute backtrace data and add it to the supplied ErrorData. num_skip
1112 : * specifies how many inner frames to skip. Use this to avoid showing the
1113 : * internal backtrace support functions in the backtrace. This requires that
1114 : * this and related functions are not inlined.
1115 : */
1116 : static void
1117 0 : set_backtrace(ErrorData *edata, int num_skip)
1118 : {
1119 : StringInfoData errtrace;
1120 :
1121 0 : initStringInfo(&errtrace);
1122 :
1123 : #ifdef HAVE_BACKTRACE_SYMBOLS
1124 : {
1125 : void *buf[100];
1126 : int nframes;
1127 : char **strfrms;
1128 :
1129 0 : nframes = backtrace(buf, lengthof(buf));
1130 0 : strfrms = backtrace_symbols(buf, nframes);
1131 0 : if (strfrms == NULL)
1132 0 : return;
1133 :
1134 0 : for (int i = num_skip; i < nframes; i++)
1135 0 : appendStringInfo(&errtrace, "\n%s", strfrms[i]);
1136 0 : free(strfrms);
1137 : }
1138 : #else
1139 : appendStringInfoString(&errtrace,
1140 : "backtrace generation is not supported by this installation");
1141 : #endif
1142 :
1143 0 : edata->backtrace = errtrace.data;
1144 : }
1145 :
1146 : /*
1147 : * errmsg_internal --- add a primary error message text to the current error
1148 : *
1149 : * This is exactly like errmsg() except that strings passed to errmsg_internal
1150 : * are not translated, and are customarily left out of the
1151 : * internationalization message dictionary. This should be used for "can't
1152 : * happen" cases that are probably not worth spending translation effort on.
1153 : * We also use this for certain cases where we *must* not try to translate
1154 : * the message because the translation would fail and result in infinite
1155 : * error recursion.
1156 : */
1157 : int
1158 158152 : errmsg_internal(const char *fmt,...)
1159 : {
1160 158152 : ErrorData *edata = &errordata[errordata_stack_depth];
1161 : MemoryContext oldcontext;
1162 :
1163 158152 : recursion_depth++;
1164 158152 : CHECK_STACK_DEPTH();
1165 158152 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1166 :
1167 158152 : edata->message_id = fmt;
1168 158204 : EVALUATE_MESSAGE(edata->domain, message, false, false);
1169 :
1170 158152 : MemoryContextSwitchTo(oldcontext);
1171 158152 : recursion_depth--;
1172 158152 : return 0; /* return value does not matter */
1173 : }
1174 :
1175 :
1176 : /*
1177 : * errmsg_plural --- add a primary error message text to the current error,
1178 : * with support for pluralization of the message text
1179 : */
1180 : int
1181 1148 : errmsg_plural(const char *fmt_singular, const char *fmt_plural,
1182 : unsigned long n,...)
1183 : {
1184 1148 : ErrorData *edata = &errordata[errordata_stack_depth];
1185 : MemoryContext oldcontext;
1186 :
1187 1148 : recursion_depth++;
1188 1148 : CHECK_STACK_DEPTH();
1189 1148 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1190 :
1191 1148 : edata->message_id = fmt_singular;
1192 1148 : EVALUATE_MESSAGE_PLURAL(edata->domain, message, false);
1193 :
1194 1148 : MemoryContextSwitchTo(oldcontext);
1195 1148 : recursion_depth--;
1196 1148 : return 0; /* return value does not matter */
1197 : }
1198 :
1199 :
1200 : /*
1201 : * errdetail --- add a detail error message text to the current error
1202 : */
1203 : int
1204 49146 : errdetail(const char *fmt,...)
1205 : {
1206 49146 : ErrorData *edata = &errordata[errordata_stack_depth];
1207 : MemoryContext oldcontext;
1208 :
1209 49146 : recursion_depth++;
1210 49146 : CHECK_STACK_DEPTH();
1211 49146 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1212 :
1213 49158 : EVALUATE_MESSAGE(edata->domain, detail, false, true);
1214 :
1215 49146 : MemoryContextSwitchTo(oldcontext);
1216 49146 : recursion_depth--;
1217 49146 : return 0; /* return value does not matter */
1218 : }
1219 :
1220 :
1221 : /*
1222 : * errdetail_internal --- add a detail error message text to the current error
1223 : *
1224 : * This is exactly like errdetail() except that strings passed to
1225 : * errdetail_internal are not translated, and are customarily left out of the
1226 : * internationalization message dictionary. This should be used for detail
1227 : * messages that seem not worth translating for one reason or another
1228 : * (typically, that they don't seem to be useful to average users).
1229 : */
1230 : int
1231 3138 : errdetail_internal(const char *fmt,...)
1232 : {
1233 3138 : ErrorData *edata = &errordata[errordata_stack_depth];
1234 : MemoryContext oldcontext;
1235 :
1236 3138 : recursion_depth++;
1237 3138 : CHECK_STACK_DEPTH();
1238 3138 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1239 :
1240 3176 : EVALUATE_MESSAGE(edata->domain, detail, false, false);
1241 :
1242 3138 : MemoryContextSwitchTo(oldcontext);
1243 3138 : recursion_depth--;
1244 3138 : return 0; /* return value does not matter */
1245 : }
1246 :
1247 :
1248 : /*
1249 : * errdetail_log --- add a detail_log error message text to the current error
1250 : */
1251 : int
1252 1198 : errdetail_log(const char *fmt,...)
1253 : {
1254 1198 : ErrorData *edata = &errordata[errordata_stack_depth];
1255 : MemoryContext oldcontext;
1256 :
1257 1198 : recursion_depth++;
1258 1198 : CHECK_STACK_DEPTH();
1259 1198 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1260 :
1261 1238 : EVALUATE_MESSAGE(edata->domain, detail_log, false, true);
1262 :
1263 1198 : MemoryContextSwitchTo(oldcontext);
1264 1198 : recursion_depth--;
1265 1198 : return 0; /* return value does not matter */
1266 : }
1267 :
1268 : /*
1269 : * errdetail_log_plural --- add a detail_log error message text to the current error
1270 : * with support for pluralization of the message text
1271 : */
1272 : int
1273 34 : errdetail_log_plural(const char *fmt_singular, const char *fmt_plural,
1274 : unsigned long n,...)
1275 : {
1276 34 : ErrorData *edata = &errordata[errordata_stack_depth];
1277 : MemoryContext oldcontext;
1278 :
1279 34 : recursion_depth++;
1280 34 : CHECK_STACK_DEPTH();
1281 34 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1282 :
1283 34 : EVALUATE_MESSAGE_PLURAL(edata->domain, detail_log, false);
1284 :
1285 34 : MemoryContextSwitchTo(oldcontext);
1286 34 : recursion_depth--;
1287 34 : return 0; /* return value does not matter */
1288 : }
1289 :
1290 :
1291 : /*
1292 : * errdetail_plural --- add a detail error message text to the current error,
1293 : * with support for pluralization of the message text
1294 : */
1295 : int
1296 58 : errdetail_plural(const char *fmt_singular, const char *fmt_plural,
1297 : unsigned long n,...)
1298 : {
1299 58 : ErrorData *edata = &errordata[errordata_stack_depth];
1300 : MemoryContext oldcontext;
1301 :
1302 58 : recursion_depth++;
1303 58 : CHECK_STACK_DEPTH();
1304 58 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1305 :
1306 58 : EVALUATE_MESSAGE_PLURAL(edata->domain, detail, false);
1307 :
1308 58 : MemoryContextSwitchTo(oldcontext);
1309 58 : recursion_depth--;
1310 58 : return 0; /* return value does not matter */
1311 : }
1312 :
1313 :
1314 : /*
1315 : * errhint --- add a hint error message text to the current error
1316 : */
1317 : int
1318 225256 : errhint(const char *fmt,...)
1319 : {
1320 225256 : ErrorData *edata = &errordata[errordata_stack_depth];
1321 : MemoryContext oldcontext;
1322 :
1323 225256 : recursion_depth++;
1324 225256 : CHECK_STACK_DEPTH();
1325 225256 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1326 :
1327 225256 : EVALUATE_MESSAGE(edata->domain, hint, false, true);
1328 :
1329 225256 : MemoryContextSwitchTo(oldcontext);
1330 225256 : recursion_depth--;
1331 225256 : return 0; /* return value does not matter */
1332 : }
1333 :
1334 : /*
1335 : * errhint_internal --- add a hint error message text to the current error
1336 : *
1337 : * Non-translated version of errhint(), see also errmsg_internal().
1338 : */
1339 : int
1340 64 : errhint_internal(const char *fmt,...)
1341 : {
1342 64 : ErrorData *edata = &errordata[errordata_stack_depth];
1343 : MemoryContext oldcontext;
1344 :
1345 64 : recursion_depth++;
1346 64 : CHECK_STACK_DEPTH();
1347 64 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1348 :
1349 64 : EVALUATE_MESSAGE(edata->domain, hint, false, false);
1350 :
1351 64 : MemoryContextSwitchTo(oldcontext);
1352 64 : recursion_depth--;
1353 64 : return 0; /* return value does not matter */
1354 : }
1355 :
1356 : /*
1357 : * errhint_plural --- add a hint error message text to the current error,
1358 : * with support for pluralization of the message text
1359 : */
1360 : int
1361 0 : errhint_plural(const char *fmt_singular, const char *fmt_plural,
1362 : unsigned long n,...)
1363 : {
1364 0 : ErrorData *edata = &errordata[errordata_stack_depth];
1365 : MemoryContext oldcontext;
1366 :
1367 0 : recursion_depth++;
1368 0 : CHECK_STACK_DEPTH();
1369 0 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1370 :
1371 0 : EVALUATE_MESSAGE_PLURAL(edata->domain, hint, false);
1372 :
1373 0 : MemoryContextSwitchTo(oldcontext);
1374 0 : recursion_depth--;
1375 0 : return 0; /* return value does not matter */
1376 : }
1377 :
1378 :
1379 : /*
1380 : * errcontext_msg --- add a context error message text to the current error
1381 : *
1382 : * Unlike other cases, multiple calls are allowed to build up a stack of
1383 : * context information. We assume earlier calls represent more-closely-nested
1384 : * states.
1385 : */
1386 : int
1387 42762 : errcontext_msg(const char *fmt,...)
1388 : {
1389 42762 : ErrorData *edata = &errordata[errordata_stack_depth];
1390 : MemoryContext oldcontext;
1391 :
1392 42762 : recursion_depth++;
1393 42762 : CHECK_STACK_DEPTH();
1394 42762 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1395 :
1396 85562 : EVALUATE_MESSAGE(edata->context_domain, context, true, true);
1397 :
1398 42762 : MemoryContextSwitchTo(oldcontext);
1399 42762 : recursion_depth--;
1400 42762 : return 0; /* return value does not matter */
1401 : }
1402 :
1403 : /*
1404 : * set_errcontext_domain --- set message domain to be used by errcontext()
1405 : *
1406 : * errcontext_msg() can be called from a different module than the original
1407 : * ereport(), so we cannot use the message domain passed in errstart() to
1408 : * translate it. Instead, each errcontext_msg() call should be preceded by
1409 : * a set_errcontext_domain() call to specify the domain. This is usually
1410 : * done transparently by the errcontext() macro.
1411 : */
1412 : int
1413 42762 : set_errcontext_domain(const char *domain)
1414 : {
1415 42762 : ErrorData *edata = &errordata[errordata_stack_depth];
1416 :
1417 : /* we don't bother incrementing recursion_depth */
1418 42762 : CHECK_STACK_DEPTH();
1419 :
1420 : /* the default text domain is the backend's */
1421 42762 : edata->context_domain = domain ? domain : PG_TEXTDOMAIN("postgres");
1422 :
1423 42762 : return 0; /* return value does not matter */
1424 : }
1425 :
1426 :
1427 : /*
1428 : * errhidestmt --- optionally suppress STATEMENT: field of log entry
1429 : *
1430 : * This should be called if the message text already includes the statement.
1431 : */
1432 : int
1433 287214 : errhidestmt(bool hide_stmt)
1434 : {
1435 287214 : ErrorData *edata = &errordata[errordata_stack_depth];
1436 :
1437 : /* we don't bother incrementing recursion_depth */
1438 287214 : CHECK_STACK_DEPTH();
1439 :
1440 287214 : edata->hide_stmt = hide_stmt;
1441 :
1442 287214 : return 0; /* return value does not matter */
1443 : }
1444 :
1445 : /*
1446 : * errhidecontext --- optionally suppress CONTEXT: field of log entry
1447 : *
1448 : * This should only be used for verbose debugging messages where the repeated
1449 : * inclusion of context would bloat the log volume too much.
1450 : */
1451 : int
1452 19770 : errhidecontext(bool hide_ctx)
1453 : {
1454 19770 : ErrorData *edata = &errordata[errordata_stack_depth];
1455 :
1456 : /* we don't bother incrementing recursion_depth */
1457 19770 : CHECK_STACK_DEPTH();
1458 :
1459 19770 : edata->hide_ctx = hide_ctx;
1460 :
1461 19770 : return 0; /* return value does not matter */
1462 : }
1463 :
1464 : /*
1465 : * errposition --- add cursor position to the current error
1466 : */
1467 : int
1468 11394 : errposition(int cursorpos)
1469 : {
1470 11394 : ErrorData *edata = &errordata[errordata_stack_depth];
1471 :
1472 : /* we don't bother incrementing recursion_depth */
1473 11394 : CHECK_STACK_DEPTH();
1474 :
1475 11394 : edata->cursorpos = cursorpos;
1476 :
1477 11394 : return 0; /* return value does not matter */
1478 : }
1479 :
1480 : /*
1481 : * internalerrposition --- add internal cursor position to the current error
1482 : */
1483 : int
1484 524 : internalerrposition(int cursorpos)
1485 : {
1486 524 : ErrorData *edata = &errordata[errordata_stack_depth];
1487 :
1488 : /* we don't bother incrementing recursion_depth */
1489 524 : CHECK_STACK_DEPTH();
1490 :
1491 524 : edata->internalpos = cursorpos;
1492 :
1493 524 : return 0; /* return value does not matter */
1494 : }
1495 :
1496 : /*
1497 : * internalerrquery --- add internal query text to the current error
1498 : *
1499 : * Can also pass NULL to drop the internal query text entry. This case
1500 : * is intended for use in error callback subroutines that are editorializing
1501 : * on the layout of the error report.
1502 : */
1503 : int
1504 506 : internalerrquery(const char *query)
1505 : {
1506 506 : ErrorData *edata = &errordata[errordata_stack_depth];
1507 :
1508 : /* we don't bother incrementing recursion_depth */
1509 506 : CHECK_STACK_DEPTH();
1510 :
1511 506 : if (edata->internalquery)
1512 : {
1513 172 : pfree(edata->internalquery);
1514 172 : edata->internalquery = NULL;
1515 : }
1516 :
1517 506 : if (query)
1518 304 : edata->internalquery = MemoryContextStrdup(edata->assoc_context, query);
1519 :
1520 506 : return 0; /* return value does not matter */
1521 : }
1522 :
1523 : /*
1524 : * err_generic_string -- used to set individual ErrorData string fields
1525 : * identified by PG_DIAG_xxx codes.
1526 : *
1527 : * This intentionally only supports fields that don't use localized strings,
1528 : * so that there are no translation considerations.
1529 : *
1530 : * Most potential callers should not use this directly, but instead prefer
1531 : * higher-level abstractions, such as errtablecol() (see relcache.c).
1532 : */
1533 : int
1534 12388 : err_generic_string(int field, const char *str)
1535 : {
1536 12388 : ErrorData *edata = &errordata[errordata_stack_depth];
1537 :
1538 : /* we don't bother incrementing recursion_depth */
1539 12388 : CHECK_STACK_DEPTH();
1540 :
1541 12388 : switch (field)
1542 : {
1543 4346 : case PG_DIAG_SCHEMA_NAME:
1544 4346 : set_errdata_field(edata->assoc_context, &edata->schema_name, str);
1545 4346 : break;
1546 3542 : case PG_DIAG_TABLE_NAME:
1547 3542 : set_errdata_field(edata->assoc_context, &edata->table_name, str);
1548 3542 : break;
1549 570 : case PG_DIAG_COLUMN_NAME:
1550 570 : set_errdata_field(edata->assoc_context, &edata->column_name, str);
1551 570 : break;
1552 838 : case PG_DIAG_DATATYPE_NAME:
1553 838 : set_errdata_field(edata->assoc_context, &edata->datatype_name, str);
1554 838 : break;
1555 3092 : case PG_DIAG_CONSTRAINT_NAME:
1556 3092 : set_errdata_field(edata->assoc_context, &edata->constraint_name, str);
1557 3092 : break;
1558 0 : default:
1559 0 : elog(ERROR, "unsupported ErrorData field id: %d", field);
1560 : break;
1561 : }
1562 :
1563 12388 : return 0; /* return value does not matter */
1564 : }
1565 :
1566 : /*
1567 : * set_errdata_field --- set an ErrorData string field
1568 : */
1569 : static void
1570 12388 : set_errdata_field(MemoryContextData *cxt, char **ptr, const char *str)
1571 : {
1572 : Assert(*ptr == NULL);
1573 12388 : *ptr = MemoryContextStrdup(cxt, str);
1574 12388 : }
1575 :
1576 : /*
1577 : * geterrcode --- return the currently set SQLSTATE error code
1578 : *
1579 : * This is only intended for use in error callback subroutines, since there
1580 : * is no other place outside elog.c where the concept is meaningful.
1581 : */
1582 : int
1583 5718 : geterrcode(void)
1584 : {
1585 5718 : ErrorData *edata = &errordata[errordata_stack_depth];
1586 :
1587 : /* we don't bother incrementing recursion_depth */
1588 5718 : CHECK_STACK_DEPTH();
1589 :
1590 5718 : return edata->sqlerrcode;
1591 : }
1592 :
1593 : /*
1594 : * geterrposition --- return the currently set error position (0 if none)
1595 : *
1596 : * This is only intended for use in error callback subroutines, since there
1597 : * is no other place outside elog.c where the concept is meaningful.
1598 : */
1599 : int
1600 14956 : geterrposition(void)
1601 : {
1602 14956 : ErrorData *edata = &errordata[errordata_stack_depth];
1603 :
1604 : /* we don't bother incrementing recursion_depth */
1605 14956 : CHECK_STACK_DEPTH();
1606 :
1607 14956 : return edata->cursorpos;
1608 : }
1609 :
1610 : /*
1611 : * getinternalerrposition --- same for internal error position
1612 : *
1613 : * This is only intended for use in error callback subroutines, since there
1614 : * is no other place outside elog.c where the concept is meaningful.
1615 : */
1616 : int
1617 260 : getinternalerrposition(void)
1618 : {
1619 260 : ErrorData *edata = &errordata[errordata_stack_depth];
1620 :
1621 : /* we don't bother incrementing recursion_depth */
1622 260 : CHECK_STACK_DEPTH();
1623 :
1624 260 : return edata->internalpos;
1625 : }
1626 :
1627 :
1628 : /*
1629 : * Functions to allow construction of error message strings separately from
1630 : * the ereport() call itself.
1631 : *
1632 : * The expected calling convention is
1633 : *
1634 : * pre_format_elog_string(errno, domain), var = format_elog_string(format,...)
1635 : *
1636 : * which can be hidden behind a macro such as GUC_check_errdetail(). We
1637 : * assume that any functions called in the arguments of format_elog_string()
1638 : * cannot result in re-entrant use of these functions --- otherwise the wrong
1639 : * text domain might be used, or the wrong errno substituted for %m. This is
1640 : * okay for the current usage with GUC check hooks, but might need further
1641 : * effort someday.
1642 : *
1643 : * The result of format_elog_string() is stored in ErrorContext, and will
1644 : * therefore survive until FlushErrorState() is called.
1645 : */
1646 : static int save_format_errnumber;
1647 : static const char *save_format_domain;
1648 :
1649 : void
1650 54 : pre_format_elog_string(int errnumber, const char *domain)
1651 : {
1652 : /* Save errno before evaluation of argument functions can change it */
1653 54 : save_format_errnumber = errnumber;
1654 : /* Save caller's text domain */
1655 54 : save_format_domain = domain;
1656 54 : }
1657 :
1658 : char *
1659 54 : format_elog_string(const char *fmt,...)
1660 : {
1661 : ErrorData errdata;
1662 : ErrorData *edata;
1663 : MemoryContext oldcontext;
1664 :
1665 : /* Initialize a mostly-dummy error frame */
1666 54 : edata = &errdata;
1667 1296 : MemSet(edata, 0, sizeof(ErrorData));
1668 : /* the default text domain is the backend's */
1669 54 : edata->domain = save_format_domain ? save_format_domain : PG_TEXTDOMAIN("postgres");
1670 : /* set the errno to be used to interpret %m */
1671 54 : edata->saved_errno = save_format_errnumber;
1672 :
1673 54 : oldcontext = MemoryContextSwitchTo(ErrorContext);
1674 :
1675 54 : edata->message_id = fmt;
1676 54 : EVALUATE_MESSAGE(edata->domain, message, false, true);
1677 :
1678 54 : MemoryContextSwitchTo(oldcontext);
1679 :
1680 54 : return edata->message;
1681 : }
1682 :
1683 :
1684 : /*
1685 : * Actual output of the top-of-stack error message
1686 : *
1687 : * In the ereport(ERROR) case this is called from PostgresMain (or not at all,
1688 : * if the error is caught by somebody). For all other severity levels this
1689 : * is called by errfinish.
1690 : */
1691 : void
1692 745002 : EmitErrorReport(void)
1693 : {
1694 745002 : ErrorData *edata = &errordata[errordata_stack_depth];
1695 : MemoryContext oldcontext;
1696 :
1697 745002 : recursion_depth++;
1698 745002 : CHECK_STACK_DEPTH();
1699 745002 : oldcontext = MemoryContextSwitchTo(edata->assoc_context);
1700 :
1701 : /*
1702 : * Reset the formatted timestamp fields before emitting any logs. This
1703 : * includes all the log destinations and emit_log_hook, as the latter
1704 : * could use log_line_prefix or the formatted timestamps.
1705 : */
1706 745002 : saved_timeval_set = false;
1707 745002 : formatted_log_time[0] = '\0';
1708 :
1709 : /*
1710 : * Call hook before sending message to log. The hook function is allowed
1711 : * to turn off edata->output_to_server, so we must recheck that afterward.
1712 : * Making any other change in the content of edata is not considered
1713 : * supported.
1714 : *
1715 : * Note: the reason why the hook can only turn off output_to_server, and
1716 : * not turn it on, is that it'd be unreliable: we will never get here at
1717 : * all if errstart() deems the message uninteresting. A hook that could
1718 : * make decisions in that direction would have to hook into errstart(),
1719 : * where it would have much less information available. emit_log_hook is
1720 : * intended for custom log filtering and custom log message transmission
1721 : * mechanisms.
1722 : *
1723 : * The log hook has access to both the translated and original English
1724 : * error message text, which is passed through to allow it to be used as a
1725 : * message identifier. Note that the original text is not available for
1726 : * detail, detail_log, hint and context text elements.
1727 : */
1728 745002 : if (edata->output_to_server && emit_log_hook)
1729 0 : (*emit_log_hook) (edata);
1730 :
1731 : /* Send to server log, if enabled */
1732 745002 : if (edata->output_to_server)
1733 721890 : send_message_to_server_log(edata);
1734 :
1735 : /* Send to client, if enabled */
1736 745002 : if (edata->output_to_client)
1737 199824 : send_message_to_frontend(edata);
1738 :
1739 745002 : MemoryContextSwitchTo(oldcontext);
1740 745002 : recursion_depth--;
1741 745002 : }
1742 :
1743 : /*
1744 : * CopyErrorData --- obtain a copy of the topmost error stack entry
1745 : *
1746 : * This is only for use in error handler code. The data is copied into the
1747 : * current memory context, so callers should always switch away from
1748 : * ErrorContext first; otherwise it will be lost when FlushErrorState is done.
1749 : */
1750 : ErrorData *
1751 6376 : CopyErrorData(void)
1752 : {
1753 6376 : ErrorData *edata = &errordata[errordata_stack_depth];
1754 : ErrorData *newedata;
1755 :
1756 : /*
1757 : * we don't increment recursion_depth because out-of-memory here does not
1758 : * indicate a problem within the error subsystem.
1759 : */
1760 6376 : CHECK_STACK_DEPTH();
1761 :
1762 : Assert(CurrentMemoryContext != ErrorContext);
1763 :
1764 : /* Copy the struct itself */
1765 6376 : newedata = (ErrorData *) palloc(sizeof(ErrorData));
1766 6376 : memcpy(newedata, edata, sizeof(ErrorData));
1767 :
1768 : /*
1769 : * Make copies of separately-allocated strings. Note that we copy even
1770 : * theoretically-constant strings such as filename. This is because those
1771 : * could point into JIT-created code segments that might get unloaded at
1772 : * transaction cleanup. In some cases we need the copied ErrorData to
1773 : * survive transaction boundaries, so we'd better copy those strings too.
1774 : */
1775 6376 : if (newedata->filename)
1776 6376 : newedata->filename = pstrdup(newedata->filename);
1777 6376 : if (newedata->funcname)
1778 6376 : newedata->funcname = pstrdup(newedata->funcname);
1779 6376 : if (newedata->domain)
1780 6376 : newedata->domain = pstrdup(newedata->domain);
1781 6376 : if (newedata->context_domain)
1782 6376 : newedata->context_domain = pstrdup(newedata->context_domain);
1783 6376 : if (newedata->message)
1784 6376 : newedata->message = pstrdup(newedata->message);
1785 6376 : if (newedata->detail)
1786 166 : newedata->detail = pstrdup(newedata->detail);
1787 6376 : if (newedata->detail_log)
1788 0 : newedata->detail_log = pstrdup(newedata->detail_log);
1789 6376 : if (newedata->hint)
1790 54 : newedata->hint = pstrdup(newedata->hint);
1791 6376 : if (newedata->context)
1792 6338 : newedata->context = pstrdup(newedata->context);
1793 6376 : if (newedata->backtrace)
1794 0 : newedata->backtrace = pstrdup(newedata->backtrace);
1795 6376 : if (newedata->message_id)
1796 6376 : newedata->message_id = pstrdup(newedata->message_id);
1797 6376 : if (newedata->schema_name)
1798 56 : newedata->schema_name = pstrdup(newedata->schema_name);
1799 6376 : if (newedata->table_name)
1800 60 : newedata->table_name = pstrdup(newedata->table_name);
1801 6376 : if (newedata->column_name)
1802 18 : newedata->column_name = pstrdup(newedata->column_name);
1803 6376 : if (newedata->datatype_name)
1804 20 : newedata->datatype_name = pstrdup(newedata->datatype_name);
1805 6376 : if (newedata->constraint_name)
1806 54 : newedata->constraint_name = pstrdup(newedata->constraint_name);
1807 6376 : if (newedata->internalquery)
1808 34 : newedata->internalquery = pstrdup(newedata->internalquery);
1809 :
1810 : /* Use the calling context for string allocation */
1811 6376 : newedata->assoc_context = CurrentMemoryContext;
1812 :
1813 6376 : return newedata;
1814 : }
1815 :
1816 : /*
1817 : * FreeErrorData --- free the structure returned by CopyErrorData.
1818 : *
1819 : * Error handlers should use this in preference to assuming they know all
1820 : * the separately-allocated fields.
1821 : */
1822 : void
1823 142 : FreeErrorData(ErrorData *edata)
1824 : {
1825 142 : FreeErrorDataContents(edata);
1826 142 : pfree(edata);
1827 142 : }
1828 :
1829 : /*
1830 : * FreeErrorDataContents --- free the subsidiary data of an ErrorData.
1831 : *
1832 : * This can be used on either an error stack entry or a copied ErrorData.
1833 : */
1834 : static void
1835 701922 : FreeErrorDataContents(ErrorData *edata)
1836 : {
1837 701922 : if (edata->message)
1838 701922 : pfree(edata->message);
1839 701922 : if (edata->detail)
1840 42426 : pfree(edata->detail);
1841 701922 : if (edata->detail_log)
1842 776 : pfree(edata->detail_log);
1843 701922 : if (edata->hint)
1844 221018 : pfree(edata->hint);
1845 701922 : if (edata->context)
1846 18392 : pfree(edata->context);
1847 701922 : if (edata->backtrace)
1848 0 : pfree(edata->backtrace);
1849 701922 : if (edata->schema_name)
1850 38 : pfree(edata->schema_name);
1851 701922 : if (edata->table_name)
1852 42 : pfree(edata->table_name);
1853 701922 : if (edata->column_name)
1854 12 : pfree(edata->column_name);
1855 701922 : if (edata->datatype_name)
1856 14 : pfree(edata->datatype_name);
1857 701922 : if (edata->constraint_name)
1858 24 : pfree(edata->constraint_name);
1859 701922 : if (edata->internalquery)
1860 34 : pfree(edata->internalquery);
1861 701922 : }
1862 :
1863 : /*
1864 : * FlushErrorState --- flush the error state after error recovery
1865 : *
1866 : * This should be called by an error handler after it's done processing
1867 : * the error; or as soon as it's done CopyErrorData, if it intends to
1868 : * do stuff that is likely to provoke another error. You are not "out" of
1869 : * the error subsystem until you have done this.
1870 : */
1871 : void
1872 49398 : FlushErrorState(void)
1873 : {
1874 : /*
1875 : * Reset stack to empty. The only case where it would be more than one
1876 : * deep is if we serviced an error that interrupted construction of
1877 : * another message. We assume control escaped out of that message
1878 : * construction and won't ever go back.
1879 : */
1880 49398 : errordata_stack_depth = -1;
1881 49398 : recursion_depth = 0;
1882 : /* Delete all data in ErrorContext */
1883 49398 : MemoryContextReset(ErrorContext);
1884 49398 : }
1885 :
1886 : /*
1887 : * ThrowErrorData --- report an error described by an ErrorData structure
1888 : *
1889 : * This function should be called on an ErrorData structure that isn't stored
1890 : * on the errordata stack and hasn't been processed yet. It will call
1891 : * errstart() and errfinish() as needed, so those should not have already been
1892 : * called.
1893 : *
1894 : * ThrowErrorData() is useful for handling soft errors. It's also useful for
1895 : * re-reporting errors originally reported by background worker processes and
1896 : * then propagated (with or without modification) to the backend responsible
1897 : * for them.
1898 : */
1899 : void
1900 18 : ThrowErrorData(ErrorData *edata)
1901 : {
1902 : ErrorData *newedata;
1903 : MemoryContext oldcontext;
1904 :
1905 18 : if (!errstart(edata->elevel, edata->domain))
1906 0 : return; /* error is not to be reported at all */
1907 :
1908 18 : newedata = &errordata[errordata_stack_depth];
1909 18 : recursion_depth++;
1910 18 : oldcontext = MemoryContextSwitchTo(newedata->assoc_context);
1911 :
1912 : /* Copy the supplied fields to the error stack entry. */
1913 18 : if (edata->sqlerrcode != 0)
1914 18 : newedata->sqlerrcode = edata->sqlerrcode;
1915 18 : if (edata->message)
1916 18 : newedata->message = pstrdup(edata->message);
1917 18 : if (edata->detail)
1918 0 : newedata->detail = pstrdup(edata->detail);
1919 18 : if (edata->detail_log)
1920 0 : newedata->detail_log = pstrdup(edata->detail_log);
1921 18 : if (edata->hint)
1922 0 : newedata->hint = pstrdup(edata->hint);
1923 18 : if (edata->context)
1924 12 : newedata->context = pstrdup(edata->context);
1925 18 : if (edata->backtrace)
1926 0 : newedata->backtrace = pstrdup(edata->backtrace);
1927 : /* assume message_id is not available */
1928 18 : if (edata->schema_name)
1929 0 : newedata->schema_name = pstrdup(edata->schema_name);
1930 18 : if (edata->table_name)
1931 0 : newedata->table_name = pstrdup(edata->table_name);
1932 18 : if (edata->column_name)
1933 0 : newedata->column_name = pstrdup(edata->column_name);
1934 18 : if (edata->datatype_name)
1935 0 : newedata->datatype_name = pstrdup(edata->datatype_name);
1936 18 : if (edata->constraint_name)
1937 0 : newedata->constraint_name = pstrdup(edata->constraint_name);
1938 18 : newedata->cursorpos = edata->cursorpos;
1939 18 : newedata->internalpos = edata->internalpos;
1940 18 : if (edata->internalquery)
1941 0 : newedata->internalquery = pstrdup(edata->internalquery);
1942 :
1943 18 : MemoryContextSwitchTo(oldcontext);
1944 18 : recursion_depth--;
1945 :
1946 : /* Process the error. */
1947 18 : errfinish(edata->filename, edata->lineno, edata->funcname);
1948 : }
1949 :
1950 : /*
1951 : * ReThrowError --- re-throw a previously copied error
1952 : *
1953 : * A handler can do CopyErrorData/FlushErrorState to get out of the error
1954 : * subsystem, then do some processing, and finally ReThrowError to re-throw
1955 : * the original error. This is slower than just PG_RE_THROW() but should
1956 : * be used if the "some processing" is likely to incur another error.
1957 : */
1958 : void
1959 64 : ReThrowError(ErrorData *edata)
1960 : {
1961 : ErrorData *newedata;
1962 :
1963 : Assert(edata->elevel == ERROR);
1964 :
1965 : /* Push the data back into the error context */
1966 64 : recursion_depth++;
1967 64 : MemoryContextSwitchTo(ErrorContext);
1968 :
1969 64 : newedata = get_error_stack_entry();
1970 64 : memcpy(newedata, edata, sizeof(ErrorData));
1971 :
1972 : /* Make copies of separately-allocated fields */
1973 64 : if (newedata->message)
1974 64 : newedata->message = pstrdup(newedata->message);
1975 64 : if (newedata->detail)
1976 38 : newedata->detail = pstrdup(newedata->detail);
1977 64 : if (newedata->detail_log)
1978 0 : newedata->detail_log = pstrdup(newedata->detail_log);
1979 64 : if (newedata->hint)
1980 0 : newedata->hint = pstrdup(newedata->hint);
1981 64 : if (newedata->context)
1982 60 : newedata->context = pstrdup(newedata->context);
1983 64 : if (newedata->backtrace)
1984 0 : newedata->backtrace = pstrdup(newedata->backtrace);
1985 64 : if (newedata->schema_name)
1986 14 : newedata->schema_name = pstrdup(newedata->schema_name);
1987 64 : if (newedata->table_name)
1988 14 : newedata->table_name = pstrdup(newedata->table_name);
1989 64 : if (newedata->column_name)
1990 0 : newedata->column_name = pstrdup(newedata->column_name);
1991 64 : if (newedata->datatype_name)
1992 0 : newedata->datatype_name = pstrdup(newedata->datatype_name);
1993 64 : if (newedata->constraint_name)
1994 14 : newedata->constraint_name = pstrdup(newedata->constraint_name);
1995 64 : if (newedata->internalquery)
1996 0 : newedata->internalquery = pstrdup(newedata->internalquery);
1997 :
1998 : /* Reset the assoc_context to be ErrorContext */
1999 64 : newedata->assoc_context = ErrorContext;
2000 :
2001 64 : recursion_depth--;
2002 64 : PG_RE_THROW();
2003 : }
2004 :
2005 : /*
2006 : * pg_re_throw --- out-of-line implementation of PG_RE_THROW() macro
2007 : */
2008 : void
2009 108998 : pg_re_throw(void)
2010 : {
2011 : /* If possible, throw the error to the next outer setjmp handler */
2012 108998 : if (PG_exception_stack != NULL)
2013 108998 : siglongjmp(*PG_exception_stack, 1);
2014 : else
2015 : {
2016 : /*
2017 : * If we get here, elog(ERROR) was thrown inside a PG_TRY block, which
2018 : * we have now exited only to discover that there is no outer setjmp
2019 : * handler to pass the error to. Had the error been thrown outside
2020 : * the block to begin with, we'd have promoted the error to FATAL, so
2021 : * the correct behavior is to make it FATAL now; that is, emit it and
2022 : * then call proc_exit.
2023 : */
2024 0 : ErrorData *edata = &errordata[errordata_stack_depth];
2025 :
2026 : Assert(errordata_stack_depth >= 0);
2027 : Assert(edata->elevel == ERROR);
2028 0 : edata->elevel = FATAL;
2029 :
2030 : /*
2031 : * At least in principle, the increase in severity could have changed
2032 : * where-to-output decisions, so recalculate.
2033 : */
2034 0 : edata->output_to_server = should_output_to_server(FATAL);
2035 0 : edata->output_to_client = should_output_to_client(FATAL);
2036 :
2037 : /*
2038 : * We can use errfinish() for the rest, but we don't want it to call
2039 : * any error context routines a second time. Since we know we are
2040 : * about to exit, it should be OK to just clear the context stack.
2041 : */
2042 0 : error_context_stack = NULL;
2043 :
2044 0 : errfinish(edata->filename, edata->lineno, edata->funcname);
2045 : }
2046 :
2047 : /* Doesn't return ... */
2048 0 : ExceptionalCondition("pg_re_throw tried to return", __FILE__, __LINE__);
2049 : }
2050 :
2051 :
2052 : /*
2053 : * GetErrorContextStack - Return the context stack, for display/diags
2054 : *
2055 : * Returns a pstrdup'd string in the caller's context which includes the PG
2056 : * error call stack. It is the caller's responsibility to ensure this string
2057 : * is pfree'd (or its context cleaned up) when done.
2058 : *
2059 : * This information is collected by traversing the error contexts and calling
2060 : * each context's callback function, each of which is expected to call
2061 : * errcontext() to return a string which can be presented to the user.
2062 : */
2063 : char *
2064 48 : GetErrorContextStack(void)
2065 : {
2066 : ErrorData *edata;
2067 : ErrorContextCallback *econtext;
2068 :
2069 : /*
2070 : * Crank up a stack entry to store the info in.
2071 : */
2072 48 : recursion_depth++;
2073 :
2074 48 : edata = get_error_stack_entry();
2075 :
2076 : /*
2077 : * Set up assoc_context to be the caller's context, so any allocations
2078 : * done (which will include edata->context) will use their context.
2079 : */
2080 48 : edata->assoc_context = CurrentMemoryContext;
2081 :
2082 : /*
2083 : * Call any context callback functions to collect the context information
2084 : * into edata->context.
2085 : *
2086 : * Errors occurring in callback functions should go through the regular
2087 : * error handling code which should handle any recursive errors, though we
2088 : * double-check above, just in case.
2089 : */
2090 192 : for (econtext = error_context_stack;
2091 : econtext != NULL;
2092 144 : econtext = econtext->previous)
2093 144 : econtext->callback(econtext->arg);
2094 :
2095 : /*
2096 : * Clean ourselves off the stack, any allocations done should have been
2097 : * using edata->assoc_context, which we set up earlier to be the caller's
2098 : * context, so we're free to just remove our entry off the stack and
2099 : * decrement recursion depth and exit.
2100 : */
2101 48 : errordata_stack_depth--;
2102 48 : recursion_depth--;
2103 :
2104 : /*
2105 : * Return a pointer to the string the caller asked for, which should have
2106 : * been allocated in their context.
2107 : */
2108 48 : return edata->context;
2109 : }
2110 :
2111 :
2112 : /*
2113 : * Initialization of error output file
2114 : */
2115 : void
2116 41028 : DebugFileOpen(void)
2117 : {
2118 : int fd,
2119 : istty;
2120 :
2121 41028 : if (OutputFileName[0])
2122 : {
2123 : /*
2124 : * A debug-output file name was given.
2125 : *
2126 : * Make sure we can write the file, and find out if it's a tty.
2127 : */
2128 0 : if ((fd = open(OutputFileName, O_CREAT | O_APPEND | O_WRONLY,
2129 : 0666)) < 0)
2130 0 : ereport(FATAL,
2131 : (errcode_for_file_access(),
2132 : errmsg("could not open file \"%s\": %m", OutputFileName)));
2133 0 : istty = isatty(fd);
2134 0 : close(fd);
2135 :
2136 : /*
2137 : * Redirect our stderr to the debug output file.
2138 : */
2139 0 : if (!freopen(OutputFileName, "a", stderr))
2140 0 : ereport(FATAL,
2141 : (errcode_for_file_access(),
2142 : errmsg("could not reopen file \"%s\" as stderr: %m",
2143 : OutputFileName)));
2144 :
2145 : /*
2146 : * If the file is a tty and we're running under the postmaster, try to
2147 : * send stdout there as well (if it isn't a tty then stderr will block
2148 : * out stdout, so we may as well let stdout go wherever it was going
2149 : * before).
2150 : */
2151 0 : if (istty && IsUnderPostmaster)
2152 0 : if (!freopen(OutputFileName, "a", stdout))
2153 0 : ereport(FATAL,
2154 : (errcode_for_file_access(),
2155 : errmsg("could not reopen file \"%s\" as stdout: %m",
2156 : OutputFileName)));
2157 : }
2158 41028 : }
2159 :
2160 :
2161 : /*
2162 : * GUC check_hook for backtrace_functions
2163 : *
2164 : * We split the input string, where commas separate function names
2165 : * and certain whitespace chars are ignored, into a \0-separated (and
2166 : * \0\0-terminated) list of function names. This formulation allows
2167 : * easy scanning when an error is thrown while avoiding the use of
2168 : * non-reentrant strtok(), as well as keeping the output data in a
2169 : * single palloc() chunk.
2170 : */
2171 : bool
2172 2168 : check_backtrace_functions(char **newval, void **extra, GucSource source)
2173 : {
2174 2168 : int newvallen = strlen(*newval);
2175 : char *someval;
2176 : int validlen;
2177 : int i;
2178 : int j;
2179 :
2180 : /*
2181 : * Allow characters that can be C identifiers and commas as separators, as
2182 : * well as some whitespace for readability.
2183 : */
2184 2168 : validlen = strspn(*newval,
2185 : "0123456789_"
2186 : "abcdefghijklmnopqrstuvwxyz"
2187 : "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
2188 : ", \n\t");
2189 2168 : if (validlen != newvallen)
2190 : {
2191 0 : GUC_check_errdetail("Invalid character.");
2192 0 : return false;
2193 : }
2194 :
2195 2168 : if (*newval[0] == '\0')
2196 : {
2197 2168 : *extra = NULL;
2198 2168 : return true;
2199 : }
2200 :
2201 : /*
2202 : * Allocate space for the output and create the copy. We could discount
2203 : * whitespace chars to save some memory, but it doesn't seem worth the
2204 : * trouble.
2205 : */
2206 0 : someval = guc_malloc(LOG, newvallen + 1 + 1);
2207 0 : if (!someval)
2208 0 : return false;
2209 0 : for (i = 0, j = 0; i < newvallen; i++)
2210 : {
2211 0 : if ((*newval)[i] == ',')
2212 0 : someval[j++] = '\0'; /* next item */
2213 0 : else if ((*newval)[i] == ' ' ||
2214 0 : (*newval)[i] == '\n' ||
2215 0 : (*newval)[i] == '\t')
2216 : ; /* ignore these */
2217 : else
2218 0 : someval[j++] = (*newval)[i]; /* copy anything else */
2219 : }
2220 :
2221 : /* two \0s end the setting */
2222 0 : someval[j] = '\0';
2223 0 : someval[j + 1] = '\0';
2224 :
2225 0 : *extra = someval;
2226 0 : return true;
2227 : }
2228 :
2229 : /*
2230 : * GUC assign_hook for backtrace_functions
2231 : */
2232 : void
2233 2168 : assign_backtrace_functions(const char *newval, void *extra)
2234 : {
2235 2168 : backtrace_function_list = (char *) extra;
2236 2168 : }
2237 :
2238 : /*
2239 : * GUC check_hook for log_destination
2240 : */
2241 : bool
2242 2170 : check_log_destination(char **newval, void **extra, GucSource source)
2243 : {
2244 : char *rawstring;
2245 : List *elemlist;
2246 : ListCell *l;
2247 2170 : int newlogdest = 0;
2248 : int *myextra;
2249 :
2250 : /* Need a modifiable copy of string */
2251 2170 : rawstring = pstrdup(*newval);
2252 :
2253 : /* Parse string into list of identifiers */
2254 2170 : if (!SplitIdentifierString(rawstring, ',', &elemlist))
2255 : {
2256 : /* syntax error in list */
2257 0 : GUC_check_errdetail("List syntax is invalid.");
2258 0 : pfree(rawstring);
2259 0 : list_free(elemlist);
2260 0 : return false;
2261 : }
2262 :
2263 4344 : foreach(l, elemlist)
2264 : {
2265 2174 : char *tok = (char *) lfirst(l);
2266 :
2267 2174 : if (pg_strcasecmp(tok, "stderr") == 0)
2268 2170 : newlogdest |= LOG_DESTINATION_STDERR;
2269 4 : else if (pg_strcasecmp(tok, "csvlog") == 0)
2270 2 : newlogdest |= LOG_DESTINATION_CSVLOG;
2271 2 : else if (pg_strcasecmp(tok, "jsonlog") == 0)
2272 2 : newlogdest |= LOG_DESTINATION_JSONLOG;
2273 : #ifdef HAVE_SYSLOG
2274 0 : else if (pg_strcasecmp(tok, "syslog") == 0)
2275 0 : newlogdest |= LOG_DESTINATION_SYSLOG;
2276 : #endif
2277 : #ifdef WIN32
2278 : else if (pg_strcasecmp(tok, "eventlog") == 0)
2279 : newlogdest |= LOG_DESTINATION_EVENTLOG;
2280 : #endif
2281 : else
2282 : {
2283 0 : GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
2284 0 : pfree(rawstring);
2285 0 : list_free(elemlist);
2286 0 : return false;
2287 : }
2288 : }
2289 :
2290 2170 : pfree(rawstring);
2291 2170 : list_free(elemlist);
2292 :
2293 2170 : myextra = (int *) guc_malloc(LOG, sizeof(int));
2294 2170 : if (!myextra)
2295 0 : return false;
2296 2170 : *myextra = newlogdest;
2297 2170 : *extra = myextra;
2298 :
2299 2170 : return true;
2300 : }
2301 :
2302 : /*
2303 : * GUC assign_hook for log_destination
2304 : */
2305 : void
2306 2170 : assign_log_destination(const char *newval, void *extra)
2307 : {
2308 2170 : Log_destination = *((int *) extra);
2309 2170 : }
2310 :
2311 : /*
2312 : * GUC assign_hook for syslog_ident
2313 : */
2314 : void
2315 2168 : assign_syslog_ident(const char *newval, void *extra)
2316 : {
2317 : #ifdef HAVE_SYSLOG
2318 : /*
2319 : * guc.c is likely to call us repeatedly with same parameters, so don't
2320 : * thrash the syslog connection unnecessarily. Also, we do not re-open
2321 : * the connection until needed, since this routine will get called whether
2322 : * or not Log_destination actually mentions syslog.
2323 : *
2324 : * Note that we make our own copy of the ident string rather than relying
2325 : * on guc.c's. This may be overly paranoid, but it ensures that we cannot
2326 : * accidentally free a string that syslog is still using.
2327 : */
2328 2168 : if (syslog_ident == NULL || strcmp(syslog_ident, newval) != 0)
2329 : {
2330 2168 : if (openlog_done)
2331 : {
2332 0 : closelog();
2333 0 : openlog_done = false;
2334 : }
2335 2168 : free(syslog_ident);
2336 2168 : syslog_ident = strdup(newval);
2337 : /* if the strdup fails, we will cope in write_syslog() */
2338 : }
2339 : #endif
2340 : /* Without syslog support, just ignore it */
2341 2168 : }
2342 :
2343 : /*
2344 : * GUC assign_hook for syslog_facility
2345 : */
2346 : void
2347 2168 : assign_syslog_facility(int newval, void *extra)
2348 : {
2349 : #ifdef HAVE_SYSLOG
2350 : /*
2351 : * As above, don't thrash the syslog connection unnecessarily.
2352 : */
2353 2168 : if (syslog_facility != newval)
2354 : {
2355 0 : if (openlog_done)
2356 : {
2357 0 : closelog();
2358 0 : openlog_done = false;
2359 : }
2360 0 : syslog_facility = newval;
2361 : }
2362 : #endif
2363 : /* Without syslog support, just ignore it */
2364 2168 : }
2365 :
2366 : #ifdef HAVE_SYSLOG
2367 :
2368 : /*
2369 : * Write a message line to syslog
2370 : */
2371 : static void
2372 0 : write_syslog(int level, const char *line)
2373 : {
2374 : static unsigned long seq = 0;
2375 :
2376 : int len;
2377 : const char *nlpos;
2378 :
2379 : /* Open syslog connection if not done yet */
2380 0 : if (!openlog_done)
2381 : {
2382 0 : openlog(syslog_ident ? syslog_ident : "postgres",
2383 : LOG_PID | LOG_NDELAY | LOG_NOWAIT,
2384 : syslog_facility);
2385 0 : openlog_done = true;
2386 : }
2387 :
2388 : /*
2389 : * We add a sequence number to each log message to suppress "same"
2390 : * messages.
2391 : */
2392 0 : seq++;
2393 :
2394 : /*
2395 : * Our problem here is that many syslog implementations don't handle long
2396 : * messages in an acceptable manner. While this function doesn't help that
2397 : * fact, it does work around by splitting up messages into smaller pieces.
2398 : *
2399 : * We divide into multiple syslog() calls if message is too long or if the
2400 : * message contains embedded newline(s).
2401 : */
2402 0 : len = strlen(line);
2403 0 : nlpos = strchr(line, '\n');
2404 0 : if (syslog_split_messages && (len > PG_SYSLOG_LIMIT || nlpos != NULL))
2405 0 : {
2406 0 : int chunk_nr = 0;
2407 :
2408 0 : while (len > 0)
2409 : {
2410 : char buf[PG_SYSLOG_LIMIT + 1];
2411 : int buflen;
2412 : int i;
2413 :
2414 : /* if we start at a newline, move ahead one char */
2415 0 : if (line[0] == '\n')
2416 : {
2417 0 : line++;
2418 0 : len--;
2419 : /* we need to recompute the next newline's position, too */
2420 0 : nlpos = strchr(line, '\n');
2421 0 : continue;
2422 : }
2423 :
2424 : /* copy one line, or as much as will fit, to buf */
2425 0 : if (nlpos != NULL)
2426 0 : buflen = nlpos - line;
2427 : else
2428 0 : buflen = len;
2429 0 : buflen = Min(buflen, PG_SYSLOG_LIMIT);
2430 0 : memcpy(buf, line, buflen);
2431 0 : buf[buflen] = '\0';
2432 :
2433 : /* trim to multibyte letter boundary */
2434 0 : buflen = pg_mbcliplen(buf, buflen, buflen);
2435 0 : if (buflen <= 0)
2436 0 : return;
2437 0 : buf[buflen] = '\0';
2438 :
2439 : /* already word boundary? */
2440 0 : if (line[buflen] != '\0' &&
2441 0 : !isspace((unsigned char) line[buflen]))
2442 : {
2443 : /* try to divide at word boundary */
2444 0 : i = buflen - 1;
2445 0 : while (i > 0 && !isspace((unsigned char) buf[i]))
2446 0 : i--;
2447 :
2448 0 : if (i > 0) /* else couldn't divide word boundary */
2449 : {
2450 0 : buflen = i;
2451 0 : buf[i] = '\0';
2452 : }
2453 : }
2454 :
2455 0 : chunk_nr++;
2456 :
2457 0 : if (syslog_sequence_numbers)
2458 0 : syslog(level, "[%lu-%d] %s", seq, chunk_nr, buf);
2459 : else
2460 0 : syslog(level, "[%d] %s", chunk_nr, buf);
2461 :
2462 0 : line += buflen;
2463 0 : len -= buflen;
2464 : }
2465 : }
2466 : else
2467 : {
2468 : /* message short enough */
2469 0 : if (syslog_sequence_numbers)
2470 0 : syslog(level, "[%lu] %s", seq, line);
2471 : else
2472 0 : syslog(level, "%s", line);
2473 : }
2474 : }
2475 : #endif /* HAVE_SYSLOG */
2476 :
2477 : #ifdef WIN32
2478 : /*
2479 : * Get the PostgreSQL equivalent of the Windows ANSI code page. "ANSI" system
2480 : * interfaces (e.g. CreateFileA()) expect string arguments in this encoding.
2481 : * Every process in a given system will find the same value at all times.
2482 : */
2483 : static int
2484 : GetACPEncoding(void)
2485 : {
2486 : static int encoding = -2;
2487 :
2488 : if (encoding == -2)
2489 : encoding = pg_codepage_to_encoding(GetACP());
2490 :
2491 : return encoding;
2492 : }
2493 :
2494 : /*
2495 : * Write a message line to the windows event log
2496 : */
2497 : static void
2498 : write_eventlog(int level, const char *line, int len)
2499 : {
2500 : WCHAR *utf16;
2501 : int eventlevel = EVENTLOG_ERROR_TYPE;
2502 : static HANDLE evtHandle = INVALID_HANDLE_VALUE;
2503 :
2504 : if (evtHandle == INVALID_HANDLE_VALUE)
2505 : {
2506 : evtHandle = RegisterEventSource(NULL,
2507 : event_source ? event_source : DEFAULT_EVENT_SOURCE);
2508 : if (evtHandle == NULL)
2509 : {
2510 : evtHandle = INVALID_HANDLE_VALUE;
2511 : return;
2512 : }
2513 : }
2514 :
2515 : switch (level)
2516 : {
2517 : case DEBUG5:
2518 : case DEBUG4:
2519 : case DEBUG3:
2520 : case DEBUG2:
2521 : case DEBUG1:
2522 : case LOG:
2523 : case LOG_SERVER_ONLY:
2524 : case INFO:
2525 : case NOTICE:
2526 : eventlevel = EVENTLOG_INFORMATION_TYPE;
2527 : break;
2528 : case WARNING:
2529 : case WARNING_CLIENT_ONLY:
2530 : eventlevel = EVENTLOG_WARNING_TYPE;
2531 : break;
2532 : case ERROR:
2533 : case FATAL:
2534 : case PANIC:
2535 : default:
2536 : eventlevel = EVENTLOG_ERROR_TYPE;
2537 : break;
2538 : }
2539 :
2540 : /*
2541 : * If message character encoding matches the encoding expected by
2542 : * ReportEventA(), call it to avoid the hazards of conversion. Otherwise,
2543 : * try to convert the message to UTF16 and write it with ReportEventW().
2544 : * Fall back on ReportEventA() if conversion failed.
2545 : *
2546 : * Since we palloc the structure required for conversion, also fall
2547 : * through to writing unconverted if we have not yet set up
2548 : * CurrentMemoryContext.
2549 : *
2550 : * Also verify that we are not on our way into error recursion trouble due
2551 : * to error messages thrown deep inside pgwin32_message_to_UTF16().
2552 : */
2553 : if (!in_error_recursion_trouble() &&
2554 : CurrentMemoryContext != NULL &&
2555 : GetMessageEncoding() != GetACPEncoding())
2556 : {
2557 : utf16 = pgwin32_message_to_UTF16(line, len, NULL);
2558 : if (utf16)
2559 : {
2560 : ReportEventW(evtHandle,
2561 : eventlevel,
2562 : 0,
2563 : 0, /* All events are Id 0 */
2564 : NULL,
2565 : 1,
2566 : 0,
2567 : (LPCWSTR *) &utf16,
2568 : NULL);
2569 : /* XXX Try ReportEventA() when ReportEventW() fails? */
2570 :
2571 : pfree(utf16);
2572 : return;
2573 : }
2574 : }
2575 : ReportEventA(evtHandle,
2576 : eventlevel,
2577 : 0,
2578 : 0, /* All events are Id 0 */
2579 : NULL,
2580 : 1,
2581 : 0,
2582 : &line,
2583 : NULL);
2584 : }
2585 : #endif /* WIN32 */
2586 :
2587 : static void
2588 721850 : write_console(const char *line, int len)
2589 : {
2590 : int rc;
2591 :
2592 : #ifdef WIN32
2593 :
2594 : /*
2595 : * Try to convert the message to UTF16 and write it with WriteConsoleW().
2596 : * Fall back on write() if anything fails.
2597 : *
2598 : * In contrast to write_eventlog(), don't skip straight to write() based
2599 : * on the applicable encodings. Unlike WriteConsoleW(), write() depends
2600 : * on the suitability of the console output code page. Since we put
2601 : * stderr into binary mode in SubPostmasterMain(), write() skips the
2602 : * necessary translation anyway.
2603 : *
2604 : * WriteConsoleW() will fail if stderr is redirected, so just fall through
2605 : * to writing unconverted to the logfile in this case.
2606 : *
2607 : * Since we palloc the structure required for conversion, also fall
2608 : * through to writing unconverted if we have not yet set up
2609 : * CurrentMemoryContext.
2610 : */
2611 : if (!in_error_recursion_trouble() &&
2612 : !redirection_done &&
2613 : CurrentMemoryContext != NULL)
2614 : {
2615 : WCHAR *utf16;
2616 : int utf16len;
2617 :
2618 : utf16 = pgwin32_message_to_UTF16(line, len, &utf16len);
2619 : if (utf16 != NULL)
2620 : {
2621 : HANDLE stdHandle;
2622 : DWORD written;
2623 :
2624 : stdHandle = GetStdHandle(STD_ERROR_HANDLE);
2625 : if (WriteConsoleW(stdHandle, utf16, utf16len, &written, NULL))
2626 : {
2627 : pfree(utf16);
2628 : return;
2629 : }
2630 :
2631 : /*
2632 : * In case WriteConsoleW() failed, fall back to writing the
2633 : * message unconverted.
2634 : */
2635 : pfree(utf16);
2636 : }
2637 : }
2638 : #else
2639 :
2640 : /*
2641 : * Conversion on non-win32 platforms is not implemented yet. It requires
2642 : * non-throw version of pg_do_encoding_conversion(), that converts
2643 : * unconvertible characters to '?' without errors.
2644 : *
2645 : * XXX: We have a no-throw version now. It doesn't convert to '?' though.
2646 : */
2647 : #endif
2648 :
2649 : /*
2650 : * We ignore any error from write() here. We have no useful way to report
2651 : * it ... certainly whining on stderr isn't likely to be productive.
2652 : */
2653 721850 : rc = write(fileno(stderr), line, len);
2654 : (void) rc;
2655 721850 : }
2656 :
2657 : /*
2658 : * get_formatted_log_time -- compute and get the log timestamp.
2659 : *
2660 : * The timestamp is computed if not set yet, so as it is kept consistent
2661 : * among all the log destinations that require it to be consistent. Note
2662 : * that the computed timestamp is returned in a static buffer, not
2663 : * palloc()'d.
2664 : */
2665 : char *
2666 1059980 : get_formatted_log_time(void)
2667 : {
2668 : pg_time_t stamp_time;
2669 : char msbuf[13];
2670 :
2671 : /* leave if already computed */
2672 1059980 : if (formatted_log_time[0] != '\0')
2673 80 : return formatted_log_time;
2674 :
2675 1059900 : if (!saved_timeval_set)
2676 : {
2677 721890 : gettimeofday(&saved_timeval, NULL);
2678 721890 : saved_timeval_set = true;
2679 : }
2680 :
2681 1059900 : stamp_time = (pg_time_t) saved_timeval.tv_sec;
2682 :
2683 : /*
2684 : * Note: we expect that guc.c will ensure that log_timezone is set up (at
2685 : * least with a minimal GMT value) before Log_line_prefix can become
2686 : * nonempty or CSV/JSON mode can be selected.
2687 : */
2688 1059900 : pg_strftime(formatted_log_time, FORMATTED_TS_LEN,
2689 : /* leave room for milliseconds... */
2690 : "%Y-%m-%d %H:%M:%S %Z",
2691 1059900 : pg_localtime(&stamp_time, log_timezone));
2692 :
2693 : /* 'paste' milliseconds into place... */
2694 1059900 : sprintf(msbuf, ".%03d", (int) (saved_timeval.tv_usec / 1000));
2695 1059900 : memcpy(formatted_log_time + 19, msbuf, 4);
2696 :
2697 1059900 : return formatted_log_time;
2698 : }
2699 :
2700 : /*
2701 : * reset_formatted_start_time -- reset the start timestamp
2702 : */
2703 : void
2704 29638 : reset_formatted_start_time(void)
2705 : {
2706 29638 : formatted_start_time[0] = '\0';
2707 29638 : }
2708 :
2709 : /*
2710 : * get_formatted_start_time -- compute and get the start timestamp.
2711 : *
2712 : * The timestamp is computed if not set yet. Note that the computed
2713 : * timestamp is returned in a static buffer, not palloc()'d.
2714 : */
2715 : char *
2716 80 : get_formatted_start_time(void)
2717 : {
2718 80 : pg_time_t stamp_time = (pg_time_t) MyStartTime;
2719 :
2720 : /* leave if already computed */
2721 80 : if (formatted_start_time[0] != '\0')
2722 36 : return formatted_start_time;
2723 :
2724 : /*
2725 : * Note: we expect that guc.c will ensure that log_timezone is set up (at
2726 : * least with a minimal GMT value) before Log_line_prefix can become
2727 : * nonempty or CSV/JSON mode can be selected.
2728 : */
2729 44 : pg_strftime(formatted_start_time, FORMATTED_TS_LEN,
2730 : "%Y-%m-%d %H:%M:%S %Z",
2731 44 : pg_localtime(&stamp_time, log_timezone));
2732 :
2733 44 : return formatted_start_time;
2734 : }
2735 :
2736 : /*
2737 : * check_log_of_query -- check if a query can be logged
2738 : */
2739 : bool
2740 721970 : check_log_of_query(ErrorData *edata)
2741 : {
2742 : /* log required? */
2743 721970 : if (!is_log_level_output(edata->elevel, log_min_error_statement))
2744 257400 : return false;
2745 :
2746 : /* query log wanted? */
2747 464570 : if (edata->hide_stmt)
2748 272562 : return false;
2749 :
2750 : /* query string available? */
2751 192008 : if (debug_query_string == NULL)
2752 136198 : return false;
2753 :
2754 55810 : return true;
2755 : }
2756 :
2757 : /*
2758 : * get_backend_type_for_log -- backend type for log entries
2759 : *
2760 : * Returns a pointer to a static buffer, not palloc()'d.
2761 : */
2762 : const char *
2763 50440 : get_backend_type_for_log(void)
2764 : {
2765 : const char *backend_type_str;
2766 :
2767 50440 : if (MyProcPid == PostmasterPid)
2768 1328 : backend_type_str = "postmaster";
2769 49112 : else if (MyBackendType == B_BG_WORKER)
2770 56 : backend_type_str = MyBgworkerEntry->bgw_type;
2771 : else
2772 49056 : backend_type_str = GetBackendTypeDesc(MyBackendType);
2773 :
2774 50440 : return backend_type_str;
2775 : }
2776 :
2777 : /*
2778 : * process_log_prefix_padding --- helper function for processing the format
2779 : * string in log_line_prefix
2780 : *
2781 : * Note: This function returns NULL if it finds something which
2782 : * it deems invalid in the format string.
2783 : */
2784 : static const char *
2785 0 : process_log_prefix_padding(const char *p, int *ppadding)
2786 : {
2787 0 : int paddingsign = 1;
2788 0 : int padding = 0;
2789 :
2790 0 : if (*p == '-')
2791 : {
2792 0 : p++;
2793 :
2794 0 : if (*p == '\0') /* Did the buf end in %- ? */
2795 0 : return NULL;
2796 0 : paddingsign = -1;
2797 : }
2798 :
2799 : /* generate an int version of the numerical string */
2800 0 : while (*p >= '0' && *p <= '9')
2801 0 : padding = padding * 10 + (*p++ - '0');
2802 :
2803 : /* format is invalid if it ends with the padding number */
2804 0 : if (*p == '\0')
2805 0 : return NULL;
2806 :
2807 0 : padding *= paddingsign;
2808 0 : *ppadding = padding;
2809 0 : return p;
2810 : }
2811 :
2812 : /*
2813 : * Format log status information using Log_line_prefix.
2814 : */
2815 : static void
2816 1059900 : log_line_prefix(StringInfo buf, ErrorData *edata)
2817 : {
2818 1059900 : log_status_format(buf, Log_line_prefix, edata);
2819 1059900 : }
2820 :
2821 : /*
2822 : * Format log status info; append to the provided buffer.
2823 : */
2824 : void
2825 1059900 : log_status_format(StringInfo buf, const char *format, ErrorData *edata)
2826 : {
2827 : /* static counter for line numbers */
2828 : static long log_line_number = 0;
2829 :
2830 : /* has counter been reset in current process? */
2831 : static int log_my_pid = 0;
2832 : int padding;
2833 : const char *p;
2834 :
2835 : /*
2836 : * This is one of the few places where we'd rather not inherit a static
2837 : * variable's value from the postmaster. But since we will, reset it when
2838 : * MyProcPid changes. MyStartTime also changes when MyProcPid does, so
2839 : * reset the formatted start timestamp too.
2840 : */
2841 1059900 : if (log_my_pid != MyProcPid)
2842 : {
2843 29594 : log_line_number = 0;
2844 29594 : log_my_pid = MyProcPid;
2845 29594 : reset_formatted_start_time();
2846 : }
2847 1059900 : log_line_number++;
2848 :
2849 1059900 : if (format == NULL)
2850 349710 : return; /* in case guc hasn't run yet */
2851 :
2852 9599180 : for (p = format; *p != '\0'; p++)
2853 : {
2854 8888990 : if (*p != '%')
2855 : {
2856 : /* literal char, just copy */
2857 4949440 : appendStringInfoChar(buf, *p);
2858 4949440 : continue;
2859 : }
2860 :
2861 : /* must be a '%', so skip to the next char */
2862 3939550 : p++;
2863 3939550 : if (*p == '\0')
2864 0 : break; /* format error - ignore it */
2865 3939550 : else if (*p == '%')
2866 : {
2867 : /* string contains %% */
2868 0 : appendStringInfoChar(buf, '%');
2869 0 : continue;
2870 : }
2871 :
2872 :
2873 : /*
2874 : * Process any formatting which may exist after the '%'. Note that
2875 : * process_log_prefix_padding moves p past the padding number if it
2876 : * exists.
2877 : *
2878 : * Note: Since only '-', '0' to '9' are valid formatting characters we
2879 : * can do a quick check here to pre-check for formatting. If the char
2880 : * is not formatting then we can skip a useless function call.
2881 : *
2882 : * Further note: At least on some platforms, passing %*s rather than
2883 : * %s to appendStringInfo() is substantially slower, so many of the
2884 : * cases below avoid doing that unless non-zero padding is in fact
2885 : * specified.
2886 : */
2887 3939550 : if (*p > '9')
2888 3939550 : padding = 0;
2889 0 : else if ((p = process_log_prefix_padding(p, &padding)) == NULL)
2890 0 : break;
2891 :
2892 : /* process the option */
2893 3939550 : switch (*p)
2894 : {
2895 709840 : case 'a':
2896 709840 : if (MyProcPort)
2897 : {
2898 709840 : const char *appname = application_name;
2899 :
2900 709840 : if (appname == NULL || *appname == '\0')
2901 5214 : appname = _("[unknown]");
2902 709840 : if (padding != 0)
2903 0 : appendStringInfo(buf, "%*s", padding, appname);
2904 : else
2905 709840 : appendStringInfoString(buf, appname);
2906 : }
2907 0 : else if (padding != 0)
2908 0 : appendStringInfoSpaces(buf,
2909 : padding > 0 ? padding : -padding);
2910 :
2911 709840 : break;
2912 50360 : case 'b':
2913 : {
2914 50360 : const char *backend_type_str = get_backend_type_for_log();
2915 :
2916 50360 : if (padding != 0)
2917 0 : appendStringInfo(buf, "%*s", padding, backend_type_str);
2918 : else
2919 50360 : appendStringInfoString(buf, backend_type_str);
2920 50360 : break;
2921 : }
2922 0 : case 'u':
2923 0 : if (MyProcPort)
2924 : {
2925 0 : const char *username = MyProcPort->user_name;
2926 :
2927 0 : if (username == NULL || *username == '\0')
2928 0 : username = _("[unknown]");
2929 0 : if (padding != 0)
2930 0 : appendStringInfo(buf, "%*s", padding, username);
2931 : else
2932 0 : appendStringInfoString(buf, username);
2933 : }
2934 0 : else if (padding != 0)
2935 0 : appendStringInfoSpaces(buf,
2936 : padding > 0 ? padding : -padding);
2937 0 : break;
2938 0 : case 'd':
2939 0 : if (MyProcPort)
2940 : {
2941 0 : const char *dbname = MyProcPort->database_name;
2942 :
2943 0 : if (dbname == NULL || *dbname == '\0')
2944 0 : dbname = _("[unknown]");
2945 0 : if (padding != 0)
2946 0 : appendStringInfo(buf, "%*s", padding, dbname);
2947 : else
2948 0 : appendStringInfoString(buf, dbname);
2949 : }
2950 0 : else if (padding != 0)
2951 0 : appendStringInfoSpaces(buf,
2952 : padding > 0 ? padding : -padding);
2953 0 : break;
2954 0 : case 'c':
2955 0 : if (padding != 0)
2956 : {
2957 : char strfbuf[128];
2958 :
2959 0 : snprintf(strfbuf, sizeof(strfbuf) - 1, INT64_HEX_FORMAT ".%x",
2960 : MyStartTime, MyProcPid);
2961 0 : appendStringInfo(buf, "%*s", padding, strfbuf);
2962 : }
2963 : else
2964 0 : appendStringInfo(buf, INT64_HEX_FORMAT ".%x", MyStartTime, MyProcPid);
2965 0 : break;
2966 1059900 : case 'p':
2967 1059900 : if (padding != 0)
2968 0 : appendStringInfo(buf, "%*d", padding, MyProcPid);
2969 : else
2970 1059900 : appendStringInfo(buf, "%d", MyProcPid);
2971 1059900 : break;
2972 :
2973 0 : case 'P':
2974 0 : if (MyProc)
2975 : {
2976 0 : PGPROC *leader = MyProc->lockGroupLeader;
2977 :
2978 : /*
2979 : * Show the leader only for active parallel workers. This
2980 : * leaves out the leader of a parallel group.
2981 : */
2982 0 : if (leader == NULL || leader->pid == MyProcPid)
2983 0 : appendStringInfoSpaces(buf,
2984 : padding > 0 ? padding : -padding);
2985 0 : else if (padding != 0)
2986 0 : appendStringInfo(buf, "%*d", padding, leader->pid);
2987 : else
2988 0 : appendStringInfo(buf, "%d", leader->pid);
2989 : }
2990 0 : else if (padding != 0)
2991 0 : appendStringInfoSpaces(buf,
2992 : padding > 0 ? padding : -padding);
2993 0 : break;
2994 :
2995 0 : case 'l':
2996 0 : if (padding != 0)
2997 0 : appendStringInfo(buf, "%*ld", padding, log_line_number);
2998 : else
2999 0 : appendStringInfo(buf, "%ld", log_line_number);
3000 0 : break;
3001 1059900 : case 'm':
3002 : /* force a log timestamp reset */
3003 1059900 : formatted_log_time[0] = '\0';
3004 1059900 : (void) get_formatted_log_time();
3005 :
3006 1059900 : if (padding != 0)
3007 0 : appendStringInfo(buf, "%*s", padding, formatted_log_time);
3008 : else
3009 1059900 : appendStringInfoString(buf, formatted_log_time);
3010 1059900 : break;
3011 0 : case 't':
3012 : {
3013 0 : pg_time_t stamp_time = (pg_time_t) time(NULL);
3014 : char strfbuf[128];
3015 :
3016 0 : pg_strftime(strfbuf, sizeof(strfbuf),
3017 : "%Y-%m-%d %H:%M:%S %Z",
3018 0 : pg_localtime(&stamp_time, log_timezone));
3019 0 : if (padding != 0)
3020 0 : appendStringInfo(buf, "%*s", padding, strfbuf);
3021 : else
3022 0 : appendStringInfoString(buf, strfbuf);
3023 : }
3024 0 : break;
3025 0 : case 'n':
3026 : {
3027 : char strfbuf[128];
3028 :
3029 0 : if (!saved_timeval_set)
3030 : {
3031 0 : gettimeofday(&saved_timeval, NULL);
3032 0 : saved_timeval_set = true;
3033 : }
3034 :
3035 0 : snprintf(strfbuf, sizeof(strfbuf), "%ld.%03d",
3036 0 : (long) saved_timeval.tv_sec,
3037 0 : (int) (saved_timeval.tv_usec / 1000));
3038 :
3039 0 : if (padding != 0)
3040 0 : appendStringInfo(buf, "%*s", padding, strfbuf);
3041 : else
3042 0 : appendStringInfoString(buf, strfbuf);
3043 : }
3044 0 : break;
3045 0 : case 's':
3046 : {
3047 0 : char *start_time = get_formatted_start_time();
3048 :
3049 0 : if (padding != 0)
3050 0 : appendStringInfo(buf, "%*s", padding, start_time);
3051 : else
3052 0 : appendStringInfoString(buf, start_time);
3053 : }
3054 0 : break;
3055 0 : case 'i':
3056 0 : if (MyProcPort)
3057 : {
3058 : const char *psdisp;
3059 : int displen;
3060 :
3061 0 : psdisp = get_ps_display(&displen);
3062 0 : if (padding != 0)
3063 0 : appendStringInfo(buf, "%*s", padding, psdisp);
3064 : else
3065 0 : appendBinaryStringInfo(buf, psdisp, displen);
3066 : }
3067 0 : else if (padding != 0)
3068 0 : appendStringInfoSpaces(buf,
3069 : padding > 0 ? padding : -padding);
3070 0 : break;
3071 0 : case 'L':
3072 : {
3073 : const char *local_host;
3074 :
3075 0 : if (MyProcPort)
3076 : {
3077 0 : if (MyProcPort->local_host[0] == '\0')
3078 : {
3079 : /*
3080 : * First time through: cache the lookup, since it
3081 : * might not have trivial cost.
3082 : */
3083 0 : (void) pg_getnameinfo_all(&MyProcPort->laddr.addr,
3084 0 : MyProcPort->laddr.salen,
3085 0 : MyProcPort->local_host,
3086 : sizeof(MyProcPort->local_host),
3087 : NULL, 0,
3088 : NI_NUMERICHOST | NI_NUMERICSERV);
3089 : }
3090 0 : local_host = MyProcPort->local_host;
3091 : }
3092 : else
3093 : {
3094 : /* Background process, or connection not yet made */
3095 0 : local_host = "[none]";
3096 : }
3097 0 : if (padding != 0)
3098 0 : appendStringInfo(buf, "%*s", padding, local_host);
3099 : else
3100 0 : appendStringInfoString(buf, local_host);
3101 : }
3102 0 : break;
3103 0 : case 'r':
3104 0 : if (MyProcPort && MyProcPort->remote_host)
3105 : {
3106 0 : if (padding != 0)
3107 : {
3108 0 : if (MyProcPort->remote_port && MyProcPort->remote_port[0] != '\0')
3109 0 : {
3110 : /*
3111 : * This option is slightly special as the port
3112 : * number may be appended onto the end. Here we
3113 : * need to build 1 string which contains the
3114 : * remote_host and optionally the remote_port (if
3115 : * set) so we can properly align the string.
3116 : */
3117 :
3118 : char *hostport;
3119 :
3120 0 : hostport = psprintf("%s(%s)", MyProcPort->remote_host, MyProcPort->remote_port);
3121 0 : appendStringInfo(buf, "%*s", padding, hostport);
3122 0 : pfree(hostport);
3123 : }
3124 : else
3125 0 : appendStringInfo(buf, "%*s", padding, MyProcPort->remote_host);
3126 : }
3127 : else
3128 : {
3129 : /* padding is 0, so we don't need a temp buffer */
3130 0 : appendStringInfoString(buf, MyProcPort->remote_host);
3131 0 : if (MyProcPort->remote_port &&
3132 0 : MyProcPort->remote_port[0] != '\0')
3133 0 : appendStringInfo(buf, "(%s)",
3134 0 : MyProcPort->remote_port);
3135 : }
3136 : }
3137 0 : else if (padding != 0)
3138 0 : appendStringInfoSpaces(buf,
3139 : padding > 0 ? padding : -padding);
3140 0 : break;
3141 0 : case 'h':
3142 0 : if (MyProcPort && MyProcPort->remote_host)
3143 : {
3144 0 : if (padding != 0)
3145 0 : appendStringInfo(buf, "%*s", padding, MyProcPort->remote_host);
3146 : else
3147 0 : appendStringInfoString(buf, MyProcPort->remote_host);
3148 : }
3149 0 : else if (padding != 0)
3150 0 : appendStringInfoSpaces(buf,
3151 : padding > 0 ? padding : -padding);
3152 0 : break;
3153 1059550 : case 'q':
3154 : /* in postmaster and friends, stop if %q is seen */
3155 : /* in a backend, just ignore */
3156 1059550 : if (MyProcPort == NULL)
3157 349710 : return;
3158 709840 : break;
3159 0 : case 'v':
3160 : /* keep VXID format in sync with lockfuncs.c */
3161 0 : if (MyProc != NULL && MyProc->vxid.procNumber != INVALID_PROC_NUMBER)
3162 : {
3163 0 : if (padding != 0)
3164 : {
3165 : char strfbuf[128];
3166 :
3167 0 : snprintf(strfbuf, sizeof(strfbuf) - 1, "%d/%u",
3168 0 : MyProc->vxid.procNumber, MyProc->vxid.lxid);
3169 0 : appendStringInfo(buf, "%*s", padding, strfbuf);
3170 : }
3171 : else
3172 0 : appendStringInfo(buf, "%d/%u", MyProc->vxid.procNumber, MyProc->vxid.lxid);
3173 : }
3174 0 : else if (padding != 0)
3175 0 : appendStringInfoSpaces(buf,
3176 : padding > 0 ? padding : -padding);
3177 0 : break;
3178 0 : case 'x':
3179 0 : if (padding != 0)
3180 0 : appendStringInfo(buf, "%*u", padding, GetTopTransactionIdIfAny());
3181 : else
3182 0 : appendStringInfo(buf, "%u", GetTopTransactionIdIfAny());
3183 0 : break;
3184 0 : case 'e':
3185 0 : if (padding != 0)
3186 0 : appendStringInfo(buf, "%*s", padding, unpack_sql_state(edata->sqlerrcode));
3187 : else
3188 0 : appendStringInfoString(buf, unpack_sql_state(edata->sqlerrcode));
3189 0 : break;
3190 0 : case 'Q':
3191 0 : if (padding != 0)
3192 0 : appendStringInfo(buf, "%*" PRId64, padding,
3193 : pgstat_get_my_query_id());
3194 : else
3195 0 : appendStringInfo(buf, "%" PRId64,
3196 : pgstat_get_my_query_id());
3197 0 : break;
3198 0 : default:
3199 : /* format error - ignore it */
3200 0 : break;
3201 : }
3202 : }
3203 : }
3204 :
3205 : /*
3206 : * Unpack MAKE_SQLSTATE code. Note that this returns a pointer to a
3207 : * static buffer.
3208 : */
3209 : char *
3210 218544 : unpack_sql_state(int sql_state)
3211 : {
3212 : static char buf[12];
3213 : int i;
3214 :
3215 1311264 : for (i = 0; i < 5; i++)
3216 : {
3217 1092720 : buf[i] = PGUNSIXBIT(sql_state);
3218 1092720 : sql_state >>= 6;
3219 : }
3220 :
3221 218544 : buf[i] = '\0';
3222 218544 : return buf;
3223 : }
3224 :
3225 :
3226 : /*
3227 : * Write error report to server's log
3228 : */
3229 : static void
3230 721890 : send_message_to_server_log(ErrorData *edata)
3231 : {
3232 : StringInfoData buf;
3233 721890 : bool fallback_to_stderr = false;
3234 :
3235 721890 : initStringInfo(&buf);
3236 :
3237 721890 : log_line_prefix(&buf, edata);
3238 721890 : appendStringInfo(&buf, "%s: ", _(error_severity(edata->elevel)));
3239 :
3240 721890 : if (Log_error_verbosity >= PGERROR_VERBOSE)
3241 180 : appendStringInfo(&buf, "%s: ", unpack_sql_state(edata->sqlerrcode));
3242 :
3243 721890 : if (edata->message)
3244 721890 : append_with_tabs(&buf, edata->message);
3245 : else
3246 0 : append_with_tabs(&buf, _("missing error text"));
3247 :
3248 721890 : if (edata->cursorpos > 0)
3249 10948 : appendStringInfo(&buf, _(" at character %d"),
3250 : edata->cursorpos);
3251 710942 : else if (edata->internalpos > 0)
3252 98 : appendStringInfo(&buf, _(" at character %d"),
3253 : edata->internalpos);
3254 :
3255 721890 : appendStringInfoChar(&buf, '\n');
3256 :
3257 721890 : if (Log_error_verbosity >= PGERROR_DEFAULT)
3258 : {
3259 721890 : if (edata->detail_log)
3260 : {
3261 550 : log_line_prefix(&buf, edata);
3262 550 : appendStringInfoString(&buf, _("DETAIL: "));
3263 550 : append_with_tabs(&buf, edata->detail_log);
3264 550 : appendStringInfoChar(&buf, '\n');
3265 : }
3266 721340 : else if (edata->detail)
3267 : {
3268 50920 : log_line_prefix(&buf, edata);
3269 50920 : appendStringInfoString(&buf, _("DETAIL: "));
3270 50920 : append_with_tabs(&buf, edata->detail);
3271 50920 : appendStringInfoChar(&buf, '\n');
3272 : }
3273 721890 : if (edata->hint)
3274 : {
3275 225258 : log_line_prefix(&buf, edata);
3276 225258 : appendStringInfoString(&buf, _("HINT: "));
3277 225258 : append_with_tabs(&buf, edata->hint);
3278 225258 : appendStringInfoChar(&buf, '\n');
3279 : }
3280 721890 : if (edata->internalquery)
3281 : {
3282 98 : log_line_prefix(&buf, edata);
3283 98 : appendStringInfoString(&buf, _("QUERY: "));
3284 98 : append_with_tabs(&buf, edata->internalquery);
3285 98 : appendStringInfoChar(&buf, '\n');
3286 : }
3287 721890 : if (edata->context && !edata->hide_ctx)
3288 : {
3289 5202 : log_line_prefix(&buf, edata);
3290 5202 : appendStringInfoString(&buf, _("CONTEXT: "));
3291 5202 : append_with_tabs(&buf, edata->context);
3292 5202 : appendStringInfoChar(&buf, '\n');
3293 : }
3294 721890 : if (Log_error_verbosity >= PGERROR_VERBOSE)
3295 : {
3296 : /* assume no newlines in funcname or filename... */
3297 180 : if (edata->funcname && edata->filename)
3298 : {
3299 180 : log_line_prefix(&buf, edata);
3300 180 : appendStringInfo(&buf, _("LOCATION: %s, %s:%d\n"),
3301 : edata->funcname, edata->filename,
3302 : edata->lineno);
3303 : }
3304 0 : else if (edata->filename)
3305 : {
3306 0 : log_line_prefix(&buf, edata);
3307 0 : appendStringInfo(&buf, _("LOCATION: %s:%d\n"),
3308 : edata->filename, edata->lineno);
3309 : }
3310 : }
3311 721890 : if (edata->backtrace)
3312 : {
3313 0 : log_line_prefix(&buf, edata);
3314 0 : appendStringInfoString(&buf, _("BACKTRACE: "));
3315 0 : append_with_tabs(&buf, edata->backtrace);
3316 0 : appendStringInfoChar(&buf, '\n');
3317 : }
3318 : }
3319 :
3320 : /*
3321 : * If the user wants the query that generated this error logged, do it.
3322 : */
3323 721890 : if (check_log_of_query(edata))
3324 : {
3325 55802 : log_line_prefix(&buf, edata);
3326 55802 : appendStringInfoString(&buf, _("STATEMENT: "));
3327 55802 : append_with_tabs(&buf, debug_query_string);
3328 55802 : appendStringInfoChar(&buf, '\n');
3329 : }
3330 :
3331 : #ifdef HAVE_SYSLOG
3332 : /* Write to syslog, if enabled */
3333 721890 : if (Log_destination & LOG_DESTINATION_SYSLOG)
3334 : {
3335 : int syslog_level;
3336 :
3337 0 : switch (edata->elevel)
3338 : {
3339 0 : case DEBUG5:
3340 : case DEBUG4:
3341 : case DEBUG3:
3342 : case DEBUG2:
3343 : case DEBUG1:
3344 0 : syslog_level = LOG_DEBUG;
3345 0 : break;
3346 0 : case LOG:
3347 : case LOG_SERVER_ONLY:
3348 : case INFO:
3349 0 : syslog_level = LOG_INFO;
3350 0 : break;
3351 0 : case NOTICE:
3352 : case WARNING:
3353 : case WARNING_CLIENT_ONLY:
3354 0 : syslog_level = LOG_NOTICE;
3355 0 : break;
3356 0 : case ERROR:
3357 0 : syslog_level = LOG_WARNING;
3358 0 : break;
3359 0 : case FATAL:
3360 0 : syslog_level = LOG_ERR;
3361 0 : break;
3362 0 : case PANIC:
3363 : default:
3364 0 : syslog_level = LOG_CRIT;
3365 0 : break;
3366 : }
3367 :
3368 0 : write_syslog(syslog_level, buf.data);
3369 : }
3370 : #endif /* HAVE_SYSLOG */
3371 :
3372 : #ifdef WIN32
3373 : /* Write to eventlog, if enabled */
3374 : if (Log_destination & LOG_DESTINATION_EVENTLOG)
3375 : {
3376 : write_eventlog(edata->elevel, buf.data, buf.len);
3377 : }
3378 : #endif /* WIN32 */
3379 :
3380 : /* Write to csvlog, if enabled */
3381 721890 : if (Log_destination & LOG_DESTINATION_CSVLOG)
3382 : {
3383 : /*
3384 : * Send CSV data if it's safe to do so (syslogger doesn't need the
3385 : * pipe). If this is not possible, fallback to an entry written to
3386 : * stderr.
3387 : */
3388 42 : if (redirection_done || MyBackendType == B_LOGGER)
3389 40 : write_csvlog(edata);
3390 : else
3391 2 : fallback_to_stderr = true;
3392 : }
3393 :
3394 : /* Write to JSON log, if enabled */
3395 721890 : if (Log_destination & LOG_DESTINATION_JSONLOG)
3396 : {
3397 : /*
3398 : * Send JSON data if it's safe to do so (syslogger doesn't need the
3399 : * pipe). If this is not possible, fallback to an entry written to
3400 : * stderr.
3401 : */
3402 42 : if (redirection_done || MyBackendType == B_LOGGER)
3403 : {
3404 40 : write_jsonlog(edata);
3405 : }
3406 : else
3407 2 : fallback_to_stderr = true;
3408 : }
3409 :
3410 : /*
3411 : * Write to stderr, if enabled or if required because of a previous
3412 : * limitation.
3413 : */
3414 721890 : if ((Log_destination & LOG_DESTINATION_STDERR) ||
3415 0 : whereToSendOutput == DestDebug ||
3416 : fallback_to_stderr)
3417 : {
3418 : /*
3419 : * Use the chunking protocol if we know the syslogger should be
3420 : * catching stderr output, and we are not ourselves the syslogger.
3421 : * Otherwise, just do a vanilla write to stderr.
3422 : */
3423 721890 : if (redirection_done && MyBackendType != B_LOGGER)
3424 40 : write_pipe_chunks(buf.data, buf.len, LOG_DESTINATION_STDERR);
3425 : #ifdef WIN32
3426 :
3427 : /*
3428 : * In a win32 service environment, there is no usable stderr. Capture
3429 : * anything going there and write it to the eventlog instead.
3430 : *
3431 : * If stderr redirection is active, it was OK to write to stderr above
3432 : * because that's really a pipe to the syslogger process.
3433 : */
3434 : else if (pgwin32_is_service())
3435 : write_eventlog(edata->elevel, buf.data, buf.len);
3436 : #endif
3437 : else
3438 721850 : write_console(buf.data, buf.len);
3439 : }
3440 :
3441 : /* If in the syslogger process, try to write messages direct to file */
3442 721890 : if (MyBackendType == B_LOGGER)
3443 0 : write_syslogger_file(buf.data, buf.len, LOG_DESTINATION_STDERR);
3444 :
3445 : /* No more need of the message formatted for stderr */
3446 721890 : pfree(buf.data);
3447 721890 : }
3448 :
3449 : /*
3450 : * Send data to the syslogger using the chunked protocol
3451 : *
3452 : * Note: when there are multiple backends writing into the syslogger pipe,
3453 : * it's critical that each write go into the pipe indivisibly, and not
3454 : * get interleaved with data from other processes. Fortunately, the POSIX
3455 : * spec requires that writes to pipes be atomic so long as they are not
3456 : * more than PIPE_BUF bytes long. So we divide long messages into chunks
3457 : * that are no more than that length, and send one chunk per write() call.
3458 : * The collector process knows how to reassemble the chunks.
3459 : *
3460 : * Because of the atomic write requirement, there are only two possible
3461 : * results from write() here: -1 for failure, or the requested number of
3462 : * bytes. There is not really anything we can do about a failure; retry would
3463 : * probably be an infinite loop, and we can't even report the error usefully.
3464 : * (There is noplace else we could send it!) So we might as well just ignore
3465 : * the result from write(). However, on some platforms you get a compiler
3466 : * warning from ignoring write()'s result, so do a little dance with casting
3467 : * rc to void to shut up the compiler.
3468 : */
3469 : void
3470 120 : write_pipe_chunks(char *data, int len, int dest)
3471 : {
3472 : PipeProtoChunk p;
3473 120 : int fd = fileno(stderr);
3474 : int rc;
3475 :
3476 : Assert(len > 0);
3477 :
3478 120 : p.proto.nuls[0] = p.proto.nuls[1] = '\0';
3479 120 : p.proto.pid = MyProcPid;
3480 120 : p.proto.flags = 0;
3481 120 : if (dest == LOG_DESTINATION_STDERR)
3482 40 : p.proto.flags |= PIPE_PROTO_DEST_STDERR;
3483 80 : else if (dest == LOG_DESTINATION_CSVLOG)
3484 40 : p.proto.flags |= PIPE_PROTO_DEST_CSVLOG;
3485 40 : else if (dest == LOG_DESTINATION_JSONLOG)
3486 40 : p.proto.flags |= PIPE_PROTO_DEST_JSONLOG;
3487 :
3488 : /* write all but the last chunk */
3489 120 : while (len > PIPE_MAX_PAYLOAD)
3490 : {
3491 : /* no need to set PIPE_PROTO_IS_LAST yet */
3492 0 : p.proto.len = PIPE_MAX_PAYLOAD;
3493 0 : memcpy(p.proto.data, data, PIPE_MAX_PAYLOAD);
3494 0 : rc = write(fd, &p, PIPE_HEADER_SIZE + PIPE_MAX_PAYLOAD);
3495 : (void) rc;
3496 0 : data += PIPE_MAX_PAYLOAD;
3497 0 : len -= PIPE_MAX_PAYLOAD;
3498 : }
3499 :
3500 : /* write the last chunk */
3501 120 : p.proto.flags |= PIPE_PROTO_IS_LAST;
3502 120 : p.proto.len = len;
3503 120 : memcpy(p.proto.data, data, len);
3504 120 : rc = write(fd, &p, PIPE_HEADER_SIZE + len);
3505 : (void) rc;
3506 120 : }
3507 :
3508 :
3509 : /*
3510 : * Append a text string to the error report being built for the client.
3511 : *
3512 : * This is ordinarily identical to pq_sendstring(), but if we are in
3513 : * error recursion trouble we skip encoding conversion, because of the
3514 : * possibility that the problem is a failure in the encoding conversion
3515 : * subsystem itself. Code elsewhere should ensure that the passed-in
3516 : * strings will be plain 7-bit ASCII, and thus not in need of conversion,
3517 : * in such cases. (In particular, we disable localization of error messages
3518 : * to help ensure that's true.)
3519 : */
3520 : static void
3521 1584034 : err_sendstring(StringInfo buf, const char *str)
3522 : {
3523 1584034 : if (in_error_recursion_trouble())
3524 0 : pq_send_ascii_string(buf, str);
3525 : else
3526 1584034 : pq_sendstring(buf, str);
3527 1584034 : }
3528 :
3529 : /*
3530 : * Write error report to client
3531 : */
3532 : static void
3533 199824 : send_message_to_frontend(ErrorData *edata)
3534 : {
3535 : StringInfoData msgbuf;
3536 :
3537 : /*
3538 : * We no longer support pre-3.0 FE/BE protocol, except here. If a client
3539 : * tries to connect using an older protocol version, it's nice to send the
3540 : * "protocol version not supported" error in a format the client
3541 : * understands. If protocol hasn't been set yet, early in backend
3542 : * startup, assume modern protocol.
3543 : */
3544 199824 : if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3 || FrontendProtocol == 0)
3545 199822 : {
3546 : /* New style with separate fields */
3547 : const char *sev;
3548 : char tbuf[12];
3549 :
3550 : /* 'N' (Notice) is for nonfatal conditions, 'E' is for errors */
3551 199822 : if (edata->elevel < ERROR)
3552 156324 : pq_beginmessage(&msgbuf, PqMsg_NoticeResponse);
3553 : else
3554 43498 : pq_beginmessage(&msgbuf, PqMsg_ErrorResponse);
3555 :
3556 199822 : sev = error_severity(edata->elevel);
3557 199822 : pq_sendbyte(&msgbuf, PG_DIAG_SEVERITY);
3558 199822 : err_sendstring(&msgbuf, _(sev));
3559 199822 : pq_sendbyte(&msgbuf, PG_DIAG_SEVERITY_NONLOCALIZED);
3560 199822 : err_sendstring(&msgbuf, sev);
3561 :
3562 199822 : pq_sendbyte(&msgbuf, PG_DIAG_SQLSTATE);
3563 199822 : err_sendstring(&msgbuf, unpack_sql_state(edata->sqlerrcode));
3564 :
3565 : /* M field is required per protocol, so always send something */
3566 199822 : pq_sendbyte(&msgbuf, PG_DIAG_MESSAGE_PRIMARY);
3567 199822 : if (edata->message)
3568 199822 : err_sendstring(&msgbuf, edata->message);
3569 : else
3570 0 : err_sendstring(&msgbuf, _("missing error text"));
3571 :
3572 199822 : if (edata->detail)
3573 : {
3574 10856 : pq_sendbyte(&msgbuf, PG_DIAG_MESSAGE_DETAIL);
3575 10856 : err_sendstring(&msgbuf, edata->detail);
3576 : }
3577 :
3578 : /* detail_log is intentionally not used here */
3579 :
3580 199822 : if (edata->hint)
3581 : {
3582 134714 : pq_sendbyte(&msgbuf, PG_DIAG_MESSAGE_HINT);
3583 134714 : err_sendstring(&msgbuf, edata->hint);
3584 : }
3585 :
3586 199822 : if (edata->context)
3587 : {
3588 17200 : pq_sendbyte(&msgbuf, PG_DIAG_CONTEXT);
3589 17200 : err_sendstring(&msgbuf, edata->context);
3590 : }
3591 :
3592 199822 : if (edata->schema_name)
3593 : {
3594 4238 : pq_sendbyte(&msgbuf, PG_DIAG_SCHEMA_NAME);
3595 4238 : err_sendstring(&msgbuf, edata->schema_name);
3596 : }
3597 :
3598 199822 : if (edata->table_name)
3599 : {
3600 3484 : pq_sendbyte(&msgbuf, PG_DIAG_TABLE_NAME);
3601 3484 : err_sendstring(&msgbuf, edata->table_name);
3602 : }
3603 :
3604 199822 : if (edata->column_name)
3605 : {
3606 552 : pq_sendbyte(&msgbuf, PG_DIAG_COLUMN_NAME);
3607 552 : err_sendstring(&msgbuf, edata->column_name);
3608 : }
3609 :
3610 199822 : if (edata->datatype_name)
3611 : {
3612 764 : pq_sendbyte(&msgbuf, PG_DIAG_DATATYPE_NAME);
3613 764 : err_sendstring(&msgbuf, edata->datatype_name);
3614 : }
3615 :
3616 199822 : if (edata->constraint_name)
3617 : {
3618 2998 : pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_NAME);
3619 2998 : err_sendstring(&msgbuf, edata->constraint_name);
3620 : }
3621 :
3622 199822 : if (edata->cursorpos > 0)
3623 : {
3624 10278 : snprintf(tbuf, sizeof(tbuf), "%d", edata->cursorpos);
3625 10278 : pq_sendbyte(&msgbuf, PG_DIAG_STATEMENT_POSITION);
3626 10278 : err_sendstring(&msgbuf, tbuf);
3627 : }
3628 :
3629 199822 : if (edata->internalpos > 0)
3630 : {
3631 98 : snprintf(tbuf, sizeof(tbuf), "%d", edata->internalpos);
3632 98 : pq_sendbyte(&msgbuf, PG_DIAG_INTERNAL_POSITION);
3633 98 : err_sendstring(&msgbuf, tbuf);
3634 : }
3635 :
3636 199822 : if (edata->internalquery)
3637 : {
3638 98 : pq_sendbyte(&msgbuf, PG_DIAG_INTERNAL_QUERY);
3639 98 : err_sendstring(&msgbuf, edata->internalquery);
3640 : }
3641 :
3642 199822 : if (edata->filename)
3643 : {
3644 199822 : pq_sendbyte(&msgbuf, PG_DIAG_SOURCE_FILE);
3645 199822 : err_sendstring(&msgbuf, edata->filename);
3646 : }
3647 :
3648 199822 : if (edata->lineno > 0)
3649 : {
3650 199822 : snprintf(tbuf, sizeof(tbuf), "%d", edata->lineno);
3651 199822 : pq_sendbyte(&msgbuf, PG_DIAG_SOURCE_LINE);
3652 199822 : err_sendstring(&msgbuf, tbuf);
3653 : }
3654 :
3655 199822 : if (edata->funcname)
3656 : {
3657 199822 : pq_sendbyte(&msgbuf, PG_DIAG_SOURCE_FUNCTION);
3658 199822 : err_sendstring(&msgbuf, edata->funcname);
3659 : }
3660 :
3661 199822 : pq_sendbyte(&msgbuf, '\0'); /* terminator */
3662 :
3663 199822 : pq_endmessage(&msgbuf);
3664 : }
3665 : else
3666 : {
3667 : /* Old style --- gin up a backwards-compatible message */
3668 : StringInfoData buf;
3669 :
3670 2 : initStringInfo(&buf);
3671 :
3672 2 : appendStringInfo(&buf, "%s: ", _(error_severity(edata->elevel)));
3673 :
3674 2 : if (edata->message)
3675 2 : appendStringInfoString(&buf, edata->message);
3676 : else
3677 0 : appendStringInfoString(&buf, _("missing error text"));
3678 :
3679 2 : appendStringInfoChar(&buf, '\n');
3680 :
3681 : /* 'N' (Notice) is for nonfatal conditions, 'E' is for errors */
3682 2 : pq_putmessage_v2((edata->elevel < ERROR) ? 'N' : 'E', buf.data, buf.len + 1);
3683 :
3684 2 : pfree(buf.data);
3685 : }
3686 :
3687 : /*
3688 : * This flush is normally not necessary, since postgres.c will flush out
3689 : * waiting data when control returns to the main loop. But it seems best
3690 : * to leave it here, so that the client has some clue what happened if the
3691 : * backend dies before getting back to the main loop ... error/notice
3692 : * messages should not be a performance-critical path anyway, so an extra
3693 : * flush won't hurt much ...
3694 : */
3695 199824 : pq_flush();
3696 199824 : }
3697 :
3698 :
3699 : /*
3700 : * Support routines for formatting error messages.
3701 : */
3702 :
3703 :
3704 : /*
3705 : * error_severity --- get string representing elevel
3706 : *
3707 : * The string is not localized here, but we mark the strings for translation
3708 : * so that callers can invoke _() on the result.
3709 : */
3710 : const char *
3711 921794 : error_severity(int elevel)
3712 : {
3713 : const char *prefix;
3714 :
3715 921794 : switch (elevel)
3716 : {
3717 31526 : case DEBUG1:
3718 : case DEBUG2:
3719 : case DEBUG3:
3720 : case DEBUG4:
3721 : case DEBUG5:
3722 31526 : prefix = gettext_noop("DEBUG");
3723 31526 : break;
3724 420186 : case LOG:
3725 : case LOG_SERVER_ONLY:
3726 420186 : prefix = gettext_noop("LOG");
3727 420186 : break;
3728 676 : case INFO:
3729 676 : prefix = gettext_noop("INFO");
3730 676 : break;
3731 22330 : case NOTICE:
3732 22330 : prefix = gettext_noop("NOTICE");
3733 22330 : break;
3734 359082 : case WARNING:
3735 : case WARNING_CLIENT_ONLY:
3736 359082 : prefix = gettext_noop("WARNING");
3737 359082 : break;
3738 86262 : case ERROR:
3739 86262 : prefix = gettext_noop("ERROR");
3740 86262 : break;
3741 1732 : case FATAL:
3742 1732 : prefix = gettext_noop("FATAL");
3743 1732 : break;
3744 0 : case PANIC:
3745 0 : prefix = gettext_noop("PANIC");
3746 0 : break;
3747 0 : default:
3748 0 : prefix = "???";
3749 0 : break;
3750 : }
3751 :
3752 921794 : return prefix;
3753 : }
3754 :
3755 :
3756 : /*
3757 : * append_with_tabs
3758 : *
3759 : * Append the string to the StringInfo buffer, inserting a tab after any
3760 : * newline.
3761 : */
3762 : static void
3763 1059720 : append_with_tabs(StringInfo buf, const char *str)
3764 : {
3765 : char ch;
3766 :
3767 202782688 : while ((ch = *str++) != '\0')
3768 : {
3769 201722968 : appendStringInfoCharMacro(buf, ch);
3770 201722968 : if (ch == '\n')
3771 1648516 : appendStringInfoCharMacro(buf, '\t');
3772 : }
3773 1059720 : }
3774 :
3775 :
3776 : /*
3777 : * Write errors to stderr (or by equal means when stderr is
3778 : * not available). Used before ereport/elog can be used
3779 : * safely (memory context, GUC load etc)
3780 : */
3781 : void
3782 0 : write_stderr(const char *fmt,...)
3783 : {
3784 : va_list ap;
3785 :
3786 : #ifdef WIN32
3787 : char errbuf[2048]; /* Arbitrary size? */
3788 : #endif
3789 :
3790 0 : fmt = _(fmt);
3791 :
3792 0 : va_start(ap, fmt);
3793 : #ifndef WIN32
3794 : /* On Unix, we just fprintf to stderr */
3795 0 : vfprintf(stderr, fmt, ap);
3796 0 : fflush(stderr);
3797 : #else
3798 : vsnprintf(errbuf, sizeof(errbuf), fmt, ap);
3799 :
3800 : /*
3801 : * On Win32, we print to stderr if running on a console, or write to
3802 : * eventlog if running as a service
3803 : */
3804 : if (pgwin32_is_service()) /* Running as a service */
3805 : {
3806 : write_eventlog(ERROR, errbuf, strlen(errbuf));
3807 : }
3808 : else
3809 : {
3810 : /* Not running as service, write to stderr */
3811 : write_console(errbuf, strlen(errbuf));
3812 : fflush(stderr);
3813 : }
3814 : #endif
3815 0 : va_end(ap);
3816 0 : }
|
