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