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