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