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