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