Debian Codegraph @

src/backend/utils/error/elog.c

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