#include "postgres.h"
#include <fcntl.h>
#include <time.h>
#include <unistd.h>
#include <signal.h>
#include <ctype.h>
#include "access/xact.h"
#include "libpq/libpq.h"
#include "libpq/pqformat.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "nodes/miscnodes.h"
#include "pgstat.h"
#include "postmaster/bgworker.h"
#include "postmaster/postmaster.h"
#include "postmaster/syslogger.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "tcop/tcopprot.h"
#include "utils/guc_hooks.h"
#include "utils/memutils.h"
#include "utils/ps_status.h"
#include "utils/varlena.h"

Include dependency graph for elog.c:

Macros
#define	_(x) err_gettext(x)

#define	ERRORDATA_STACK_SIZE 5

#define	FORMATTED_TS_LEN 128

#define	CHECK_STACK_DEPTH()

#define	EVALUATE_MESSAGE(domain, targetfield, appendval, translateit)

#define	EVALUATE_MESSAGE_PLURAL(domain, targetfield, appendval)

Functions
static const char *	err_gettext (const char *str) pg_attribute_format_arg(1)

static ErrorData *	get_error_stack_entry (void)

static void	set_stack_entry_domain (ErrorData edata, const char domain)

static void	set_stack_entry_location (ErrorData edata, const char filename, int lineno, const char *funcname)

static bool	matches_backtrace_functions (const char *funcname)

static pg_noinline void	set_backtrace (ErrorData *edata, int num_skip)

static void	set_errdata_field (MemoryContextData cxt, char ptr, const char str)

static void	FreeErrorDataContents (ErrorData *edata)

static void	write_console (const char *line, int len)

static const char *	process_log_prefix_padding (const char p, int ppadding)

static void	log_line_prefix (StringInfo buf, ErrorData *edata)

static void	send_message_to_server_log (ErrorData *edata)

static void	send_message_to_frontend (ErrorData *edata)

static void	append_with_tabs (StringInfo buf, const char *str)

static bool	is_log_level_output (int elevel, int log_min_level)

static bool	should_output_to_server (int elevel)

static bool	should_output_to_client (int elevel)

bool	message_level_is_interesting (int elevel)

bool	in_error_recursion_trouble (void)

pg_attribute_cold bool	errstart_cold (int elevel, const char *domain)

bool	errstart (int elevel, const char *domain)

void	errfinish (const char filename, int lineno, const char funcname)

bool	errsave_start (struct Node context, const char domain)

void	errsave_finish (struct Node context, const char filename, int lineno, const char *funcname)

int	errcode (int sqlerrcode)

int	errcode_for_file_access (void)

int	errcode_for_socket_access (void)

int	errmsg (const char *fmt,...)

int	errbacktrace (void)

int	errmsg_internal (const char *fmt,...)

int	errmsg_plural (const char fmt_singular, const char fmt_plural, unsigned long n,...)

int	errdetail (const char *fmt,...)

int	errdetail_internal (const char *fmt,...)

int	errdetail_log (const char *fmt,...)

int	errdetail_log_plural (const char fmt_singular, const char fmt_plural, unsigned long n,...)

int	errdetail_plural (const char fmt_singular, const char fmt_plural, unsigned long n,...)

int	errhint (const char *fmt,...)

int	errhint_plural (const char fmt_singular, const char fmt_plural, unsigned long n,...)

int	errcontext_msg (const char *fmt,...)

int	set_errcontext_domain (const char *domain)

int	errhidestmt (bool hide_stmt)

int	errhidecontext (bool hide_ctx)

int	errposition (int cursorpos)

int	internalerrposition (int cursorpos)

int	internalerrquery (const char *query)

int	err_generic_string (int field, const char *str)

int	geterrcode (void)

int	geterrlevel (void)

int	geterrposition (void)

int	getinternalerrposition (void)

void	pre_format_elog_string (int errnumber, const char *domain)

char *	format_elog_string (const char *fmt,...)

void	EmitErrorReport (void)

ErrorData *	CopyErrorData (void)

void	FreeErrorData (ErrorData *edata)

void	FlushErrorState (void)

void	ThrowErrorData (ErrorData *edata)

void	ReThrowError (ErrorData *edata)

void	pg_re_throw (void)

char *	GetErrorContextStack (void)

void	DebugFileOpen (void)

bool	check_backtrace_functions (char newval, void extra, GucSource source)

void	assign_backtrace_functions (const char newval, void extra)

bool	check_log_destination (char newval, void extra, GucSource source)

void	assign_log_destination (const char newval, void extra)

void	assign_syslog_ident (const char newval, void extra)

void	assign_syslog_facility (int newval, void *extra)

char *	get_formatted_log_time (void)

void	reset_formatted_start_time (void)

char *	get_formatted_start_time (void)

bool	check_log_of_query (ErrorData *edata)

const char *	get_backend_type_for_log (void)

void	log_status_format (StringInfo buf, const char format, ErrorData edata)

char *	unpack_sql_state (int sql_state)

void	write_pipe_chunks (char *data, int len, int dest)

static void	err_sendstring (StringInfo buf, const char *str)

const char *	error_severity (int elevel)

void	write_stderr (const char *fmt,...)

Variables
ErrorContextCallback *	error_context_stack = NULL

sigjmp_buf *	PG_exception_stack = NULL

emit_log_hook_type	emit_log_hook = NULL

int	Log_error_verbosity = PGERROR_DEFAULT

char *	Log_line_prefix = NULL

int	Log_destination = LOG_DESTINATION_STDERR

char *	Log_destination_string = NULL

bool	syslog_sequence_numbers = true

bool	syslog_split_messages = true

static char *	backtrace_function_list

static ErrorData	errordata [ERRORDATA_STACK_SIZE]

static int	errordata_stack_depth = -1

static int	recursion_depth = 0

static struct timeval	saved_timeval

static bool	saved_timeval_set = false

static char	formatted_start_time [FORMATTED_TS_LEN]

static char	formatted_log_time [FORMATTED_TS_LEN]

static int	save_format_errnumber

static const char *	save_format_domain

Macro Definition Documentation

◆ _

#define _ ( x ) err_gettext(x)

Definition at line 90 of file elog.c.

◆ CHECK_STACK_DEPTH

#define CHECK_STACK_DEPTH ( )

Value:

    do { \
        if (errordata_stack_depth < 0) \
        { \
            errordata_stack_depth = -1; \
            ereport(ERROR, (errmsg_internal("errstart was not called"))); \
        } \
    } while (0)

Definition at line 164 of file elog.c.

◆ ERRORDATA_STACK_SIZE

#define ERRORDATA_STACK_SIZE 5

Definition at line 143 of file elog.c.

◆ EVALUATE_MESSAGE

#define EVALUATE_MESSAGE	(	domain,
		targetfield,
		appendval,
		translateit
	)

Value:

    { \
        StringInfoData  buf; \
        /* Internationalize the error format string */ \
        if ((translateit) && !in_error_recursion_trouble()) \
            fmt = dgettext((domain), fmt);                \
        initStringInfo(&buf); \
        if ((appendval) && edata->targetfield) { \
            appendStringInfoString(&buf, edata->targetfield); \
            appendStringInfoChar(&buf, '\n'); \
        } \
        /* Generate actual output --- have to use appendStringInfoVA */ \
        for (;;) \
        { \
            va_list     args; \
            int         needed; \
            errno = edata->saved_errno; \
            va_start(args, fmt); \
            needed = appendStringInfoVA(&buf, fmt, args); \
            va_end(args); \
            if (needed == 0) \
                break; \
            enlargeStringInfo(&buf, needed); \
        } \
        /* Save the completed message into the stack item */ \
        if (edata->targetfield) \
            pfree(edata->targetfield); \
        edata->targetfield = pstrdup(buf.data); \
        pfree(buf.data); \
    }

Definition at line 989 of file elog.c.

◆ EVALUATE_MESSAGE_PLURAL

#define EVALUATE_MESSAGE_PLURAL	(	domain,
		targetfield,
		appendval
	)

Definition at line 1025 of file elog.c.

◆ FORMATTED_TS_LEN

#define FORMATTED_TS_LEN 128

Definition at line 158 of file elog.c.

Function Documentation

◆ append_with_tabs()

static void append_with_tabs	(	StringInfo	buf,
		const char *	str
	)

static

Definition at line 3722 of file elog.c.

 {
     char        ch;
  
     while ((ch = *str++) != '\0')
     {
         appendStringInfoCharMacro(buf, ch);
         if (ch == '\n')
             appendStringInfoCharMacro(buf, '\t');
     }
 }

References appendStringInfoCharMacro, buf, and str.

Referenced by send_message_to_server_log().

◆ assign_backtrace_functions()

void assign_backtrace_functions	(	const char *	newval,
		void *	extra
	)

Definition at line 2226 of file elog.c.

 {
     backtrace_function_list = (char *) extra;
 }

References backtrace_function_list.

◆ assign_log_destination()

void assign_log_destination	(	const char *	newval,
		void *	extra
	)

Definition at line 2297 of file elog.c.

 {
     Log_destination = *((int *) extra);
 }

References Log_destination.

◆ assign_syslog_facility()

void assign_syslog_facility	(	int	newval,
		void *	extra
	)

Definition at line 2338 of file elog.c.

 {
 #ifdef HAVE_SYSLOG
     /*
      * As above, don't thrash the syslog connection unnecessarily.
      */
     if (syslog_facility != newval)
     {
         if (openlog_done)
         {
             closelog();
             openlog_done = false;
         }
         syslog_facility = newval;
     }
 #endif
     /* Without syslog support, just ignore it */
 }

References newval, and syslog_facility.

◆ assign_syslog_ident()

void assign_syslog_ident	(	const char *	newval,
		void *	extra
	)

Definition at line 2306 of file elog.c.

 {
 #ifdef HAVE_SYSLOG
     /*
      * guc.c is likely to call us repeatedly with same parameters, so don't
      * thrash the syslog connection unnecessarily.  Also, we do not re-open
      * the connection until needed, since this routine will get called whether
      * or not Log_destination actually mentions syslog.
      *
      * Note that we make our own copy of the ident string rather than relying
      * on guc.c's.  This may be overly paranoid, but it ensures that we cannot
      * accidentally free a string that syslog is still using.
      */
     if (syslog_ident == NULL || strcmp(syslog_ident, newval) != 0)
     {
         if (openlog_done)
         {
             closelog();
             openlog_done = false;
         }
         free(syslog_ident);
         syslog_ident = strdup(newval);
         /* if the strdup fails, we will cope in write_syslog() */
     }
 #endif
     /* Without syslog support, just ignore it */
 }

References free, and newval.

◆ check_backtrace_functions()

bool check_backtrace_functions	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 2167 of file elog.c.

 {
     int         newvallen = strlen(*newval);
     char       *someval;
     int         validlen;
     int         i;
     int         j;
  
     /*
      * Allow characters that can be C identifiers and commas as separators, as
      * well as some whitespace for readability.
      */
     validlen = strspn(*newval,
                       "0123456789_"
                       "abcdefghijklmnopqrstuvwxyz"
                       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                       ", \n\t");
     if (validlen != newvallen)
     {
         GUC_check_errdetail("Invalid character");
         return false;
     }
  
     if (*newval[0] == '\0')
     {
         *extra = NULL;
         return true;
     }
  
     /*
      * Allocate space for the output and create the copy.  We could discount
      * whitespace chars to save some memory, but it doesn't seem worth the
      * trouble.
      */
     someval = guc_malloc(ERROR, newvallen + 1 + 1);
     for (i = 0, j = 0; i < newvallen; i++)
     {
         if ((*newval)[i] == ',')
             someval[j++] = '\0';    /* next item */
         else if ((*newval)[i] == ' ' ||
                  (*newval)[i] == '\n' ||
                  (*newval)[i] == '\t')
             ;                   /* ignore these */
         else
             someval[j++] = (*newval)[i];    /* copy anything else */
     }
  
     /* two \0s end the setting */
     someval[j] = '\0';
     someval[j + 1] = '\0';
  
     *extra = someval;
     return true;
 }

References ERROR, GUC_check_errdetail, guc_malloc(), i, j, and newval.

◆ check_log_destination()

bool check_log_destination	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 2235 of file elog.c.

 {
     char       *rawstring;
     List       *elemlist;
     ListCell   *l;
     int         newlogdest = 0;
     int        *myextra;
  
     /* Need a modifiable copy of string */
     rawstring = pstrdup(*newval);
  
     /* Parse string into list of identifiers */
     if (!SplitIdentifierString(rawstring, ',', &elemlist))
     {
         /* syntax error in list */
         GUC_check_errdetail("List syntax is invalid.");
         pfree(rawstring);
         list_free(elemlist);
         return false;
     }
  
     foreach(l, elemlist)
     {
         char       *tok = (char *) lfirst(l);
  
         if (pg_strcasecmp(tok, "stderr") == 0)
             newlogdest |= LOG_DESTINATION_STDERR;
         else if (pg_strcasecmp(tok, "csvlog") == 0)
             newlogdest |= LOG_DESTINATION_CSVLOG;
         else if (pg_strcasecmp(tok, "jsonlog") == 0)
             newlogdest |= LOG_DESTINATION_JSONLOG;
 #ifdef HAVE_SYSLOG
         else if (pg_strcasecmp(tok, "syslog") == 0)
             newlogdest |= LOG_DESTINATION_SYSLOG;
 #endif
 #ifdef WIN32
         else if (pg_strcasecmp(tok, "eventlog") == 0)
             newlogdest |= LOG_DESTINATION_EVENTLOG;
 #endif
         else
         {
             GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
             pfree(rawstring);
             list_free(elemlist);
             return false;
         }
     }
  
     pfree(rawstring);
     list_free(elemlist);
  
     myextra = (int *) guc_malloc(ERROR, sizeof(int));
     *myextra = newlogdest;
     *extra = (void *) myextra;
  
     return true;
 }

References ERROR, GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG_DESTINATION_CSVLOG, LOG_DESTINATION_EVENTLOG, LOG_DESTINATION_JSONLOG, LOG_DESTINATION_STDERR, LOG_DESTINATION_SYSLOG, newval, pfree(), pg_strcasecmp(), pstrdup(), and SplitIdentifierString().

◆ check_log_of_query()

bool check_log_of_query ( ErrorData * edata )

Definition at line 2731 of file elog.c.

 {
     /* log required? */
     if (!is_log_level_output(edata->elevel, log_min_error_statement))
         return false;
  
     /* query log wanted? */
     if (edata->hide_stmt)
         return false;
  
     /* query string available? */
     if (debug_query_string == NULL)
         return false;
  
     return true;
 }

References debug_query_string, ErrorData::elevel, ErrorData::hide_stmt, is_log_level_output(), and log_min_error_statement.

Referenced by send_message_to_server_log(), write_csvlog(), and write_jsonlog().

◆ CopyErrorData()

ErrorData* CopyErrorData ( void )

Definition at line 1746 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     ErrorData  *newedata;
  
     /*
      * we don't increment recursion_depth because out-of-memory here does not
      * indicate a problem within the error subsystem.
      */
     CHECK_STACK_DEPTH();
  
     Assert(CurrentMemoryContext != ErrorContext);
  
     /* Copy the struct itself */
     newedata = (ErrorData *) palloc(sizeof(ErrorData));
     memcpy(newedata, edata, sizeof(ErrorData));
  
     /*
      * Make copies of separately-allocated strings.  Note that we copy even
      * theoretically-constant strings such as filename.  This is because those
      * could point into JIT-created code segments that might get unloaded at
      * transaction cleanup.  In some cases we need the copied ErrorData to
      * survive transaction boundaries, so we'd better copy those strings too.
      */
     if (newedata->filename)
         newedata->filename = pstrdup(newedata->filename);
     if (newedata->funcname)
         newedata->funcname = pstrdup(newedata->funcname);
     if (newedata->domain)
         newedata->domain = pstrdup(newedata->domain);
     if (newedata->context_domain)
         newedata->context_domain = pstrdup(newedata->context_domain);
     if (newedata->message)
         newedata->message = pstrdup(newedata->message);
     if (newedata->detail)
         newedata->detail = pstrdup(newedata->detail);
     if (newedata->detail_log)
         newedata->detail_log = pstrdup(newedata->detail_log);
     if (newedata->hint)
         newedata->hint = pstrdup(newedata->hint);
     if (newedata->context)
         newedata->context = pstrdup(newedata->context);
     if (newedata->backtrace)
         newedata->backtrace = pstrdup(newedata->backtrace);
     if (newedata->message_id)
         newedata->message_id = pstrdup(newedata->message_id);
     if (newedata->schema_name)
         newedata->schema_name = pstrdup(newedata->schema_name);
     if (newedata->table_name)
         newedata->table_name = pstrdup(newedata->table_name);
     if (newedata->column_name)
         newedata->column_name = pstrdup(newedata->column_name);
     if (newedata->datatype_name)
         newedata->datatype_name = pstrdup(newedata->datatype_name);
     if (newedata->constraint_name)
         newedata->constraint_name = pstrdup(newedata->constraint_name);
     if (newedata->internalquery)
         newedata->internalquery = pstrdup(newedata->internalquery);
  
     /* Use the calling context for string allocation */
     newedata->assoc_context = CurrentMemoryContext;
  
     return newedata;
 }

References Assert, ErrorData::assoc_context, ErrorData::backtrace, CHECK_STACK_DEPTH, ErrorData::column_name, ErrorData::constraint_name, ErrorData::context, ErrorData::context_domain, CurrentMemoryContext, ErrorData::datatype_name, ErrorData::detail, ErrorData::detail_log, ErrorData::domain, ErrorContext, errordata, errordata_stack_depth, ErrorData::filename, ErrorData::funcname, ErrorData::hint, ErrorData::internalquery, ErrorData::message, ErrorData::message_id, palloc(), pstrdup(), ErrorData::schema_name, and ErrorData::table_name.

Referenced by _SPI_commit(), _SPI_rollback(), exec_stmt_block(), GetConnection(), initTrie(), plperl_return_next(), plperl_spi_commit(), plperl_spi_exec(), plperl_spi_exec_prepared(), plperl_spi_fetchrow(), plperl_spi_prepare(), plperl_spi_query(), plperl_spi_query_prepared(), plperl_spi_rollback(), plperl_util_elog(), pltcl_commit(), pltcl_elog(), pltcl_rollback(), pltcl_subtrans_abort(), PLy_commit(), PLy_output(), PLy_rollback(), PLy_spi_subtransaction_abort(), and ReorderBufferProcessTXN().

◆ DebugFileOpen()

void DebugFileOpen ( void )

Definition at line 2111 of file elog.c.

 {
     int         fd,
                 istty;
  
     if (OutputFileName[0])
     {
         /*
          * A debug-output file name was given.
          *
          * Make sure we can write the file, and find out if it's a tty.
          */
         if ((fd = open(OutputFileName, O_CREAT | O_APPEND | O_WRONLY,
                        0666)) < 0)
             ereport(FATAL,
                     (errcode_for_file_access(),
                      errmsg("could not open file \"%s\": %m", OutputFileName)));
         istty = isatty(fd);
         close(fd);
  
         /*
          * Redirect our stderr to the debug output file.
          */
         if (!freopen(OutputFileName, "a", stderr))
             ereport(FATAL,
                     (errcode_for_file_access(),
                      errmsg("could not reopen file \"%s\" as stderr: %m",
                             OutputFileName)));
  
         /*
          * If the file is a tty and we're running under the postmaster, try to
          * send stdout there as well (if it isn't a tty then stderr will block
          * out stdout, so we may as well let stdout go wherever it was going
          * before).
          */
         if (istty && IsUnderPostmaster)
             if (!freopen(OutputFileName, "a", stdout))
                 ereport(FATAL,
                         (errcode_for_file_access(),
                          errmsg("could not reopen file \"%s\" as stdout: %m",
                                 OutputFileName)));
     }
 }

References close, ereport, errcode_for_file_access(), errmsg(), FATAL, fd(), IsUnderPostmaster, OutputFileName, and generate_unaccent_rules::stdout.

Referenced by BaseInit().

◆ EmitErrorReport()

void EmitErrorReport ( void )

Definition at line 1687 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     /*
      * Reset the formatted timestamp fields before emitting any logs.  This
      * includes all the log destinations and emit_log_hook, as the latter
      * could use log_line_prefix or the formatted timestamps.
      */
     saved_timeval_set = false;
     formatted_log_time[0] = '\0';
  
     /*
      * Call hook before sending message to log.  The hook function is allowed
      * to turn off edata->output_to_server, so we must recheck that afterward.
      * Making any other change in the content of edata is not considered
      * supported.
      *
      * Note: the reason why the hook can only turn off output_to_server, and
      * not turn it on, is that it'd be unreliable: we will never get here at
      * all if errstart() deems the message uninteresting.  A hook that could
      * make decisions in that direction would have to hook into errstart(),
      * where it would have much less information available.  emit_log_hook is
      * intended for custom log filtering and custom log message transmission
      * mechanisms.
      *
      * The log hook has access to both the translated and original English
      * error message text, which is passed through to allow it to be used as a
      * message identifier. Note that the original text is not available for
      * detail, detail_log, hint and context text elements.
      */
     if (edata->output_to_server && emit_log_hook)
         (*emit_log_hook) (edata);
  
     /* Send to server log, if enabled */
     if (edata->output_to_server)
         send_message_to_server_log(edata);
  
     /* Send to client, if enabled */
     if (edata->output_to_client)
         send_message_to_frontend(edata);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, emit_log_hook, errordata, errordata_stack_depth, formatted_log_time, MemoryContextSwitchTo(), ErrorData::output_to_client, ErrorData::output_to_server, recursion_depth, saved_timeval_set, send_message_to_frontend(), and send_message_to_server_log().

Referenced by AutoVacWorkerMain(), BackgroundWorkerMain(), BackgroundWriterMain(), CheckpointerMain(), DisableSubscriptionAndExit(), do_autovacuum(), errfinish(), perform_work_item(), pgarch_archiveXlog(), PostgresMain(), ReplSlotSyncWorkerMain(), WalSummarizerMain(), and WalWriterMain().

◆ err_generic_string()

int err_generic_string	(	int	field,
		const char *	str
	)

Definition at line 1512 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     switch (field)
     {
         case PG_DIAG_SCHEMA_NAME:
             set_errdata_field(edata->assoc_context, &edata->schema_name, str);
             break;
         case PG_DIAG_TABLE_NAME:
             set_errdata_field(edata->assoc_context, &edata->table_name, str);
             break;
         case PG_DIAG_COLUMN_NAME:
             set_errdata_field(edata->assoc_context, &edata->column_name, str);
             break;
         case PG_DIAG_DATATYPE_NAME:
             set_errdata_field(edata->assoc_context, &edata->datatype_name, str);
             break;
         case PG_DIAG_CONSTRAINT_NAME:
             set_errdata_field(edata->assoc_context, &edata->constraint_name, str);
             break;
         default:
             elog(ERROR, "unsupported ErrorData field id: %d", field);
             break;
     }
  
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::column_name, ErrorData::constraint_name, ErrorData::datatype_name, elog, ERROR, errordata, errordata_stack_depth, PG_DIAG_COLUMN_NAME, PG_DIAG_CONSTRAINT_NAME, PG_DIAG_DATATYPE_NAME, PG_DIAG_SCHEMA_NAME, PG_DIAG_TABLE_NAME, ErrorData::schema_name, set_errdata_field(), str, and ErrorData::table_name.

Referenced by errdatatype(), errdomainconstraint(), errtable(), errtablecolname(), errtableconstraint(), exec_stmt_raise(), PLy_elog_impl(), and PLy_output().

◆ err_gettext()

static const char * err_gettext ( const char * str )

inlinestatic

Definition at line 305 of file elog.c.

 {
 #ifdef ENABLE_NLS
     if (in_error_recursion_trouble())
         return str;
     else
         return gettext(str);
 #else
     return str;
 #endif
 }

References gettext, in_error_recursion_trouble(), and str.

◆ err_sendstring()

static void err_sendstring	(	StringInfo	buf,
		const char *	str
	)

static

Definition at line 3480 of file elog.c.

 {
     if (in_error_recursion_trouble())
         pq_send_ascii_string(buf, str);
     else
         pq_sendstring(buf, str);
 }

References buf, in_error_recursion_trouble(), pq_send_ascii_string(), pq_sendstring(), and str.

Referenced by send_message_to_frontend().

◆ errbacktrace()

int errbacktrace ( void )

Definition at line 1092 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     set_backtrace(edata, 1);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
  
     return 0;
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, errordata, errordata_stack_depth, MemoryContextSwitchTo(), recursion_depth, and set_backtrace().

◆ errcode()

int errcode ( int sqlerrcode )

Definition at line 853 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     edata->sqlerrcode = sqlerrcode;
  
     return 0;                   /* return value does not matter */
 }

References CHECK_STACK_DEPTH, errordata, errordata_stack_depth, and ErrorData::sqlerrcode.

◆ errcode_for_file_access()

int errcode_for_file_access ( void )

Definition at line 876 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     switch (edata->saved_errno)
     {
             /* Permission-denied failures */
         case EPERM:             /* Not super-user */
         case EACCES:            /* Permission denied */
 #ifdef EROFS
         case EROFS:             /* Read only file system */
 #endif
             edata->sqlerrcode = ERRCODE_INSUFFICIENT_PRIVILEGE;
             break;
  
             /* File not found */
         case ENOENT:            /* No such file or directory */
             edata->sqlerrcode = ERRCODE_UNDEFINED_FILE;
             break;
  
             /* Duplicate file */
         case EEXIST:            /* File exists */
             edata->sqlerrcode = ERRCODE_DUPLICATE_FILE;
             break;
  
             /* Wrong object type or state */
         case ENOTDIR:           /* Not a directory */
         case EISDIR:            /* Is a directory */
         case ENOTEMPTY:         /* Directory not empty */
             edata->sqlerrcode = ERRCODE_WRONG_OBJECT_TYPE;
             break;
  
             /* Insufficient resources */
         case ENOSPC:            /* No space left on device */
             edata->sqlerrcode = ERRCODE_DISK_FULL;
             break;
  
         case ENOMEM:            /* Out of memory */
             edata->sqlerrcode = ERRCODE_OUT_OF_MEMORY;
             break;
  
         case ENFILE:            /* File table overflow */
         case EMFILE:            /* Too many open files */
             edata->sqlerrcode = ERRCODE_INSUFFICIENT_RESOURCES;
             break;
  
             /* Hardware failure */
         case EIO:               /* I/O error */
             edata->sqlerrcode = ERRCODE_IO_ERROR;
             break;
  
         case ENAMETOOLONG:      /* File name too long */
             edata->sqlerrcode = ERRCODE_FILE_NAME_TOO_LONG;
             break;
  
             /* All else is classified as internal errors */
         default:
             edata->sqlerrcode = ERRCODE_INTERNAL_ERROR;
             break;
     }
  
     return 0;                   /* return value does not matter */
 }

References CHECK_STACK_DEPTH, errordata, errordata_stack_depth, ErrorData::saved_errno, and ErrorData::sqlerrcode.

Referenced by _mdfd_getseg(), _mdnblocks(), AddToDataDirLockFile(), AlterSystemSetConfigFile(), ApplyLogicalMappingFile(), apw_dump_now(), apw_load_buffers(), assign_wal_sync_method(), basebackup_read_file(), basic_archive_file(), bbsink_server_archive_contents(), bbsink_server_begin_archive(), bbsink_server_begin_manifest(), bbsink_server_end_archive(), bbsink_server_manifest_contents(), bbsink_server_new(), be_lo_export(), BeginCopyFrom(), BeginCopyTo(), BootStrapXLOG(), BufFileDumpBuffer(), BufFileLoadBuffer(), BufFileOpenFileSet(), BufFileReadCommon(), BufFileSeek(), BufFileSize(), BufFileTruncateFileSet(), calculate_relation_size(), calculate_tablespace_size(), ChangeToDataDir(), check_ssl_key_file_permissions(), checkDataDir(), CheckPointLogicalRewriteHeap(), CheckPointReplicationOrigin(), CheckPointSnapBuild(), CheckXLogRemoved(), ClosePipeFromProgram(), ClosePipeToProgram(), ClosePostmasterPorts(), compare_files(), copy_file(), copydir(), CopyGetData(), CopySendEndOfRow(), create_tablespace_directories(), CreateDirAndVersionFile(), CreateLockFile(), CreateOptsFile(), CreateSlotOnDisk(), db_dir_size(), DebugFileOpen(), DeleteAllExportedSnapshotFiles(), destroy_tablespace_directories(), do_pg_backup_stop(), do_truncate(), dsm_cleanup_for_mmap(), dsm_impl_mmap(), durable_rename(), durable_unlink(), EndCopy(), EndCopyFrom(), entry_reset(), errcode_for_dynamic_shared_memory(), ExecHashJoinNewBatch(), existsTimeLineHistory(), ExportSnapshot(), fileAnalyzeForeignTable(), FileClose(), fsync_fname_ext(), gc_qtexts(), get_controlfile_by_exact_path(), get_dirent_type(), GetConfFilesInDir(), getInstallationPaths(), hashagg_batch_read(), heap_xlog_logical_rewrite(), ImportSnapshot(), InitPostgres(), InitPostmasterDeathWatchHandle(), InitWalRecovery(), internal_load_library(), issue_xlog_fsync(), KeepFileRestoredFromArchive(), lo_import_internal(), load_dh_file(), logfile_open(), logical_end_heap_rewrite(), logical_heap_rewrite_flush_mappings(), logical_rewrite_log_mapping(), ltsReadBlock(), ltsWriteBlock(), mdcreate(), mdextend(), mdimmedsync(), mdopenfork(), mdreadv(), mdtruncate(), mdunlinkfork(), mdwritev(), mdzeroextend(), normalize_exec_path(), open_auth_file(), OpenWalSummaryFile(), parse_extension_control_file(), PathNameCreateTemporaryDir(), PathNameCreateTemporaryFile(), PathNameDeleteTemporaryFile(), PathNameOpenTemporaryFile(), perform_base_backup(), pg_current_logfile(), pg_file_exists(), pg_flush_data(), pg_import_system_collations(), pg_ls_dir_files(), pg_promote(), pg_stat_file(), pg_tablespace_databases(), pg_tablespace_location(), pg_tzenumerate_next(), pg_tzenumerate_start(), pgarch_archiveDone(), pgarch_readyXlog(), PGReserveSemaphores(), PGSharedMemoryCreate(), pgss_shmem_shutdown(), pgss_shmem_startup(), pgstat_discard_stats(), pgstat_read_statsfile(), pgstat_write_statsfile(), pipe_read_line(), PostmasterMain(), PrepareRedoAdd(), ProcessSyncRequests(), qtext_load_file(), qtext_store(), read_backup_label(), read_binary_file(), read_relmap_file(), read_tablespace_map(), read_whole_file(), ReadControlFile(), ReadDirExtended(), ReadNextXLogRecord(), readRecoverySignalFile(), readTimeLineHistory(), ReadTwoPhaseFile(), ReadWalSummary(), RecheckDataDirLockFile(), RecreateTwoPhaseFile(), register_dirty_segment(), remove_tablespace_symlink(), RemovePgTempFilesInDir(), RemovePgTempRelationFilesInDbspace(), RemoveTwoPhaseFile(), RemoveWalSummaryIfOlderThan(), RemoveXlogFile(), ReorderBufferCleanupSerializedTXNs(), ReorderBufferRestoreChanges(), ReorderBufferRestoreCleanup(), ReorderBufferSerializeChange(), ReorderBufferSerializeTXN(), ReplicationSlotDropPtr(), ResetUnloggedRelationsInDbspaceDir(), ResetUnloggedRelationsInTablespaceDir(), RestoreArchivedFile(), RestoreSlotFromDisk(), run_ssl_passphrase_command(), SaveSlotToPath(), SendBackupManifest(), sendDir(), sendFile(), sendTablespace(), SendTimeLineHistory(), Setup_AF_UNIX(), shell_finish_command(), shell_run_command(), shell_send_data(), SlruReportIOError(), SnapBuildRestoreContents(), SnapBuildRestoreSnapshot(), SnapBuildSerialize(), SnapBuildSnapshotExists(), StartupReplicationOrigin(), sts_parallel_scan_next(), sts_read_tuple(), SummarizeWAL(), SyncDataDirectory(), SyncPostCheckpoint(), SysLogger_Start(), TablespaceCreateDbspace(), tokenize_auth_file(), tuplestore_copy_read_pointer(), tuplestore_gettuple(), tuplestore_puttuple_common(), tuplestore_rescan(), tuplestore_select_read_pointer(), unlink_if_exists_fname(), unlink_initfile(), update_controlfile(), update_metainfo_datafile(), ValidatePgVersion(), ValidateXLOGDirectoryStructure(), wal_segment_open(), WALReadRaiseError(), WalReceiverMain(), WalSndSegmentOpen(), write_auto_conf_file(), write_item(), write_relcache_init_file(), write_relmap_file(), WriteControlFile(), writeTimeLineHistory(), writeTimeLineHistoryFile(), WriteWalSummary(), XLogArchiveForceDone(), XLogArchiveNotify(), XLogFileClose(), XLogFileCopy(), XLogFileInit(), XLogFileInitInternal(), XLogFileOpen(), XLogFileRead(), XLogFileReadAnyTLI(), XLogInitNewTimeline(), XLogPageRead(), XlogReadTwoPhaseData(), XLogWalRcvClose(), XLogWalRcvWrite(), and XLogWrite().

◆ errcode_for_socket_access()

int errcode_for_socket_access ( void )

Definition at line 953 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     switch (edata->saved_errno)
     {
             /* Loss of connection */
         case ALL_CONNECTION_FAILURE_ERRNOS:
             edata->sqlerrcode = ERRCODE_CONNECTION_FAILURE;
             break;
  
             /* All else is classified as internal errors */
         default:
             edata->sqlerrcode = ERRCODE_INTERNAL_ERROR;
             break;
     }
  
     return 0;                   /* return value does not matter */
 }

References ALL_CONNECTION_FAILURE_ERRNOS, CHECK_STACK_DEPTH, errordata, errordata_stack_depth, ErrorData::saved_errno, and ErrorData::sqlerrcode.

Referenced by AcceptConnection(), auth_peer(), be_tls_open_server(), ident_inet(), InitPostmasterChild(), InitPostmasterDeathWatchHandle(), internal_flush_buffer(), ListenServerPort(), pq_getbyte_if_available(), pq_recvbuf(), ProcessStartupPacket(), SysLogger_Start(), SysLoggerMain(), and WaitEventSetWaitBlock().

◆ errcontext_msg()

int errcontext_msg	(	const char *	fmt,
			...
	)

Definition at line 1365 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     EVALUATE_MESSAGE(edata->context_domain, context, true, true);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, context, ErrorData::context_domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE, MemoryContextSwitchTo(), and recursion_depth.

◆ errdetail()

int errdetail	(	const char *	fmt,
			...
	)

Definition at line 1203 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     EVALUATE_MESSAGE(edata->domain, detail, false, true);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE, MemoryContextSwitchTo(), and recursion_depth.

Referenced by _bt_check_third_page(), _bt_check_unique(), _PG_init(), AbortBufferIO(), AddEnumLabel(), AggregateCreate(), AllocSetContextCreateInternal(), AlterExtensionNamespace(), AlterPublicationOptions(), AlterPublicationSchemas(), AlterRole(), AlterRoleSet(), AlterTableNamespace(), apply_typmod(), apply_typmod_special(), array_cat(), array_fill_internal(), array_in(), array_set_slice(), assignable_custom_variable_name(), asyncQueueFillWarning(), ATAddForeignKeyConstraint(), ATExecAddColumn(), ATExecAddInherit(), ATExecAlterConstraint(), ATExecAttachPartition(), ATExecAttachPartitionIdx(), ATExecChangeOwner(), ATExecCheckNotNull(), ATPrepAlterColumnType(), ATPrepChangePersistence(), AttachPartitionEnsureIndexes(), attribute_statistics_update(), BackendInitialize(), bbsink_server_new(), be_tls_init(), brin_page_type(), bt_entry_unique_check(), bt_page_items_bytea(), bt_report_duplicate(), btree_index_checkable(), build_attrmap_by_name(), build_attrmap_by_position(), BumpContextCreate(), check_conn_params(), check_encoding_locale_matches(), check_exclusion_or_unique_constraint(), check_lateral_ref_ok(), check_nested_generated_walker(), check_new_partition_bound(), check_object_ownership(), check_of_type(), check_primary_key(), check_publication_add_relation(), check_publication_add_schema(), check_role_grantor(), check_role_membership_authorization(), check_sql_fn_retval(), check_ssl_key_file_permissions(), check_valid_extension_name(), check_valid_version_name(), CheckAlterPublication(), CheckCmdReplicaIdentity(), checkDataDir(), checkMembershipInCurrentExtension(), CheckMyDatabase(), CheckPubRelationColumnList(), CheckRecoveryConflictDeadlock(), CheckRequiredParameterValues(), checkRuleResultList(), CheckSlotPermissions(), checkStringLen(), CheckTablespaceDirectory(), CheckVarSlotCompatibility(), choose_hashed_setop(), clear_subscription_skip_lsn(), coerce_record_to_complex(), comparetup_index_btree_tiebreak(), compatConnectbyTupleDescs(), compatCrosstabTupleDescs(), compute_return_type(), ComputeIndexAttrs(), ComputePartitionAttrs(), copy_replication_slot(), copy_table_data(), CopyGetAttnums(), CopyReadAttributesCSV(), CopyReadAttributesText(), countVariablesFromJsonb(), create_distinct_paths(), create_ordinary_grouping_paths(), createdb(), CreateDecodingContext(), CreateRestartPoint(), CreateRole(), CreateSchemaCommand(), CreateSubscription(), CreateTableSpace(), CreateTriggerFiringOn(), crosstab(), crosstab_hash(), cube_a_f8(), cube_a_f8_f8(), cube_c_f8(), cube_c_f8_f8(), cube_recv(), cube_subset(), DateTimeParseError(), dblink_connstr_check(), dblink_fdw_validator(), dblink_security_check(), DCH_from_char(), DefineCollation(), DefineIndex(), DefineOpClass(), DefineOperator(), DefineRelation(), DeleteInheritsTuple(), DoCopy(), DropOwnedObjects(), DropRole(), dsa_allocate_extended(), dshash_create(), EnableLockPagesPrivilege(), encrypt_password(), enforce_generic_type_consistency(), enlargeStringInfo(), EnumValuesCreate(), errdetail_abort(), errdetail_busy_db(), errdetail_execute(), errdetail_params(), errdetail_recovery_conflict(), errdetail_relkind_not_supported(), errorMissingColumn(), errorMissingRTE(), EvaluateParams(), exec_move_row_from_fields(), exec_stmt_dynexecute(), exec_stmt_execsql(), ExecBRInsertTriggers(), ExecBuildUpdateProjection(), ExecCheckPlanOutput(), ExecConstraints(), ExecCrossPartitionUpdate(), ExecCrossPartitionUpdateForeignKey(), ExecEvalArrayExpr(), ExecEvalFieldSelect(), ExecEvalJsonCoercionFinish(), ExecEvalWholeRowVar(), ExecFindPartition(), ExecGrant_Language_check(), ExecPartitionCheckEmitError(), ExecWithCheckOptions(), ExitPostmaster(), expandTableLikeClause(), fatal_llvm_new_handler(), fatal_system_new_handler(), file_fdw_validator(), FindFKPeriodOpers(), finish_nodeitem(), FloatExceptionHandler(), from_char_parse_int_len(), from_char_seq_search(), from_char_set_int(), generate_recursion_path(), generateClonedIndexStmt(), GenerationContextCreate(), get_connect_string(), get_crosstab_tuplestore(), get_page_from_raw(), GetConfigOption(), GetConfigOptionByName(), GetConfigOptionResetString(), getid(), GetOperatorFromWellKnownStrategy(), GetSerializableTransactionSnapshot(), GetSerializableTransactionSnapshotInt(), gin_leafpage_items(), gin_metapage_info(), gin_page_opaque_info(), gistdoinsert(), gistvacuumpage(), HandlePgArchInterrupts(), heap_create(), heap_truncate_check_FKs(), hlparsetext(), incompatible_module_error(), InitializeMaxBackends(), InitPgFdwOptions(), InitPostgres(), InitWalRecovery(), InitXLogReaderState(), instantiate_empty_record_variable(), InternalIpcMemoryCreate(), InternalIpcSemaphoreCreate(), interval_trunc(), jsonb_set_lax(), lazy_check_wraparound_failsafe(), libpqrcv_check_conninfo(), libpqrcv_connect(), libpqrcv_identify_system(), libpqrcv_processTuples(), libpqrcv_readtimelinehistoryfile(), libpqsrv_connect_prepare(), load_categories_hash(), LoadArchiveLibrary(), LogChildExit(), ltxtq_out(), ltxtq_send(), make_pathkeys_for_window(), make_row_comparison_op(), makeMultirangeTypeName(), map_sql_value_to_xml_value(), MarkGUCPrefixReserved(), matchLocks(), MemoryContextAllocationFailure(), MergeAttributes(), MergeChildAttribute(), MergeInheritedAttribute(), multirange_in(), namerecv(), network_in(), network_recv(), NUMDesc_prepare(), parse_extension_control_file(), parse_ident(), parse_lquery(), parse_ltree(), parse_one_reloption(), parserOpenTable(), parsetext(), perform_default_encoding_conversion(), pg_attribute_noreturn(), pg_cancel_backend(), pg_do_encoding_conversion(), pg_get_wal_record_info(), pg_get_wal_records_info_till_end_of_wal(), pg_get_wal_stats_till_end_of_wal(), pg_newlocale_from_collation(), pg_replication_origin_create(), pg_replication_slot_advance(), pg_size_bytes(), pg_terminate_backend(), pg_wal_replay_wait(), pgfdw_security_check(), pgrowlocks(), PGSharedMemoryCreate(), pgstat_register_kind(), plpgsql_post_column_ref(), PLy_exec_function(), PLy_exec_trigger(), PLy_initialize(), PLyUnicode_ToComposite(), populate_array_check_dimension(), PrepareForIncrementalBackup(), PrepareRedoAdd(), preprocess_grouping_sets(), ProcedureCreate(), process_owned_by(), ProcessStartupPacket(), ProcessUtilitySlow(), qtext_load_file(), queryin(), quickdie(), range_parse(), range_parse_bound(), read_any_attr(), read_attr_value(), read_backup_label(), read_client_final_message(), read_client_first_message(), ReadArrayDimensions(), ReadArrayStr(), ReadArrayToken(), ReadControlFile(), ReassignOwnedObjects(), record_in(), recordDependencyOnCurrentExtension(), RecoveryRequiresIntParameter(), refresh_by_match_merge(), refuseDupeIndexAttach(), RegisterCustomRmgr(), ReindexRelationConcurrently(), RememberAllDependentForRebuilding(), RemoveSubscriptionRel(), RenameEnumLabel(), RenameRole(), RenameSchema(), RenameTableSpace(), replace_percent_placeholders(), ReplicationSlotAlter(), ReplicationSlotDrop(), report_newlocale_failure(), RestoreArchivedFile(), rewriteTargetListIU(), rewriteTargetView(), RI_FKey_check(), RI_Initial_Check(), ri_ReportViolation(), scram_exchange(), set_max_safe_fds(), setPath(), SetTransactionSnapshot(), shell_archive_file(), should_apply_changes_for_rel(), SlabContextCreate(), SlruReportIOError(), SnapBuildFindSnapshot(), SnapBuildRestore(), SPI_cursor_open_internal(), standard_ProcessUtility(), StandbySlotsHaveCaughtup(), StartReplication(), StartupDecodingContext(), substitute_grouped_columns_mutator(), SummarizeWAL(), SyncRepWaitForLSN(), TerminateOtherDBBackends(), test_enc_conversion(), tfuncInitialize(), transformAggregateCall(), transformDeclareCursorStmt(), transformIndexConstraint(), transformJsonFuncExpr(), transformJsonTable(), transformMergeStmt(), TransformPubWhereClauses(), transformSetOperationStmt(), tupledesc_match(), update_and_persist_local_synced_slot(), update_local_synced_slot(), vac_cleanup_one_index(), vac_truncate_clog(), validateConnectbyTupleDesc(), ValidateInputLSNs(), ValidatePgVersion(), variable_coerce_param_hook(), verify_brin_page(), verify_gist_page(), verify_hash_page(), verify_message(), WaitForLSNReplay(), WaitForWalSummarization(), WalReceiverMain(), write_relcache_init_file(), XlogReadTwoPhaseData(), xmlpi(), and xpath_table().

◆ errdetail_internal()

int errdetail_internal	(	const char *	fmt,
			...
	)

Definition at line 1230 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     EVALUATE_MESSAGE(edata->domain, detail, false, false);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE, MemoryContextSwitchTo(), and recursion_depth.

Referenced by AggregateCreate(), be_tls_open_server(), bt_check_every_level(), bt_check_level_from_leftmost(), bt_child_check(), bt_child_highkey_check(), bt_downlink_missing_check(), bt_leftmost_ignoring_half_dead(), bt_recheck_sibling_links(), bt_right_page_check_scankey(), bt_target_page_check(), call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), call_string_check_hook(), check_rolespec_name(), check_simple_rowfilter_expr_walker(), CheckForSerializableConflictIn(), CheckForSerializableConflictOut(), CheckForSerializableConflictOutNeeded(), ClosePipeFromProgram(), ClosePipeToProgram(), connect_pg_server(), dblink_connect(), dblink_get_conn(), dblink_res_error(), DeadLockReport(), DropRole(), DropTableSpace(), elog_node_display(), errdetail_apply_conflict(), error_view_not_updatable(), exec_stmt_dynexecute(), exec_stmt_execsql(), exec_stmt_raise(), FreezeMultiXactId(), GetConnection(), incompatible_module_error(), json_errsave_error(), OnConflict_CheckForSerializationFailure(), PageGetItemIdCareful(), parse_one_reloption(), pg_GSS_error(), pgarch_ArchiverCopyLoop(), pgfdw_report_error(), PLy_elog_impl(), PLy_output(), PreCommit_CheckForSerializationFailure(), ProcedureCreate(), reindex_index(), reportDependentObjects(), ReportSlotInvalidation(), rewriteTargetView(), run_ssl_passphrase_command(), shell_finish_command(), ShowUsage(), SnapBuildFindSnapshot(), sts_read_tuple(), synchronize_one_slot(), update_local_synced_slot(), XLogRecordAssemble(), XLogRegisterBufData(), and XLogRegisterData().

◆ errdetail_log()

int errdetail_log	(	const char *	fmt,
			...
	)

Definition at line 1251 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     EVALUATE_MESSAGE(edata->domain, detail_log, false, true);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE, MemoryContextSwitchTo(), and recursion_depth.

Referenced by auth_failed(), check_password(), DeadLockReport(), DropRole(), DropTableSpace(), ProcSleep(), reportDependentObjects(), and set_authn_id().

◆ errdetail_log_plural()

int errdetail_log_plural	(	const char *	fmt_singular,
		const char *	fmt_plural,
		unsigned long	n,
			...
	)

Definition at line 1272 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     EVALUATE_MESSAGE_PLURAL(edata->domain, detail_log, false);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE_PLURAL, MemoryContextSwitchTo(), and recursion_depth.

Referenced by LogRecoveryConflict(), and ProcSleep().

◆ errdetail_plural()

int errdetail_plural	(	const char *	fmt_singular,
		const char *	fmt_plural,
		unsigned long	n,
			...
	)

Definition at line 1295 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     EVALUATE_MESSAGE_PLURAL(edata->domain, detail, false);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE_PLURAL, MemoryContextSwitchTo(), and recursion_depth.

Referenced by check_publications_origin(), dropdb(), errdetail_busy_db(), ExecEvalWholeRowVar(), GetNewMultiXactId(), GetNewOidWithIndex(), RegisterBackgroundWorker(), TerminateOtherDBBackends(), and tupledesc_match().

◆ errfinish()

void errfinish	(	const char *	filename,
		int	lineno,
		const char *	funcname
	)

Definition at line 473 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     int         elevel;
     MemoryContext oldcontext;
     ErrorContextCallback *econtext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
  
     /* Save the last few bits of error state into the stack entry */
     set_stack_entry_location(edata, filename, lineno, funcname);
  
     elevel = edata->elevel;
  
     /*
      * Do processing in ErrorContext, which we hope has enough reserved space
      * to report an error.
      */
     oldcontext = MemoryContextSwitchTo(ErrorContext);
  
     /* Collect backtrace, if enabled and we didn't already */
     if (!edata->backtrace &&
         edata->funcname &&
         backtrace_functions &&
         matches_backtrace_functions(edata->funcname))
         set_backtrace(edata, 2);
  
     /*
      * Call any context callback functions.  Errors occurring in callback
      * functions will be treated as recursive errors --- this ensures we will
      * avoid infinite recursion (see errstart).
      */
     for (econtext = error_context_stack;
          econtext != NULL;
          econtext = econtext->previous)
         econtext->callback(econtext->arg);
  
     /*
      * If ERROR (not more nor less) we pass it off to the current handler.
      * Printing it and popping the stack is the responsibility of the handler.
      */
     if (elevel == ERROR)
     {
         /*
          * We do some minimal cleanup before longjmp'ing so that handlers can
          * execute in a reasonably sane state.
          *
          * Reset InterruptHoldoffCount in case we ereport'd from inside an
          * interrupt holdoff section.  (We assume here that no handler will
          * itself be inside a holdoff section.  If necessary, such a handler
          * could save and restore InterruptHoldoffCount for itself, but this
          * should make life easier for most.)
          */
         InterruptHoldoffCount = 0;
         QueryCancelHoldoffCount = 0;
  
         CritSectionCount = 0;   /* should be unnecessary, but... */
  
         /*
          * Note that we leave CurrentMemoryContext set to ErrorContext. The
          * handler should reset it to something else soon.
          */
  
         recursion_depth--;
         PG_RE_THROW();
     }
  
     /* Emit the message to the right places */
     EmitErrorReport();
  
     /* Now free up subsidiary data attached to stack entry, and release it */
     FreeErrorDataContents(edata);
     errordata_stack_depth--;
  
     /* Exit error-handling context */
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
  
     /*
      * Perform error recovery action as specified by elevel.
      */
     if (elevel == FATAL)
     {
         /*
          * For a FATAL error, we let proc_exit clean up and exit.
          *
          * If we just reported a startup failure, the client will disconnect
          * on receiving it, so don't send any more to the client.
          */
         if (PG_exception_stack == NULL && whereToSendOutput == DestRemote)
             whereToSendOutput = DestNone;
  
         /*
          * fflush here is just to improve the odds that we get to see the
          * error message, in case things are so hosed that proc_exit crashes.
          * Any other code you might be tempted to add here should probably be
          * in an on_proc_exit or on_shmem_exit callback instead.
          */
         fflush(NULL);
  
         /*
          * Let the cumulative stats system know. Only mark the session as
          * terminated by fatal error if there is no other known cause.
          */
         if (pgStatSessionEndCause == DISCONNECT_NORMAL)
             pgStatSessionEndCause = DISCONNECT_FATAL;
  
         /*
          * Do normal process-exit cleanup, then return exit code 1 to indicate
          * FATAL termination.  The postmaster may or may not consider this
          * worthy of panic, depending on which subprocess returns it.
          */
         proc_exit(1);
     }
  
     if (elevel >= PANIC)
     {
         /*
          * Serious crash time. Postmaster will observe SIGABRT process exit
          * status and kill the other backends too.
          *
          * XXX: what if we are *in* the postmaster?  abort() won't kill our
          * children...
          */
         fflush(NULL);
         abort();
     }
  
     /*
      * Check for cancel/die interrupt first --- this is so that the user can
      * stop a query emitting tons of notice or warning messages, even if it's
      * in a loop that otherwise fails to check for interrupts.
      */
     CHECK_FOR_INTERRUPTS();
 }

References ErrorContextCallback::arg, ErrorData::backtrace, backtrace_functions, ErrorContextCallback::callback, CHECK_FOR_INTERRUPTS, CHECK_STACK_DEPTH, CritSectionCount, DestNone, DestRemote, DISCONNECT_FATAL, DISCONNECT_NORMAL, ErrorData::elevel, EmitErrorReport(), ERROR, error_context_stack, ErrorContext, errordata, errordata_stack_depth, FATAL, fflush(), filename, FreeErrorDataContents(), ErrorData::funcname, funcname, InterruptHoldoffCount, matches_backtrace_functions(), MemoryContextSwitchTo(), PANIC, PG_exception_stack, PG_RE_THROW, pgStatSessionEndCause, ErrorContextCallback::previous, proc_exit(), QueryCancelHoldoffCount, recursion_depth, set_backtrace(), set_stack_entry_location(), and whereToSendOutput.

Referenced by errsave_finish(), pg_re_throw(), and ThrowErrorData().

◆ errhidecontext()

int errhidecontext ( bool hide_ctx )

Definition at line 1430 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     edata->hide_ctx = hide_ctx;
  
     return 0;                   /* return value does not matter */
 }

References CHECK_STACK_DEPTH, errordata, errordata_stack_depth, and ErrorData::hide_ctx.

Referenced by llvm_compile_module(), MemoryContextStatsDetail(), MemoryContextStatsInternal(), MemoryContextStatsPrint(), and ProcessLogMemoryContextInterrupt().

◆ errhidestmt()

int errhidestmt ( bool hide_stmt )

Definition at line 1411 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     edata->hide_stmt = hide_stmt;
  
     return 0;                   /* return value does not matter */
 }

References CHECK_STACK_DEPTH, errordata, errordata_stack_depth, and ErrorData::hide_stmt.

Referenced by exec_bind_message(), exec_execute_message(), exec_parse_message(), exec_simple_query(), explain_ExecutorEnd(), llvm_compile_module(), MemoryContextStatsDetail(), MemoryContextStatsInternal(), MemoryContextStatsPrint(), and ProcessLogMemoryContextInterrupt().

◆ errhint()

int errhint	(	const char *	fmt,
			...
	)

Definition at line 1317 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     EVALUATE_MESSAGE(edata->domain, hint, false, true);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE, MemoryContextSwitchTo(), and recursion_depth.

Referenced by _bt_check_third_page(), _bt_check_unique(), _bt_checkpage(), _bt_pagedel(), _hash_checkpage(), _hash_doinsert(), aclparse(), addTargetToSortList(), AlterCollation(), AlterDatabase(), AlterEventTriggerOwner_internal(), AlterForeignDataWrapper(), AlterForeignDataWrapperOwner_internal(), AlterObjectRename_internal(), AlterPublicationOwner_internal(), AlterSubscription(), AlterSubscriptionOwner_internal(), AlterTypeNamespace_oid(), AlterTypeNamespaceInternal(), AlterTypeOwner(), analyzeCTE(), apw_start_database_worker(), apw_start_leader_worker(), assign_collations_walker(), assign_hypothetical_collations(), assignProcTypes(), asyncQueueFillWarning(), AtEOSubXact_SPI(), AtEOXact_SPI(), ATExecAddIdentity(), ATExecAlterConstraint(), ATExecChangeOwner(), ATExecCheckNotNull(), ATExecColumnDefault(), ATExecDropColumn(), ATExecDropIdentity(), ATExecSetIdentity(), ATExecSetRelOptions(), ATExecSetStatistics(), ATPrepAlterColumnType(), ATPrepCmd(), autovac_init(), bbsink_server_archive_contents(), bbsink_server_manifest_contents(), be_tls_open_server(), BeginCopyFrom(), BeginCopyTo(), brin_desummarize_range(), brin_summarize_range(), bt_check_every_level(), bt_entry_unique_check(), bt_index_check_internal(), bt_metap(), bt_target_page_check(), bt_tuple_present_callback(), build_column_default(), call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), call_string_check_hook(), char2wchar(), check_agg_arguments_walker(), check_collation_set(), check_enable_rls(), check_lateral_ref_ok(), check_publications_origin(), check_safe_enum_use(), check_stack_depth(), CheckAttributeType(), CheckCmdReplicaIdentity(), checkDataDir(), CheckForSerializableConflictIn(), CheckForSerializableConflictOut(), CheckForSerializableConflictOutNeeded(), checkJsonOutputFormat(), CheckMyDatabase(), CheckpointerMain(), CheckRequiredParameterValues(), CheckTablespaceDirectory(), checkTimezoneIsUsedForCast(), checkViewColumns(), compileTheLexeme(), ComputeIndexAttrs(), ComputePartitionAttrs(), cookDefault(), copy_replication_slot(), CopyFrom(), CopyReadLineText(), create_ctas_nodata(), create_tablespace_directories(), CreateAccessMethod(), CreateAnonymousSegment(), createdb(), CreateDecodingContext(), CreateEventTrigger(), CreateForeignDataWrapper(), CreateFunction(), CreateLockFile(), CreatePredicateLock(), CreatePublication(), CreateSubscription(), CreateTableSpace(), CreateTriggerFiringOn(), DateTimeParseError(), dblink_fdw_validator(), dblink_res_error(), dblink_security_check(), DeadLockReport(), DefineQueryRewrite(), DefineRange(), DefineType(), DefineView(), DefineVirtualRelation(), DeleteInheritsTuple(), do_compile(), do_pg_backup_start(), do_pg_backup_stop(), do_to_timestamp(), DoCopy(), DoPortalRewind(), DropErrorMsgWrongType(), EnableLockPagesPrivilege(), error_commit_ts_disabled(), error_view_not_updatable(), errorMissingColumn(), errorMissingRTE(), EvaluateParams(), exec_move_row_from_fields(), exec_stmt_case(), exec_stmt_dynexecute(), exec_stmt_execsql(), exec_stmt_raise(), ExecCrossPartitionUpdateForeignKey(), ExecDelete(), ExecGrant_Type_check(), ExecMergeMatched(), ExecOnConflictUpdate(), ExecOpenScanRelation(), ExecUpdate(), execute_extension_script(), executeDateTimeMethod(), ExecuteDoStmt(), ExecuteTruncate(), ExecVacuum(), ExtendBufferedRelShared(), FastPathGetRelationLockEntry(), fetch_finfo_record(), file_fdw_validator(), find_typed_table_dependencies(), findDependentObjects(), findRangeSubOpclass(), forkname_to_number(), from_char_parse_int_len(), from_char_set_mode(), Generic_Text_IC_like(), get_object_address_defacl(), get_raw_page(), get_record_type_from_query(), get_required_extension(), get_sort_group_operators(), getInstallationPaths(), GetNewMultiXactId(), GetNewTransactionId(), GetSerializableTransactionSnapshot(), GetTupleForTrigger(), gin_clean_pending_list(), ginCombineData(), gistcheckpage(), gistdoinsert(), gistUserPicksplit(), gistvacuumpage(), hashbpchar(), hashbpcharextended(), hashtext(), hashtextextended(), heap_create_with_catalog(), heap_force_common(), heap_truncate_check_FKs(), icu_validate_locale(), InitPostgres(), InitWalRecovery(), internal_load_library(), InternalIpcMemoryCreate(), InternalIpcSemaphoreCreate(), intorel_startup(), IpcSemaphoreInitialize(), json_build_object_worker(), jsonb_build_object_worker(), jsonb_set_lax(), jsonb_subscript_transform(), JsonPathQuery(), lazy_check_wraparound_failsafe(), libpqrcv_connect(), libpqsrv_connect_prepare(), like_fixed_prefix(), ListenServerPort(), lock_twophase_recover(), LockAcquireExtended(), LockGXact(), LogChildExit(), logicalrep_worker_launch(), LookupFuncName(), LookupFuncWithArgs(), macaddr8tomacaddr(), make_row_comparison_op(), makeMultirangeTypeName(), MarkAsPreparing(), MarkInheritDetached(), mdextend(), mdwritev(), mdzeroextend(), MergeAttributes(), MergeChildAttribute(), movedb(), OnConflict_CheckForSerializationFailure(), op_error(), palloc_btree_page(), parse_and_validate_value(), parse_extension_control_file(), parse_hba_line(), parse_jsonb_index_flags(), parse_sane_timezone(), ParseFuncOrColumn(), parserOpenTable(), partitioned_table_reloptions(), pg_backup_stop(), pg_base64_decode(), pg_create_restore_point(), pg_current_logfile(), pg_current_wal_flush_lsn(), pg_current_wal_insert_lsn(), pg_current_wal_lsn(), pg_get_wal_replay_pause_state(), pg_is_wal_replay_paused(), pg_log_standby_snapshot(), pg_newlocale_from_collation(), pg_prewarm(), pg_promote(), pg_set_regex_collation(), pg_size_bytes(), pg_stat_reset_shared(), pg_switch_wal(), pg_wal_replay_pause(), pg_wal_replay_resume(), pg_walfile_name(), pg_walfile_name_offset(), pgfdw_report_error(), pgfdw_security_check(), PGSharedMemoryCreate(), pgstat_register_kind(), plan_recursive_revoke(), PLy_elog_impl(), PLy_output(), PLyGenericObject_ToComposite(), PLyMapping_ToComposite(), PLyUnicode_ToComposite(), policy_role_list_to_array(), populate_array_report_expected_array(), PortalRunSelect(), postgres_fdw_validator(), postgresql_fdw_validator(), PostmasterMain(), PreCommit_CheckForSerializationFailure(), PrepareForIncrementalBackup(), PrepareRedoAdd(), ProcedureCreate(), process_owned_by(), process_postgres_switches(), ProcessRecoveryConflictInterrupt(), ProcessStartupPacket(), quickdie(), range_parse_flags(), RangeVarCallbackForAlterRelation(), read_backup_label(), ReadControlFile(), readTimeLineHistory(), recoveryPausesHere(), RecoveryRequiresIntParameter(), recursive_revoke(), RefreshMatViewByOid(), regexp_match(), RegisterBackgroundWorker(), RegisterCustomRmgr(), regoperatorin(), ReindexRelationConcurrently(), ReleaseOneSerializableXact(), RemoveObjects(), RemoveSubscriptionRel(), renametrig(), RenameType(), ReplicationSlotCreate(), ReplicationSlotValidateName(), replorigin_advance(), replorigin_session_setup(), reportDependentObjects(), ReportSlotConnectionError(), ReportSlotInvalidation(), RequestCheckpoint(), ResolveOpClass(), RestoreSlotFromDisk(), RewriteQuery(), rewriteTargetListIU(), rewriteTargetView(), ri_FetchConstraintInfo(), ri_PerformCheck(), RmgrNotFound(), select_common_collation(), sendDir(), SetMultiXactIdLimit(), setPathObject(), SetPossibleUnsafeConflict(), SetRWConflict(), SetTransactionIdLimit(), setup_background_workers(), shell_archive_file(), shell_get_sink(), similar_escape_internal(), spgdoinsert(), spgFormInnerTuple(), StandbySlotsHaveCaughtup(), StartupXLOG(), str_initcap(), str_tolower(), str_toupper(), str_udeescape(), SysLogger_Start(), tblspc_redo(), text_format(), textregexreplace(), transformArrayExpr(), transformAssignedExpr(), transformAssignmentIndirection(), transformCaseExpr(), transformCoalesceExpr(), transformFrameOffset(), transformInsertRow(), transformJsonBehavior(), transformJsonSerializeExpr(), transformOnConflictArbiter(), transformPLAssignStmt(), transformRangeFunction(), transformSetOperationStmt(), transformUpdateTargetList(), transformWindowDefinitions(), unistr(), vacuum_get_cutoffs(), validate_remote_info(), ValidatePgVersion(), validateRecoveryParameters(), verify_heapam(), VirtualXactLock(), WaitForLSNReplay(), WaitForParallelWorkersToAttach(), WaitForParallelWorkersToFinish(), worker_spi_launch(), and WriteWalSummary().

◆ errhint_plural()

int errhint_plural	(	const char *	fmt_singular,
		const char *	fmt_plural,
		unsigned long	n,
			...
	)

Definition at line 1339 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     EVALUATE_MESSAGE_PLURAL(edata->domain, hint, false);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE_PLURAL, MemoryContextSwitchTo(), and recursion_depth.

Referenced by ParseFuncOrColumn().

◆ errmsg()

int errmsg	(	const char *	fmt,
			...
	)

Definition at line 1070 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     edata->message_id = fmt;
     EVALUATE_MESSAGE(edata->domain, message, false, true);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE, fmt, MemoryContextSwitchTo(), ErrorData::message_id, and recursion_depth.

◆ errmsg_internal()

int errmsg_internal	(	const char *	fmt,
			...
	)

Definition at line 1157 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     edata->message_id = fmt;
     EVALUATE_MESSAGE(edata->domain, message, false, false);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE, fmt, MemoryContextSwitchTo(), ErrorData::message_id, and recursion_depth.

Referenced by _bt_binsrch_insert(), _bt_get_endpoint(), _bt_insert_parent(), _bt_insertonpg(), _bt_lock_subtree_parent(), _bt_mark_page_halfdead(), _bt_pagedel(), _bt_preprocess_array_keys_final(), _bt_split(), _bt_unlink_halfdead_page(), _dosmaperr(), AlterSubscription_refresh(), apply_handle_begin_prepare(), apply_handle_commit(), apply_handle_origin(), apply_handle_prepare(), apply_handle_stream_abort(), apply_handle_stream_commit(), apply_handle_stream_prepare(), apply_handle_stream_start(), apply_handle_stream_stop(), ApplyLauncherMain(), apw_dump_now(), ATRewriteTable(), AutoVacWorkerMain(), BackendInitialize(), BackendStartup(), BackgroundWorkerStateChange(), before_shmem_exit(), BeginCopyFrom(), brinGetTupleForHeapBlock(), bt_check_every_level(), bt_check_level_from_leftmost(), bt_downlink_missing_check(), bt_leftmost_ignoring_half_dead(), bt_recheck_sibling_links(), bt_right_page_check_scankey(), bt_target_page_check(), BTreeTupleGetHeapTIDCareful(), btvacuumpage(), build_attrmap_by_position(), byteaout(), call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), call_string_check_hook(), check_agglevels_and_constraints(), check_default_partition_contents(), check_srf_call_placement(), ClosePostmasterPorts(), CompactCheckpointerRequestQueue(), CopyXLogRecordToWAL(), create_and_test_bloom(), CreateCheckPoint(), CreateRestartPoint(), dblink_res_error(), DefineIndex(), do_analyze_rel(), do_start_bgworker(), elog_node_display(), enforce_generic_type_consistency(), exec_bind_message(), exec_parse_message(), exec_replication_command(), exec_stmt_assert(), exec_stmt_raise(), ExecuteRecoveryCommand(), ExitPostmaster(), ForgetBackgroundWorker(), FreezeMultiXactId(), generateSerialExtraStmts(), get_error_stack_entry(), get_object_property_data(), GetConnection(), GetFileBackupMethod(), GetOldestUnsummarizedLSN(), GetSafeSnapshot(), GetWALBlockInfo(), handle_streamed_transaction(), HandleWalSummarizerInterrupts(), hashagg_batch_read(), heap_fetch_toast_slice(), heap_getnext(), heap_inplace_lock(), heap_pre_freeze_checks(), heap_prepare_freeze_tuple(), heap_vacuum_rel(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_tuple_lock(), index_build(), index_delete_check_htid(), info_cb(), InitPostmasterChild(), InitPostmasterDeathWatchHandle(), InitWalRecovery(), InsertOneValue(), inv_seek(), inv_truncate(), IpcSemaphoreInitialize(), issue_xlog_fsync(), llvm_compile_module(), load_critical_index(), load_dh_buffer(), load_libraries(), logicalrep_worker_launch(), lz4_decompress_datum(), lz4_decompress_datum_slice(), manifest_report_error(), MemoryContextStatsDetail(), MemoryContextStatsInternal(), MemoryContextStatsPrint(), NotNullImpliedByRelConstraints(), on_proc_exit(), on_shmem_exit(), palloc_btree_page(), PerformAuthentication(), pg_GSS_error(), pg_tzenumerate_next(), pgfdw_report_error(), pglz_decompress_datum(), pglz_decompress_datum_slice(), PGSharedMemoryCreate(), pgstat_discard_stats(), pgwin32_recv(), pgwin32_signal_initialize(), pgwin32_waitforsinglesocket(), PLy_elog_impl(), PLy_output(), PostmasterMain(), PrepareForIncrementalBackup(), process_pm_child_exit(), process_pm_pmsignal(), process_pm_reload_request(), process_pm_shutdown_request(), ProcessInterrupts(), ProcessSyncRequests(), ProcSleep(), QueuePartitionConstraintValidation(), read_backup_label(), ReadRecord(), register_dirty_segment(), RegisterBackgroundWorker(), RelationCacheInitializePhase3(), RemoveWalSummaryIfOlderThan(), RemoveXlogFile(), reportDependentObjects(), ReportWalSummaryError(), RestoreArchivedFile(), run_apply_worker(), secure_open_server(), SendCancelRequest(), SetMultiXactIdLimit(), SetOffsetVacuumLimit(), SetTransactionIdLimit(), shell_archive_file(), ShowTransactionStateRec(), ShowUsage(), SignalSomeChildren(), sigquit_child(), SlruInternalDeleteSegment(), SnapBuildFindSnapshot(), SocketBackend(), StartupXLOG(), statistic_proc_security_check(), summarizer_read_local_xlog_page(), SummarizeWAL(), synchronize_one_slot(), SyncRepInitConfig(), SysLoggerMain(), transformColumnRef(), transformSubLink(), transformWindowFuncCall(), TranslateSocketError(), TwoPhaseTransactionGid(), update_local_synced_slot(), UpdateMinRecoveryPoint(), vac_update_relstats(), validateForeignKeyConstraint(), verifyBackupPageConsistency(), WalRcvFetchTimeLineHistoryFiles(), WalSndLoop(), WalSummarizerMain(), write_item(), write_relcache_init_file(), XLogPageRead(), XLogReadBufferForRedoExtended(), XLogRecordAssemble(), XLogRegisterBufData(), XLogRegisterData(), XLogWalRcvProcessMsg(), and xml_out_internal().

◆ errmsg_plural()

int errmsg_plural	(	const char *	fmt_singular,
		const char *	fmt_plural,
		unsigned long	n,
			...
	)

Definition at line 1180 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
     MemoryContext oldcontext;
  
     recursion_depth++;
     CHECK_STACK_DEPTH();
     oldcontext = MemoryContextSwitchTo(edata->assoc_context);
  
     edata->message_id = fmt_singular;
     EVALUATE_MESSAGE_PLURAL(edata->domain, message, false);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, ErrorData::domain, errordata, errordata_stack_depth, EVALUATE_MESSAGE_PLURAL, MemoryContextSwitchTo(), ErrorData::message_id, and recursion_depth.

Referenced by AggregateCreate(), check_publications(), CheckpointerMain(), CheckPointTwoPhase(), CopyFrom(), exec_eval_expr(), ExecInitFunc(), ExecuteCallStmt(), file_acquire_sample_rows(), fileEndForeignScan(), func_select_candidate(), GetNewMultiXactId(), GetNewOidWithIndex(), init_sexpr(), logicalrep_report_missing_attrs(), LookupFuncWithArgs(), ParseFuncOrColumn(), perform_base_backup(), pg_promote(), pg_wait_until_termination(), ProcedureCreate(), ReadControlFile(), ReadTwoPhaseFile(), reportDependentObjects(), sendFile(), SetMultiXactIdLimit(), SnapBuildExportSnapshot(), transformPLAssignStmt(), transformRangeTableSample(), and WaitForWalSummarization().

◆ error_severity()

const char* error_severity ( int elevel )

Definition at line 3670 of file elog.c.

 {
     const char *prefix;
  
     switch (elevel)
     {
         case DEBUG1:
         case DEBUG2:
         case DEBUG3:
         case DEBUG4:
         case DEBUG5:
             prefix = gettext_noop("DEBUG");
             break;
         case LOG:
         case LOG_SERVER_ONLY:
             prefix = gettext_noop("LOG");
             break;
         case INFO:
             prefix = gettext_noop("INFO");
             break;
         case NOTICE:
             prefix = gettext_noop("NOTICE");
             break;
         case WARNING:
         case WARNING_CLIENT_ONLY:
             prefix = gettext_noop("WARNING");
             break;
         case ERROR:
             prefix = gettext_noop("ERROR");
             break;
         case FATAL:
             prefix = gettext_noop("FATAL");
             break;
         case PANIC:
             prefix = gettext_noop("PANIC");
             break;
         default:
             prefix = "???";
             break;
     }
  
     return prefix;
 }

References DEBUG1, DEBUG2, DEBUG3, DEBUG4, DEBUG5, ERROR, FATAL, gettext_noop, INFO, LOG, LOG_SERVER_ONLY, NOTICE, PANIC, WARNING, and WARNING_CLIENT_ONLY.

Referenced by send_message_to_frontend(), send_message_to_server_log(), write_csvlog(), and write_jsonlog().

◆ errposition()

int errposition ( int cursorpos )

Definition at line 1446 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     edata->cursorpos = cursorpos;
  
     return 0;                   /* return value does not matter */
 }

References CHECK_STACK_DEPTH, ErrorData::cursorpos, errordata, and errordata_stack_depth.

Referenced by _SPI_error_callback(), executor_errposition(), function_parse_error_transpose(), import_error_callback(), parser_errposition(), script_error_callback(), sql_exec_error_callback(), and sql_inline_error_callback().

◆ errsave_finish()

void errsave_finish	(	struct Node *	context,
		const char *	filename,
		int	lineno,
		const char *	funcname
	)

Definition at line 681 of file elog.c.

 {
     ErrorSaveContext *escontext = (ErrorSaveContext *) context;
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* verify stack depth before accessing *edata */
     CHECK_STACK_DEPTH();
  
     /*
      * If errsave_start punted to errstart, then elevel will be ERROR or
      * perhaps even PANIC.  Punt likewise to errfinish.
      */
     if (edata->elevel >= ERROR)
     {
         errfinish(filename, lineno, funcname);
         pg_unreachable();
     }
  
     /*
      * Else, we should package up the stack entry contents and deliver them to
      * the caller.
      */
     recursion_depth++;
  
     /* Save the last few bits of error state into the stack entry */
     set_stack_entry_location(edata, filename, lineno, funcname);
  
     /* Replace the LOG value that errsave_start inserted */
     edata->elevel = ERROR;
  
     /*
      * We skip calling backtrace and context functions, which are more likely
      * to cause trouble than provide useful context; they might act on the
      * assumption that a transaction abort is about to occur.
      */
  
     /*
      * Make a copy of the error info for the caller.  All the subsidiary
      * strings are already in the caller's context, so it's sufficient to
      * flat-copy the stack entry.
      */
     escontext->error_data = palloc_object(ErrorData);
     memcpy(escontext->error_data, edata, sizeof(ErrorData));
  
     /* Exit error-handling context */
     errordata_stack_depth--;
     recursion_depth--;
 }

References CHECK_STACK_DEPTH, context, ErrorData::elevel, errfinish(), ERROR, ErrorSaveContext::error_data, errordata, errordata_stack_depth, filename, funcname, palloc_object, pg_unreachable, recursion_depth, and set_stack_entry_location().

◆ errsave_start()

bool errsave_start	(	struct Node *	context,
		const char *	domain
	)

Definition at line 629 of file elog.c.

 {
     ErrorSaveContext *escontext;
     ErrorData  *edata;
  
     /*
      * Do we have a context for soft error reporting?  If not, just punt to
      * errstart().
      */
     if (context == NULL || !IsA(context, ErrorSaveContext))
         return errstart(ERROR, domain);
  
     /* Report that a soft error was detected */
     escontext = (ErrorSaveContext *) context;
     escontext->error_occurred = true;
  
     /* Nothing else to do if caller wants no further details */
     if (!escontext->details_wanted)
         return false;
  
     /*
      * Okay, crank up a stack entry to store the info in.
      */
  
     recursion_depth++;
  
     /* Initialize data for this error frame */
     edata = get_error_stack_entry();
     edata->elevel = LOG;        /* signal all is well to errsave_finish */
     set_stack_entry_domain(edata, domain);
     /* Select default errcode based on the assumed elevel of ERROR */
     edata->sqlerrcode = ERRCODE_INTERNAL_ERROR;
  
     /*
      * Any allocations for this error state level should go into the caller's
      * context.  We don't need to pollute ErrorContext, or even require it to
      * exist, in this code path.
      */
     edata->assoc_context = CurrentMemoryContext;
  
     recursion_depth--;
     return true;
 }

References ErrorData::assoc_context, context, CurrentMemoryContext, ErrorSaveContext::details_wanted, ErrorData::elevel, ERROR, ErrorSaveContext::error_occurred, errstart(), get_error_stack_entry(), IsA, LOG, recursion_depth, set_stack_entry_domain(), and ErrorData::sqlerrcode.

◆ errstart()

bool errstart	(	int	elevel,
		const char *	domain
	)

Definition at line 342 of file elog.c.

 {
     ErrorData  *edata;
     bool        output_to_server;
     bool        output_to_client = false;
     int         i;
  
     /*
      * Check some cases in which we want to promote an error into a more
      * severe error.  None of this logic applies for non-error messages.
      */
     if (elevel >= ERROR)
     {
         /*
          * If we are inside a critical section, all errors become PANIC
          * errors.  See miscadmin.h.
          */
         if (CritSectionCount > 0)
             elevel = PANIC;
  
         /*
          * Check reasons for treating ERROR as FATAL:
          *
          * 1. we have no handler to pass the error to (implies we are in the
          * postmaster or in backend startup).
          *
          * 2. ExitOnAnyError mode switch is set (initdb uses this).
          *
          * 3. the error occurred after proc_exit has begun to run.  (It's
          * proc_exit's responsibility to see that this doesn't turn into
          * infinite recursion!)
          */
         if (elevel == ERROR)
         {
             if (PG_exception_stack == NULL ||
                 ExitOnAnyError ||
                 proc_exit_inprogress)
                 elevel = FATAL;
         }
  
         /*
          * If the error level is ERROR or more, errfinish is not going to
          * return to caller; therefore, if there is any stacked error already
          * in progress it will be lost.  This is more or less okay, except we
          * do not want to have a FATAL or PANIC error downgraded because the
          * reporting process was interrupted by a lower-grade error.  So check
          * the stack and make sure we panic if panic is warranted.
          */
         for (i = 0; i <= errordata_stack_depth; i++)
             elevel = Max(elevel, errordata[i].elevel);
     }
  
     /*
      * Now decide whether we need to process this report at all; if it's
      * warning or less and not enabled for logging, just return false without
      * starting up any error logging machinery.
      */
     output_to_server = should_output_to_server(elevel);
     output_to_client = should_output_to_client(elevel);
     if (elevel < ERROR && !output_to_server && !output_to_client)
         return false;
  
     /*
      * We need to do some actual work.  Make sure that memory context
      * initialization has finished, else we can't do anything useful.
      */
     if (ErrorContext == NULL)
     {
         /* Oops, hard crash time; very little we can do safely here */
         write_stderr("error occurred before error message processing is available\n");
         exit(2);
     }
  
     /*
      * Okay, crank up a stack entry to store the info in.
      */
  
     if (recursion_depth++ > 0 && elevel >= ERROR)
     {
         /*
          * Oops, error during error processing.  Clear ErrorContext as
          * discussed at top of file.  We will not return to the original
          * error's reporter or handler, so we don't need it.
          */
         MemoryContextReset(ErrorContext);
  
         /*
          * Infinite error recursion might be due to something broken in a
          * context traceback routine.  Abandon them too.  We also abandon
          * attempting to print the error statement (which, if long, could
          * itself be the source of the recursive failure).
          */
         if (in_error_recursion_trouble())
         {
             error_context_stack = NULL;
             debug_query_string = NULL;
         }
     }
  
     /* Initialize data for this error frame */
     edata = get_error_stack_entry();
     edata->elevel = elevel;
     edata->output_to_server = output_to_server;
     edata->output_to_client = output_to_client;
     set_stack_entry_domain(edata, domain);
     /* Select default errcode based on elevel */
     if (elevel >= ERROR)
         edata->sqlerrcode = ERRCODE_INTERNAL_ERROR;
     else if (elevel >= WARNING)
         edata->sqlerrcode = ERRCODE_WARNING;
     else
         edata->sqlerrcode = ERRCODE_SUCCESSFUL_COMPLETION;
  
     /*
      * Any allocations for this error state level should go into ErrorContext
      */
     edata->assoc_context = ErrorContext;
  
     recursion_depth--;
     return true;
 }

References ErrorData::assoc_context, CritSectionCount, debug_query_string, ErrorData::elevel, ERROR, error_context_stack, ErrorContext, errordata, errordata_stack_depth, exit(), ExitOnAnyError, FATAL, get_error_stack_entry(), i, in_error_recursion_trouble(), Max, MemoryContextReset(), ErrorData::output_to_client, ErrorData::output_to_server, PANIC, PG_exception_stack, proc_exit_inprogress, recursion_depth, set_stack_entry_domain(), should_output_to_client(), should_output_to_server(), ErrorData::sqlerrcode, WARNING, and write_stderr().

Referenced by errsave_start(), errstart_cold(), and ThrowErrorData().

◆ errstart_cold()

pg_attribute_cold bool errstart_cold	(	int	elevel,
		const char *	domain
	)

Definition at line 326 of file elog.c.

 {
     return errstart(elevel, domain);
 }

References errstart().

◆ FlushErrorState()

void FlushErrorState ( void )

Definition at line 1867 of file elog.c.

 {
     /*
      * Reset stack to empty.  The only case where it would be more than one
      * deep is if we serviced an error that interrupted construction of
      * another message.  We assume control escaped out of that message
      * construction and won't ever go back.
      */
     errordata_stack_depth = -1;
     recursion_depth = 0;
     /* Delete all data in ErrorContext */
     MemoryContextReset(ErrorContext);
 }

References ErrorContext, errordata_stack_depth, MemoryContextReset(), and recursion_depth.

Referenced by _SPI_commit(), _SPI_rollback(), BackgroundWriterMain(), call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), call_string_check_hook(), CheckpointerMain(), DisableSubscriptionAndExit(), do_autovacuum(), exec_stmt_block(), GetConnection(), initTrie(), perform_work_item(), pgarch_archiveXlog(), plperl_return_next(), plperl_spi_commit(), plperl_spi_exec(), plperl_spi_exec_prepared(), plperl_spi_fetchrow(), plperl_spi_prepare(), plperl_spi_query(), plperl_spi_query_prepared(), plperl_spi_rollback(), plperl_util_elog(), pltcl_commit(), pltcl_elog(), pltcl_rollback(), pltcl_subtrans_abort(), PLy_commit(), PLy_output(), PLy_rollback(), PLy_spi_subtransaction_abort(), PostgresMain(), ReorderBufferProcessTXN(), WalSummarizerMain(), and WalWriterMain().

◆ format_elog_string()

char* format_elog_string	(	const char *	fmt,
			...
	)

Definition at line 1654 of file elog.c.

 {
     ErrorData   errdata;
     ErrorData  *edata;
     MemoryContext oldcontext;
  
     /* Initialize a mostly-dummy error frame */
     edata = &errdata;
     MemSet(edata, 0, sizeof(ErrorData));
     /* the default text domain is the backend's */
     edata->domain = save_format_domain ? save_format_domain : PG_TEXTDOMAIN("postgres");
     /* set the errno to be used to interpret %m */
     edata->saved_errno = save_format_errnumber;
  
     oldcontext = MemoryContextSwitchTo(ErrorContext);
  
     edata->message_id = fmt;
     EVALUATE_MESSAGE(edata->domain, message, false, true);
  
     MemoryContextSwitchTo(oldcontext);
  
     return edata->message;
 }

References ErrorData::domain, ErrorContext, EVALUATE_MESSAGE, fmt, MemoryContextSwitchTo(), MemSet, ErrorData::message, ErrorData::message_id, PG_TEXTDOMAIN, save_format_domain, save_format_errnumber, and ErrorData::saved_errno.

◆ FreeErrorData()

void FreeErrorData ( ErrorData * edata )

Definition at line 1818 of file elog.c.

 {
     FreeErrorDataContents(edata);
     pfree(edata);
 }

References FreeErrorDataContents(), and pfree().

Referenced by GetConnection(), pltcl_commit(), pltcl_elog(), pltcl_rollback(), pltcl_subtrans_abort(), PLy_commit(), PLy_output(), PLy_rollback(), PLy_spi_subtransaction_abort(), and ReorderBufferProcessTXN().

◆ FreeErrorDataContents()

static void FreeErrorDataContents ( ErrorData * edata )

static

Definition at line 1830 of file elog.c.

 {
     if (edata->message)
         pfree(edata->message);
     if (edata->detail)
         pfree(edata->detail);
     if (edata->detail_log)
         pfree(edata->detail_log);
     if (edata->hint)
         pfree(edata->hint);
     if (edata->context)
         pfree(edata->context);
     if (edata->backtrace)
         pfree(edata->backtrace);
     if (edata->schema_name)
         pfree(edata->schema_name);
     if (edata->table_name)
         pfree(edata->table_name);
     if (edata->column_name)
         pfree(edata->column_name);
     if (edata->datatype_name)
         pfree(edata->datatype_name);
     if (edata->constraint_name)
         pfree(edata->constraint_name);
     if (edata->internalquery)
         pfree(edata->internalquery);
 }

References ErrorData::backtrace, ErrorData::column_name, ErrorData::constraint_name, ErrorData::context, ErrorData::datatype_name, ErrorData::detail, ErrorData::detail_log, ErrorData::hint, ErrorData::internalquery, ErrorData::message, pfree(), ErrorData::schema_name, and ErrorData::table_name.

Referenced by errfinish(), and FreeErrorData().

◆ get_backend_type_for_log()

const char* get_backend_type_for_log ( void )

Definition at line 2754 of file elog.c.

 {
     const char *backend_type_str;
  
     if (MyProcPid == PostmasterPid)
         backend_type_str = "postmaster";
     else if (MyBackendType == B_BG_WORKER)
         backend_type_str = MyBgworkerEntry->bgw_type;
     else
         backend_type_str = GetBackendTypeDesc(MyBackendType);
  
     return backend_type_str;
 }

References B_BG_WORKER, BackgroundWorker::bgw_type, GetBackendTypeDesc(), MyBackendType, MyBgworkerEntry, MyProcPid, and PostmasterPid.

Referenced by log_status_format(), write_csvlog(), and write_jsonlog().

◆ get_error_stack_entry()

static ErrorData * get_error_stack_entry ( void )

static

Definition at line 751 of file elog.c.

 {
     ErrorData  *edata;
  
     /* Allocate error frame */
     errordata_stack_depth++;
     if (unlikely(errordata_stack_depth >= ERRORDATA_STACK_SIZE))
     {
         /* Wups, stack not big enough */
         errordata_stack_depth = -1; /* make room on stack */
         ereport(PANIC, (errmsg_internal("ERRORDATA_STACK_SIZE exceeded")));
     }
  
     /* Initialize error frame to all zeroes/NULLs */
     edata = &errordata[errordata_stack_depth];
     memset(edata, 0, sizeof(ErrorData));
  
     /* Save errno immediately to ensure error parameter eval can't change it */
     edata->saved_errno = errno;
  
     return edata;
 }

References ereport, errmsg_internal(), errordata, errordata_stack_depth, ERRORDATA_STACK_SIZE, PANIC, ErrorData::saved_errno, and unlikely.

Referenced by errsave_start(), errstart(), GetErrorContextStack(), and ReThrowError().

◆ get_formatted_log_time()

char* get_formatted_log_time ( void )

Definition at line 2657 of file elog.c.

 {
     pg_time_t   stamp_time;
     char        msbuf[13];
  
     /* leave if already computed */
     if (formatted_log_time[0] != '\0')
         return formatted_log_time;
  
     if (!saved_timeval_set)
     {
         gettimeofday(&saved_timeval, NULL);
         saved_timeval_set = true;
     }
  
     stamp_time = (pg_time_t) saved_timeval.tv_sec;
  
     /*
      * Note: we expect that guc.c will ensure that log_timezone is set up (at
      * least with a minimal GMT value) before Log_line_prefix can become
      * nonempty or CSV/JSON mode can be selected.
      */
     pg_strftime(formatted_log_time, FORMATTED_TS_LEN,
     /* leave room for milliseconds... */
                 "%Y-%m-%d %H:%M:%S     %Z",
                 pg_localtime(&stamp_time, log_timezone));
  
     /* 'paste' milliseconds into place... */
     sprintf(msbuf, ".%03d", (int) (saved_timeval.tv_usec / 1000));
     memcpy(formatted_log_time + 19, msbuf, 4);
  
     return formatted_log_time;
 }

References formatted_log_time, FORMATTED_TS_LEN, gettimeofday(), log_timezone, pg_localtime(), pg_strftime(), saved_timeval, saved_timeval_set, and sprintf.

Referenced by log_status_format(), write_csvlog(), and write_jsonlog().

◆ get_formatted_start_time()

char* get_formatted_start_time ( void )

Definition at line 2707 of file elog.c.

 {
     pg_time_t   stamp_time = (pg_time_t) MyStartTime;
  
     /* leave if already computed */
     if (formatted_start_time[0] != '\0')
         return formatted_start_time;
  
     /*
      * Note: we expect that guc.c will ensure that log_timezone is set up (at
      * least with a minimal GMT value) before Log_line_prefix can become
      * nonempty or CSV/JSON mode can be selected.
      */
     pg_strftime(formatted_start_time, FORMATTED_TS_LEN,
                 "%Y-%m-%d %H:%M:%S %Z",
                 pg_localtime(&stamp_time, log_timezone));
  
     return formatted_start_time;
 }

References formatted_start_time, FORMATTED_TS_LEN, log_timezone, MyStartTime, pg_localtime(), and pg_strftime().

Referenced by log_status_format(), write_csvlog(), and write_jsonlog().

◆ geterrcode()

int geterrcode ( void )

Definition at line 1561 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     return edata->sqlerrcode;
 }

References CHECK_STACK_DEPTH, errordata, errordata_stack_depth, and ErrorData::sqlerrcode.

Referenced by pcb_error_callback().

◆ geterrlevel()

int geterrlevel ( void )

Definition at line 1578 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     return edata->elevel;
 }

References CHECK_STACK_DEPTH, ErrorData::elevel, errordata, and errordata_stack_depth.

Referenced by apply_error_callback().

◆ GetErrorContextStack()

char* GetErrorContextStack ( void )

Definition at line 2059 of file elog.c.

 {
     ErrorData  *edata;
     ErrorContextCallback *econtext;
  
     /*
      * Crank up a stack entry to store the info in.
      */
     recursion_depth++;
  
     edata = get_error_stack_entry();
  
     /*
      * Set up assoc_context to be the caller's context, so any allocations
      * done (which will include edata->context) will use their context.
      */
     edata->assoc_context = CurrentMemoryContext;
  
     /*
      * Call any context callback functions to collect the context information
      * into edata->context.
      *
      * Errors occurring in callback functions should go through the regular
      * error handling code which should handle any recursive errors, though we
      * double-check above, just in case.
      */
     for (econtext = error_context_stack;
          econtext != NULL;
          econtext = econtext->previous)
         econtext->callback(econtext->arg);
  
     /*
      * Clean ourselves off the stack, any allocations done should have been
      * using edata->assoc_context, which we set up earlier to be the caller's
      * context, so we're free to just remove our entry off the stack and
      * decrement recursion depth and exit.
      */
     errordata_stack_depth--;
     recursion_depth--;
  
     /*
      * Return a pointer to the string the caller asked for, which should have
      * been allocated in their context.
      */
     return edata->context;
 }

References ErrorContextCallback::arg, ErrorData::assoc_context, ErrorContextCallback::callback, ErrorData::context, CurrentMemoryContext, error_context_stack, errordata_stack_depth, get_error_stack_entry(), ErrorContextCallback::previous, and recursion_depth.

Referenced by exec_stmt_getdiag().

◆ geterrposition()

int geterrposition ( void )

Definition at line 1595 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     return edata->cursorpos;
 }

References CHECK_STACK_DEPTH, ErrorData::cursorpos, errordata, and errordata_stack_depth.

Referenced by _SPI_error_callback(), function_parse_error_transpose(), import_error_callback(), script_error_callback(), sql_exec_error_callback(), and sql_inline_error_callback().

◆ getinternalerrposition()

int getinternalerrposition ( void )

Definition at line 1612 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     return edata->internalpos;
 }

References CHECK_STACK_DEPTH, errordata, errordata_stack_depth, and ErrorData::internalpos.

Referenced by function_parse_error_transpose().

◆ in_error_recursion_trouble()

bool in_error_recursion_trouble ( void )

Definition at line 293 of file elog.c.

 {
     /* Pull the plug if recurse more than once */
     return (recursion_depth > 2);
 }

References recursion_depth.

Referenced by err_gettext(), err_sendstring(), errstart(), pgfdw_abort_cleanup(), pgfdw_abort_cleanup_begin(), and write_console().

◆ internalerrposition()

int internalerrposition ( int cursorpos )

Definition at line 1462 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     edata->internalpos = cursorpos;
  
     return 0;                   /* return value does not matter */
 }

References CHECK_STACK_DEPTH, errordata, errordata_stack_depth, and ErrorData::internalpos.

Referenced by _SPI_error_callback(), function_parse_error_transpose(), import_error_callback(), plpgsql_scanner_errposition(), PLy_elog_impl(), script_error_callback(), sql_exec_error_callback(), and sql_inline_error_callback().

◆ internalerrquery()

int internalerrquery ( const char * query )

Definition at line 1482 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     if (edata->internalquery)
     {
         pfree(edata->internalquery);
         edata->internalquery = NULL;
     }
  
     if (query)
         edata->internalquery = MemoryContextStrdup(edata->assoc_context, query);
  
     return 0;                   /* return value does not matter */
 }

References ErrorData::assoc_context, CHECK_STACK_DEPTH, errordata, errordata_stack_depth, ErrorData::internalquery, MemoryContextStrdup(), and pfree().

Referenced by _SPI_error_callback(), function_parse_error_transpose(), import_error_callback(), plpgsql_scanner_errposition(), PLy_elog_impl(), script_error_callback(), sql_exec_error_callback(), and sql_inline_error_callback().

◆ is_log_level_output()

static bool is_log_level_output	(	int	elevel,
		int	log_min_level
	)

inlinestatic

Definition at line 201 of file elog.c.

 {
     if (elevel == LOG || elevel == LOG_SERVER_ONLY)
     {
         if (log_min_level == LOG || log_min_level <= ERROR)
             return true;
     }
     else if (elevel == WARNING_CLIENT_ONLY)
     {
         /* never sent to log, regardless of log_min_level */
         return false;
     }
     else if (log_min_level == LOG)
     {
         /* elevel != LOG */
         if (elevel >= FATAL)
             return true;
     }
     /* Neither is LOG */
     else if (elevel >= log_min_level)
         return true;
  
     return false;
 }

References ERROR, FATAL, LOG, LOG_SERVER_ONLY, and WARNING_CLIENT_ONLY.

Referenced by check_log_of_query(), and should_output_to_server().

◆ log_line_prefix()

static void log_line_prefix	(	StringInfo	buf,
		ErrorData *	edata
	)

static

Definition at line 2807 of file elog.c.

 {
     log_status_format(buf, Log_line_prefix, edata);
 }

References buf, Log_line_prefix, and log_status_format().

Referenced by send_message_to_server_log().

◆ log_status_format()

void log_status_format	(	StringInfo	buf,
		const char *	format,
		ErrorData *	edata
	)

Definition at line 2816 of file elog.c.

 {
     /* static counter for line numbers */
     static long log_line_number = 0;
  
     /* has counter been reset in current process? */
     static int  log_my_pid = 0;
     int         padding;
     const char *p;
  
     /*
      * This is one of the few places where we'd rather not inherit a static
      * variable's value from the postmaster.  But since we will, reset it when
      * MyProcPid changes. MyStartTime also changes when MyProcPid does, so
      * reset the formatted start timestamp too.
      */
     if (log_my_pid != MyProcPid)
     {
         log_line_number = 0;
         log_my_pid = MyProcPid;
         reset_formatted_start_time();
     }
     log_line_number++;
  
     if (format == NULL)
         return;                 /* in case guc hasn't run yet */
  
     for (p = format; *p != '\0'; p++)
     {
         if (*p != '%')
         {
             /* literal char, just copy */
             appendStringInfoChar(buf, *p);
             continue;
         }
  
         /* must be a '%', so skip to the next char */
         p++;
         if (*p == '\0')
             break;              /* format error - ignore it */
         else if (*p == '%')
         {
             /* string contains %% */
             appendStringInfoChar(buf, '%');
             continue;
         }
  
  
         /*
          * Process any formatting which may exist after the '%'.  Note that
          * process_log_prefix_padding moves p past the padding number if it
          * exists.
          *
          * Note: Since only '-', '0' to '9' are valid formatting characters we
          * can do a quick check here to pre-check for formatting. If the char
          * is not formatting then we can skip a useless function call.
          *
          * Further note: At least on some platforms, passing %*s rather than
          * %s to appendStringInfo() is substantially slower, so many of the
          * cases below avoid doing that unless non-zero padding is in fact
          * specified.
          */
         if (*p > '9')
             padding = 0;
         else if ((p = process_log_prefix_padding(p, &padding)) == NULL)
             break;
  
         /* process the option */
         switch (*p)
         {
             case 'a':
                 if (MyProcPort)
                 {
                     const char *appname = application_name;
  
                     if (appname == NULL || *appname == '\0')
                         appname = _("[unknown]");
                     if (padding != 0)
                         appendStringInfo(buf, "%*s", padding, appname);
                     else
                         appendStringInfoString(buf, appname);
                 }
                 else if (padding != 0)
                     appendStringInfoSpaces(buf,
                                            padding > 0 ? padding : -padding);
  
                 break;
             case 'b':
                 {
                     const char *backend_type_str = get_backend_type_for_log();
  
                     if (padding != 0)
                         appendStringInfo(buf, "%*s", padding, backend_type_str);
                     else
                         appendStringInfoString(buf, backend_type_str);
                     break;
                 }
             case 'u':
                 if (MyProcPort)
                 {
                     const char *username = MyProcPort->user_name;
  
                     if (username == NULL || *username == '\0')
                         username = _("[unknown]");
                     if (padding != 0)
                         appendStringInfo(buf, "%*s", padding, username);
                     else
                         appendStringInfoString(buf, username);
                 }
                 else if (padding != 0)
                     appendStringInfoSpaces(buf,
                                            padding > 0 ? padding : -padding);
                 break;
             case 'd':
                 if (MyProcPort)
                 {
                     const char *dbname = MyProcPort->database_name;
  
                     if (dbname == NULL || *dbname == '\0')
                         dbname = _("[unknown]");
                     if (padding != 0)
                         appendStringInfo(buf, "%*s", padding, dbname);
                     else
                         appendStringInfoString(buf, dbname);
                 }
                 else if (padding != 0)
                     appendStringInfoSpaces(buf,
                                            padding > 0 ? padding : -padding);
                 break;
             case 'c':
                 if (padding != 0)
                 {
                     char        strfbuf[128];
  
                     snprintf(strfbuf, sizeof(strfbuf) - 1, "%" INT64_MODIFIER "x.%x",
                              MyStartTime, MyProcPid);
                     appendStringInfo(buf, "%*s", padding, strfbuf);
                 }
                 else
                     appendStringInfo(buf, "%" INT64_MODIFIER "x.%x", MyStartTime, MyProcPid);
                 break;
             case 'p':
                 if (padding != 0)
                     appendStringInfo(buf, "%*d", padding, MyProcPid);
                 else
                     appendStringInfo(buf, "%d", MyProcPid);
                 break;
  
             case 'P':
                 if (MyProc)
                 {
                     PGPROC     *leader = MyProc->lockGroupLeader;
  
                     /*
                      * Show the leader only for active parallel workers. This
                      * leaves out the leader of a parallel group.
                      */
                     if (leader == NULL || leader->pid == MyProcPid)
                         appendStringInfoSpaces(buf,
                                                padding > 0 ? padding : -padding);
                     else if (padding != 0)
                         appendStringInfo(buf, "%*d", padding, leader->pid);
                     else
                         appendStringInfo(buf, "%d", leader->pid);
                 }
                 else if (padding != 0)
                     appendStringInfoSpaces(buf,
                                            padding > 0 ? padding : -padding);
                 break;
  
             case 'l':
                 if (padding != 0)
                     appendStringInfo(buf, "%*ld", padding, log_line_number);
                 else
                     appendStringInfo(buf, "%ld", log_line_number);
                 break;
             case 'm':
                 /* force a log timestamp reset */
                 formatted_log_time[0] = '\0';
                 (void) get_formatted_log_time();
  
                 if (padding != 0)
                     appendStringInfo(buf, "%*s", padding, formatted_log_time);
                 else
                     appendStringInfoString(buf, formatted_log_time);
                 break;
             case 't':
                 {
                     pg_time_t   stamp_time = (pg_time_t) time(NULL);
                     char        strfbuf[128];
  
                     pg_strftime(strfbuf, sizeof(strfbuf),
                                 "%Y-%m-%d %H:%M:%S %Z",
                                 pg_localtime(&stamp_time, log_timezone));
                     if (padding != 0)
                         appendStringInfo(buf, "%*s", padding, strfbuf);
                     else
                         appendStringInfoString(buf, strfbuf);
                 }
                 break;
             case 'n':
                 {
                     char        strfbuf[128];
  
                     if (!saved_timeval_set)
                     {
                         gettimeofday(&saved_timeval, NULL);
                         saved_timeval_set = true;
                     }
  
                     snprintf(strfbuf, sizeof(strfbuf), "%ld.%03d",
                              (long) saved_timeval.tv_sec,
                              (int) (saved_timeval.tv_usec / 1000));
  
                     if (padding != 0)
                         appendStringInfo(buf, "%*s", padding, strfbuf);
                     else
                         appendStringInfoString(buf, strfbuf);
                 }
                 break;
             case 's':
                 {
                     char       *start_time = get_formatted_start_time();
  
                     if (padding != 0)
                         appendStringInfo(buf, "%*s", padding, start_time);
                     else
                         appendStringInfoString(buf, start_time);
                 }
                 break;
             case 'i':
                 if (MyProcPort)
                 {
                     const char *psdisp;
                     int         displen;
  
                     psdisp = get_ps_display(&displen);
                     if (padding != 0)
                         appendStringInfo(buf, "%*s", padding, psdisp);
                     else
                         appendBinaryStringInfo(buf, psdisp, displen);
                 }
                 else if (padding != 0)
                     appendStringInfoSpaces(buf,
                                            padding > 0 ? padding : -padding);
                 break;
             case 'r':
                 if (MyProcPort && MyProcPort->remote_host)
                 {
                     if (padding != 0)
                     {
                         if (MyProcPort->remote_port && MyProcPort->remote_port[0] != '\0')
                         {
                             /*
                              * This option is slightly special as the port
                              * number may be appended onto the end. Here we
                              * need to build 1 string which contains the
                              * remote_host and optionally the remote_port (if
                              * set) so we can properly align the string.
                              */
  
                             char       *hostport;
  
                             hostport = psprintf("%s(%s)", MyProcPort->remote_host, MyProcPort->remote_port);
                             appendStringInfo(buf, "%*s", padding, hostport);
                             pfree(hostport);
                         }
                         else
                             appendStringInfo(buf, "%*s", padding, MyProcPort->remote_host);
                     }
                     else
                     {
                         /* padding is 0, so we don't need a temp buffer */
                         appendStringInfoString(buf, MyProcPort->remote_host);
                         if (MyProcPort->remote_port &&
                             MyProcPort->remote_port[0] != '\0')
                             appendStringInfo(buf, "(%s)",
                                              MyProcPort->remote_port);
                     }
                 }
                 else if (padding != 0)
                     appendStringInfoSpaces(buf,
                                            padding > 0 ? padding : -padding);
                 break;
             case 'h':
                 if (MyProcPort && MyProcPort->remote_host)
                 {
                     if (padding != 0)
                         appendStringInfo(buf, "%*s", padding, MyProcPort->remote_host);
                     else
                         appendStringInfoString(buf, MyProcPort->remote_host);
                 }
                 else if (padding != 0)
                     appendStringInfoSpaces(buf,
                                            padding > 0 ? padding : -padding);
                 break;
             case 'q':
                 /* in postmaster and friends, stop if %q is seen */
                 /* in a backend, just ignore */
                 if (MyProcPort == NULL)
                     return;
                 break;
             case 'v':
                 /* keep VXID format in sync with lockfuncs.c */
                 if (MyProc != NULL && MyProc->vxid.procNumber != INVALID_PROC_NUMBER)
                 {
                     if (padding != 0)
                     {
                         char        strfbuf[128];
  
                         snprintf(strfbuf, sizeof(strfbuf) - 1, "%d/%u",
                                  MyProc->vxid.procNumber, MyProc->vxid.lxid);
                         appendStringInfo(buf, "%*s", padding, strfbuf);
                     }
                     else
                         appendStringInfo(buf, "%d/%u", MyProc->vxid.procNumber, MyProc->vxid.lxid);
                 }
                 else if (padding != 0)
                     appendStringInfoSpaces(buf,
                                            padding > 0 ? padding : -padding);
                 break;
             case 'x':
                 if (padding != 0)
                     appendStringInfo(buf, "%*u", padding, GetTopTransactionIdIfAny());
                 else
                     appendStringInfo(buf, "%u", GetTopTransactionIdIfAny());
                 break;
             case 'e':
                 if (padding != 0)
                     appendStringInfo(buf, "%*s", padding, unpack_sql_state(edata->sqlerrcode));
                 else
                     appendStringInfoString(buf, unpack_sql_state(edata->sqlerrcode));
                 break;
             case 'Q':
                 if (padding != 0)
                     appendStringInfo(buf, "%*lld", padding,
                                      (long long) pgstat_get_my_query_id());
                 else
                     appendStringInfo(buf, "%lld",
                                      (long long) pgstat_get_my_query_id());
                 break;
             default:
                 /* format error - ignore it */
                 break;
         }
     }
 }

References _, appendBinaryStringInfo(), appendStringInfo(), appendStringInfoChar(), appendStringInfoSpaces(), appendStringInfoString(), application_name, buf, Port::database_name, dbname, format, formatted_log_time, get_backend_type_for_log(), get_formatted_log_time(), get_formatted_start_time(), get_ps_display(), gettimeofday(), GetTopTransactionIdIfAny(), INVALID_PROC_NUMBER, PGPROC::lockGroupLeader, log_timezone, PGPROC::lxid, MyProc, MyProcPid, MyProcPort, MyStartTime, pfree(), pg_localtime(), pg_strftime(), pgstat_get_my_query_id(), PGPROC::pid, process_log_prefix_padding(), PGPROC::procNumber, psprintf(), Port::remote_host, Port::remote_port, reset_formatted_start_time(), saved_timeval, saved_timeval_set, snprintf, ErrorData::sqlerrcode, start_time, unpack_sql_state(), Port::user_name, username, and PGPROC::vxid.

Referenced by log_line_prefix().

◆ matches_backtrace_functions()

static bool matches_backtrace_functions ( const char * funcname )

static

Definition at line 825 of file elog.c.

 {
     const char *p;
  
     if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
         return false;
  
     p = backtrace_function_list;
     for (;;)
     {
         if (*p == '\0')         /* end of backtrace_function_list */
             break;
  
         if (strcmp(funcname, p) == 0)
             return true;
         p += strlen(p) + 1;
     }
  
     return false;
 }

References backtrace_function_list, and funcname.

Referenced by errfinish().

◆ message_level_is_interesting()

bool message_level_is_interesting ( int elevel )

Definition at line 272 of file elog.c.

 {
     /*
      * Keep this in sync with the decision-making in errstart().
      */
     if (elevel >= ERROR ||
         should_output_to_server(elevel) ||
         should_output_to_client(elevel))
         return true;
     return false;
 }

References ERROR, should_output_to_client(), and should_output_to_server().

Referenced by forget_invalid_pages(), forget_invalid_pages_db(), log_invalid_page(), ProcessStandbyHSFeedbackMessage(), ProcessStandbyReplyMessage(), ProcessWalSndrMessage(), ProcSleep(), reportDependentObjects(), ShowTransactionState(), and VacuumUpdateCosts().

◆ pg_re_throw()

void pg_re_throw ( void )

Definition at line 2004 of file elog.c.

 {
     /* If possible, throw the error to the next outer setjmp handler */
     if (PG_exception_stack != NULL)
         siglongjmp(*PG_exception_stack, 1);
     else
     {
         /*
          * If we get here, elog(ERROR) was thrown inside a PG_TRY block, which
          * we have now exited only to discover that there is no outer setjmp
          * handler to pass the error to.  Had the error been thrown outside
          * the block to begin with, we'd have promoted the error to FATAL, so
          * the correct behavior is to make it FATAL now; that is, emit it and
          * then call proc_exit.
          */
         ErrorData  *edata = &errordata[errordata_stack_depth];
  
         Assert(errordata_stack_depth >= 0);
         Assert(edata->elevel == ERROR);
         edata->elevel = FATAL;
  
         /*
          * At least in principle, the increase in severity could have changed
          * where-to-output decisions, so recalculate.
          */
         edata->output_to_server = should_output_to_server(FATAL);
         edata->output_to_client = should_output_to_client(FATAL);
  
         /*
          * We can use errfinish() for the rest, but we don't want it to call
          * any error context routines a second time.  Since we know we are
          * about to exit, it should be OK to just clear the context stack.
          */
         error_context_stack = NULL;
  
         errfinish(edata->filename, edata->lineno, edata->funcname);
     }
  
     /* Doesn't return ... */
     ExceptionalCondition("pg_re_throw tried to return", __FILE__, __LINE__);
 }

References Assert, ErrorData::elevel, errfinish(), ERROR, error_context_stack, errordata, errordata_stack_depth, ExceptionalCondition(), FATAL, ErrorData::filename, ErrorData::funcname, ErrorData::lineno, ErrorData::output_to_client, ErrorData::output_to_server, PG_exception_stack, should_output_to_client(), and should_output_to_server().

◆ pre_format_elog_string()

void pre_format_elog_string	(	int	errnumber,
		const char *	domain
	)

Definition at line 1645 of file elog.c.

 {
     /* Save errno before evaluation of argument functions can change it */
     save_format_errnumber = errnumber;
     /* Save caller's text domain */
     save_format_domain = domain;
 }

References save_format_domain, and save_format_errnumber.

◆ process_log_prefix_padding()

static const char * process_log_prefix_padding	(	const char *	p,
		int *	ppadding
	)

static

Definition at line 2776 of file elog.c.

 {
     int         paddingsign = 1;
     int         padding = 0;
  
     if (*p == '-')
     {
         p++;
  
         if (*p == '\0')         /* Did the buf end in %- ? */
             return NULL;
         paddingsign = -1;
     }
  
     /* generate an int version of the numerical string */
     while (*p >= '0' && *p <= '9')
         padding = padding * 10 + (*p++ - '0');
  
     /* format is invalid if it ends with the padding number */
     if (*p == '\0')
         return NULL;
  
     padding *= paddingsign;
     *ppadding = padding;
     return p;
 }

Referenced by log_status_format().

◆ reset_formatted_start_time()

void reset_formatted_start_time ( void )

Definition at line 2695 of file elog.c.

 {
     formatted_start_time[0] = '\0';
 }

References formatted_start_time.

Referenced by log_status_format(), write_csvlog(), and write_jsonlog().

◆ ReThrowError()

void ReThrowError ( ErrorData * edata )

Definition at line 1954 of file elog.c.

 {
     ErrorData  *newedata;
  
     Assert(edata->elevel == ERROR);
  
     /* Push the data back into the error context */
     recursion_depth++;
     MemoryContextSwitchTo(ErrorContext);
  
     newedata = get_error_stack_entry();
     memcpy(newedata, edata, sizeof(ErrorData));
  
     /* Make copies of separately-allocated fields */
     if (newedata->message)
         newedata->message = pstrdup(newedata->message);
     if (newedata->detail)
         newedata->detail = pstrdup(newedata->detail);
     if (newedata->detail_log)
         newedata->detail_log = pstrdup(newedata->detail_log);
     if (newedata->hint)
         newedata->hint = pstrdup(newedata->hint);
     if (newedata->context)
         newedata->context = pstrdup(newedata->context);
     if (newedata->backtrace)
         newedata->backtrace = pstrdup(newedata->backtrace);
     if (newedata->schema_name)
         newedata->schema_name = pstrdup(newedata->schema_name);
     if (newedata->table_name)
         newedata->table_name = pstrdup(newedata->table_name);
     if (newedata->column_name)
         newedata->column_name = pstrdup(newedata->column_name);
     if (newedata->datatype_name)
         newedata->datatype_name = pstrdup(newedata->datatype_name);
     if (newedata->constraint_name)
         newedata->constraint_name = pstrdup(newedata->constraint_name);
     if (newedata->internalquery)
         newedata->internalquery = pstrdup(newedata->internalquery);
  
     /* Reset the assoc_context to be ErrorContext */
     newedata->assoc_context = ErrorContext;
  
     recursion_depth--;
     PG_RE_THROW();
 }

References Assert, ErrorData::assoc_context, ErrorData::backtrace, ErrorData::column_name, ErrorData::constraint_name, ErrorData::context, ErrorData::datatype_name, ErrorData::detail, ErrorData::detail_log, ErrorData::elevel, ERROR, ErrorContext, get_error_stack_entry(), ErrorData::hint, ErrorData::internalquery, MemoryContextSwitchTo(), ErrorData::message, PG_RE_THROW, pstrdup(), recursion_depth, ErrorData::schema_name, and ErrorData::table_name.

Referenced by _SPI_commit(), _SPI_rollback(), exec_stmt_block(), and exec_stmt_raise().

◆ send_message_to_frontend()

static void send_message_to_frontend ( ErrorData * edata )

static

Definition at line 3492 of file elog.c.

 {
     StringInfoData msgbuf;
  
     /*
      * We no longer support pre-3.0 FE/BE protocol, except here.  If a client
      * tries to connect using an older protocol version, it's nice to send the
      * "protocol version not supported" error in a format the client
      * understands.  If protocol hasn't been set yet, early in backend
      * startup, assume modern protocol.
      */
     if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3 || FrontendProtocol == 0)
     {
         /* New style with separate fields */
         const char *sev;
         char        tbuf[12];
  
         /* 'N' (Notice) is for nonfatal conditions, 'E' is for errors */
         if (edata->elevel < ERROR)
             pq_beginmessage(&msgbuf, PqMsg_NoticeResponse);
         else
             pq_beginmessage(&msgbuf, PqMsg_ErrorResponse);
  
         sev = error_severity(edata->elevel);
         pq_sendbyte(&msgbuf, PG_DIAG_SEVERITY);
         err_sendstring(&msgbuf, _(sev));
         pq_sendbyte(&msgbuf, PG_DIAG_SEVERITY_NONLOCALIZED);
         err_sendstring(&msgbuf, sev);
  
         pq_sendbyte(&msgbuf, PG_DIAG_SQLSTATE);
         err_sendstring(&msgbuf, unpack_sql_state(edata->sqlerrcode));
  
         /* M field is required per protocol, so always send something */
         pq_sendbyte(&msgbuf, PG_DIAG_MESSAGE_PRIMARY);
         if (edata->message)
             err_sendstring(&msgbuf, edata->message);
         else
             err_sendstring(&msgbuf, _("missing error text"));
  
         if (edata->detail)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_MESSAGE_DETAIL);
             err_sendstring(&msgbuf, edata->detail);
         }
  
         /* detail_log is intentionally not used here */
  
         if (edata->hint)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_MESSAGE_HINT);
             err_sendstring(&msgbuf, edata->hint);
         }
  
         if (edata->context)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_CONTEXT);
             err_sendstring(&msgbuf, edata->context);
         }
  
         if (edata->schema_name)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_SCHEMA_NAME);
             err_sendstring(&msgbuf, edata->schema_name);
         }
  
         if (edata->table_name)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_TABLE_NAME);
             err_sendstring(&msgbuf, edata->table_name);
         }
  
         if (edata->column_name)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_COLUMN_NAME);
             err_sendstring(&msgbuf, edata->column_name);
         }
  
         if (edata->datatype_name)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_DATATYPE_NAME);
             err_sendstring(&msgbuf, edata->datatype_name);
         }
  
         if (edata->constraint_name)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_NAME);
             err_sendstring(&msgbuf, edata->constraint_name);
         }
  
         if (edata->cursorpos > 0)
         {
             snprintf(tbuf, sizeof(tbuf), "%d", edata->cursorpos);
             pq_sendbyte(&msgbuf, PG_DIAG_STATEMENT_POSITION);
             err_sendstring(&msgbuf, tbuf);
         }
  
         if (edata->internalpos > 0)
         {
             snprintf(tbuf, sizeof(tbuf), "%d", edata->internalpos);
             pq_sendbyte(&msgbuf, PG_DIAG_INTERNAL_POSITION);
             err_sendstring(&msgbuf, tbuf);
         }
  
         if (edata->internalquery)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_INTERNAL_QUERY);
             err_sendstring(&msgbuf, edata->internalquery);
         }
  
         if (edata->filename)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_SOURCE_FILE);
             err_sendstring(&msgbuf, edata->filename);
         }
  
         if (edata->lineno > 0)
         {
             snprintf(tbuf, sizeof(tbuf), "%d", edata->lineno);
             pq_sendbyte(&msgbuf, PG_DIAG_SOURCE_LINE);
             err_sendstring(&msgbuf, tbuf);
         }
  
         if (edata->funcname)
         {
             pq_sendbyte(&msgbuf, PG_DIAG_SOURCE_FUNCTION);
             err_sendstring(&msgbuf, edata->funcname);
         }
  
         pq_sendbyte(&msgbuf, '\0'); /* terminator */
  
         pq_endmessage(&msgbuf);
     }
     else
     {
         /* Old style --- gin up a backwards-compatible message */
         StringInfoData buf;
  
         initStringInfo(&buf);
  
         appendStringInfo(&buf, "%s:  ", _(error_severity(edata->elevel)));
  
         if (edata->message)
             appendStringInfoString(&buf, edata->message);
         else
             appendStringInfoString(&buf, _("missing error text"));
  
         appendStringInfoChar(&buf, '\n');
  
         /* 'N' (Notice) is for nonfatal conditions, 'E' is for errors */
         pq_putmessage_v2((edata->elevel < ERROR) ? 'N' : 'E', buf.data, buf.len + 1);
  
         pfree(buf.data);
     }
  
     /*
      * This flush is normally not necessary, since postgres.c will flush out
      * waiting data when control returns to the main loop. But it seems best
      * to leave it here, so that the client has some clue what happened if the
      * backend dies before getting back to the main loop ... error/notice
      * messages should not be a performance-critical path anyway, so an extra
      * flush won't hurt much ...
      */
     pq_flush();
 }

References _, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, ErrorData::column_name, ErrorData::constraint_name, ErrorData::context, ErrorData::cursorpos, ErrorData::datatype_name, ErrorData::detail, ErrorData::elevel, err_sendstring(), ERROR, error_severity(), ErrorData::filename, FrontendProtocol, ErrorData::funcname, ErrorData::hint, initStringInfo(), ErrorData::internalpos, ErrorData::internalquery, ErrorData::lineno, ErrorData::message, pfree(), PG_DIAG_COLUMN_NAME, PG_DIAG_CONSTRAINT_NAME, PG_DIAG_CONTEXT, PG_DIAG_DATATYPE_NAME, PG_DIAG_INTERNAL_POSITION, PG_DIAG_INTERNAL_QUERY, PG_DIAG_MESSAGE_DETAIL, PG_DIAG_MESSAGE_HINT, PG_DIAG_MESSAGE_PRIMARY, PG_DIAG_SCHEMA_NAME, PG_DIAG_SEVERITY, PG_DIAG_SEVERITY_NONLOCALIZED, PG_DIAG_SOURCE_FILE, PG_DIAG_SOURCE_FUNCTION, PG_DIAG_SOURCE_LINE, PG_DIAG_SQLSTATE, PG_DIAG_STATEMENT_POSITION, PG_DIAG_TABLE_NAME, PG_PROTOCOL_MAJOR, pq_beginmessage(), pq_endmessage(), pq_flush, pq_putmessage_v2(), pq_sendbyte(), PqMsg_ErrorResponse, PqMsg_NoticeResponse, ErrorData::schema_name, snprintf, ErrorData::sqlerrcode, ErrorData::table_name, and unpack_sql_state().

Referenced by EmitErrorReport().

◆ send_message_to_server_log()

static void send_message_to_server_log ( ErrorData * edata )

static

Definition at line 3189 of file elog.c.

 {
     StringInfoData buf;
     bool        fallback_to_stderr = false;
  
     initStringInfo(&buf);
  
     log_line_prefix(&buf, edata);
     appendStringInfo(&buf, "%s:  ", _(error_severity(edata->elevel)));
  
     if (Log_error_verbosity >= PGERROR_VERBOSE)
         appendStringInfo(&buf, "%s: ", unpack_sql_state(edata->sqlerrcode));
  
     if (edata->message)
         append_with_tabs(&buf, edata->message);
     else
         append_with_tabs(&buf, _("missing error text"));
  
     if (edata->cursorpos > 0)
         appendStringInfo(&buf, _(" at character %d"),
                          edata->cursorpos);
     else if (edata->internalpos > 0)
         appendStringInfo(&buf, _(" at character %d"),
                          edata->internalpos);
  
     appendStringInfoChar(&buf, '\n');
  
     if (Log_error_verbosity >= PGERROR_DEFAULT)
     {
         if (edata->detail_log)
         {
             log_line_prefix(&buf, edata);
             appendStringInfoString(&buf, _("DETAIL:  "));
             append_with_tabs(&buf, edata->detail_log);
             appendStringInfoChar(&buf, '\n');
         }
         else if (edata->detail)
         {
             log_line_prefix(&buf, edata);
             appendStringInfoString(&buf, _("DETAIL:  "));
             append_with_tabs(&buf, edata->detail);
             appendStringInfoChar(&buf, '\n');
         }
         if (edata->hint)
         {
             log_line_prefix(&buf, edata);
             appendStringInfoString(&buf, _("HINT:  "));
             append_with_tabs(&buf, edata->hint);
             appendStringInfoChar(&buf, '\n');
         }
         if (edata->internalquery)
         {
             log_line_prefix(&buf, edata);
             appendStringInfoString(&buf, _("QUERY:  "));
             append_with_tabs(&buf, edata->internalquery);
             appendStringInfoChar(&buf, '\n');
         }
         if (edata->context && !edata->hide_ctx)
         {
             log_line_prefix(&buf, edata);
             appendStringInfoString(&buf, _("CONTEXT:  "));
             append_with_tabs(&buf, edata->context);
             appendStringInfoChar(&buf, '\n');
         }
         if (Log_error_verbosity >= PGERROR_VERBOSE)
         {
             /* assume no newlines in funcname or filename... */
             if (edata->funcname && edata->filename)
             {
                 log_line_prefix(&buf, edata);
                 appendStringInfo(&buf, _("LOCATION:  %s, %s:%d\n"),
                                  edata->funcname, edata->filename,
                                  edata->lineno);
             }
             else if (edata->filename)
             {
                 log_line_prefix(&buf, edata);
                 appendStringInfo(&buf, _("LOCATION:  %s:%d\n"),
                                  edata->filename, edata->lineno);
             }
         }
         if (edata->backtrace)
         {
             log_line_prefix(&buf, edata);
             appendStringInfoString(&buf, _("BACKTRACE:  "));
             append_with_tabs(&buf, edata->backtrace);
             appendStringInfoChar(&buf, '\n');
         }
     }
  
     /*
      * If the user wants the query that generated this error logged, do it.
      */
     if (check_log_of_query(edata))
     {
         log_line_prefix(&buf, edata);
         appendStringInfoString(&buf, _("STATEMENT:  "));
         append_with_tabs(&buf, debug_query_string);
         appendStringInfoChar(&buf, '\n');
     }
  
 #ifdef HAVE_SYSLOG
     /* Write to syslog, if enabled */
     if (Log_destination & LOG_DESTINATION_SYSLOG)
     {
         int         syslog_level;
  
         switch (edata->elevel)
         {
             case DEBUG5:
             case DEBUG4:
             case DEBUG3:
             case DEBUG2:
             case DEBUG1:
                 syslog_level = LOG_DEBUG;
                 break;
             case LOG:
             case LOG_SERVER_ONLY:
             case INFO:
                 syslog_level = LOG_INFO;
                 break;
             case NOTICE:
             case WARNING:
             case WARNING_CLIENT_ONLY:
                 syslog_level = LOG_NOTICE;
                 break;
             case ERROR:
                 syslog_level = LOG_WARNING;
                 break;
             case FATAL:
                 syslog_level = LOG_ERR;
                 break;
             case PANIC:
             default:
                 syslog_level = LOG_CRIT;
                 break;
         }
  
         write_syslog(syslog_level, buf.data);
     }
 #endif                          /* HAVE_SYSLOG */
  
 #ifdef WIN32
     /* Write to eventlog, if enabled */
     if (Log_destination & LOG_DESTINATION_EVENTLOG)
     {
         write_eventlog(edata->elevel, buf.data, buf.len);
     }
 #endif                          /* WIN32 */
  
     /* Write to csvlog, if enabled */
     if (Log_destination & LOG_DESTINATION_CSVLOG)
     {
         /*
          * Send CSV data if it's safe to do so (syslogger doesn't need the
          * pipe).  If this is not possible, fallback to an entry written to
          * stderr.
          */
         if (redirection_done || MyBackendType == B_LOGGER)
             write_csvlog(edata);
         else
             fallback_to_stderr = true;
     }
  
     /* Write to JSON log, if enabled */
     if (Log_destination & LOG_DESTINATION_JSONLOG)
     {
         /*
          * Send JSON data if it's safe to do so (syslogger doesn't need the
          * pipe).  If this is not possible, fallback to an entry written to
          * stderr.
          */
         if (redirection_done || MyBackendType == B_LOGGER)
         {
             write_jsonlog(edata);
         }
         else
             fallback_to_stderr = true;
     }
  
     /*
      * Write to stderr, if enabled or if required because of a previous
      * limitation.
      */
     if ((Log_destination & LOG_DESTINATION_STDERR) ||
         whereToSendOutput == DestDebug ||
         fallback_to_stderr)
     {
         /*
          * Use the chunking protocol if we know the syslogger should be
          * catching stderr output, and we are not ourselves the syslogger.
          * Otherwise, just do a vanilla write to stderr.
          */
         if (redirection_done && MyBackendType != B_LOGGER)
             write_pipe_chunks(buf.data, buf.len, LOG_DESTINATION_STDERR);
 #ifdef WIN32
  
         /*
          * In a win32 service environment, there is no usable stderr. Capture
          * anything going there and write it to the eventlog instead.
          *
          * If stderr redirection is active, it was OK to write to stderr above
          * because that's really a pipe to the syslogger process.
          */
         else if (pgwin32_is_service())
             write_eventlog(edata->elevel, buf.data, buf.len);
 #endif
         else
             write_console(buf.data, buf.len);
     }
  
     /* If in the syslogger process, try to write messages direct to file */
     if (MyBackendType == B_LOGGER)
         write_syslogger_file(buf.data, buf.len, LOG_DESTINATION_STDERR);
  
     /* No more need of the message formatted for stderr */
     pfree(buf.data);
 }

References _, append_with_tabs(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), B_LOGGER, ErrorData::backtrace, buf, check_log_of_query(), ErrorData::context, ErrorData::cursorpos, DEBUG1, DEBUG2, DEBUG3, DEBUG4, DEBUG5, debug_query_string, DestDebug, ErrorData::detail, ErrorData::detail_log, ErrorData::elevel, ERROR, error_severity(), FATAL, ErrorData::filename, ErrorData::funcname, ErrorData::hide_ctx, ErrorData::hint, INFO, initStringInfo(), ErrorData::internalpos, ErrorData::internalquery, ErrorData::lineno, LOG, Log_destination, LOG_DESTINATION_CSVLOG, LOG_DESTINATION_EVENTLOG, LOG_DESTINATION_JSONLOG, LOG_DESTINATION_STDERR, LOG_DESTINATION_SYSLOG, Log_error_verbosity, log_line_prefix(), LOG_SERVER_ONLY, ErrorData::message, MyBackendType, NOTICE, PANIC, pfree(), PGERROR_DEFAULT, PGERROR_VERBOSE, pgwin32_is_service(), redirection_done, ErrorData::sqlerrcode, unpack_sql_state(), WARNING, WARNING_CLIENT_ONLY, whereToSendOutput, write_console(), write_csvlog(), write_jsonlog(), write_pipe_chunks(), and write_syslogger_file().

Referenced by EmitErrorReport().

◆ set_backtrace()

static void set_backtrace	(	ErrorData *	edata,
		int	num_skip
	)

static

Definition at line 1116 of file elog.c.

 {
     StringInfoData errtrace;
  
     initStringInfo(&errtrace);
  
 #ifdef HAVE_BACKTRACE_SYMBOLS
     {
         void       *buf[100];
         int         nframes;
         char      **strfrms;
  
         nframes = backtrace(buf, lengthof(buf));
         strfrms = backtrace_symbols(buf, nframes);
         if (strfrms == NULL)
             return;
  
         for (int i = num_skip; i < nframes; i++)
             appendStringInfo(&errtrace, "\n%s", strfrms[i]);
         free(strfrms);
     }
 #else
     appendStringInfoString(&errtrace,
                            "backtrace generation is not supported by this installation");
 #endif
  
     edata->backtrace = errtrace.data;
 }

References appendStringInfo(), appendStringInfoString(), ErrorData::backtrace, buf, StringInfoData::data, free, i, initStringInfo(), and lengthof.

Referenced by errbacktrace(), and errfinish().

◆ set_errcontext_domain()

int set_errcontext_domain ( const char * domain )

Definition at line 1391 of file elog.c.

 {
     ErrorData  *edata = &errordata[errordata_stack_depth];
  
     /* we don't bother incrementing recursion_depth */
     CHECK_STACK_DEPTH();
  
     /* the default text domain is the backend's */
     edata->context_domain = domain ? domain : PG_TEXTDOMAIN("postgres");
  
     return 0;                   /* return value does not matter */
 }

References CHECK_STACK_DEPTH, ErrorData::context_domain, errordata, errordata_stack_depth, and PG_TEXTDOMAIN.

◆ set_errdata_field()

static void set_errdata_field	(	MemoryContextData *	cxt,
		char **	ptr,
		const char *	str
	)

static

Definition at line 1548 of file elog.c.

 {
     Assert(*ptr == NULL);
     *ptr = MemoryContextStrdup(cxt, str);
 }

References Assert, MemoryContextStrdup(), and str.

Referenced by err_generic_string().

◆ set_stack_entry_domain()

static void set_stack_entry_domain	(	ErrorData *	edata,
		const char *	domain
	)

static

Definition at line 778 of file elog.c.

 {
     /* the default text domain is the backend's */
     edata->domain = domain ? domain : PG_TEXTDOMAIN("postgres");
     /* initialize context_domain the same way (see set_errcontext_domain()) */
     edata->context_domain = edata->domain;
 }

References ErrorData::context_domain, ErrorData::domain, and PG_TEXTDOMAIN.

Referenced by errsave_start(), and errstart().

◆ set_stack_entry_location()

static void set_stack_entry_location	(	ErrorData *	edata,
		const char *	filename,
		int	lineno,
		const char *	funcname
	)

static

Definition at line 795 of file elog.c.

 {
     if (filename)
     {
         const char *slash;
  
         /* keep only base name, useful especially for vpath builds */
         slash = strrchr(filename, '/');
         if (slash)
             filename = slash + 1;
         /* Some Windows compilers use backslashes in __FILE__ strings */
         slash = strrchr(filename, '\\');
         if (slash)
             filename = slash + 1;
     }
  
     edata->filename = filename;
     edata->lineno = lineno;
     edata->funcname = funcname;
 }

References filename, ErrorData::filename, ErrorData::funcname, funcname, and ErrorData::lineno.

Referenced by errfinish(), and errsave_finish().

◆ should_output_to_client()

static bool should_output_to_client ( int elevel )

inlinestatic

Definition at line 244 of file elog.c.

 {
     if (whereToSendOutput == DestRemote && elevel != LOG_SERVER_ONLY)
     {
         /*
          * client_min_messages is honored only after we complete the
          * authentication handshake.  This is required both for security
          * reasons and because many clients can't handle NOTICE messages
          * during authentication.
          */
         if (ClientAuthInProgress)
             return (elevel >= ERROR);
         else
             return (elevel >= client_min_messages || elevel == INFO);
     }
     return false;
 }

References client_min_messages, ClientAuthInProgress, DestRemote, ERROR, INFO, LOG_SERVER_ONLY, and whereToSendOutput.

Referenced by errstart(), message_level_is_interesting(), and pg_re_throw().

◆ should_output_to_server()

static bool should_output_to_server ( int elevel )

inlinestatic

Definition at line 235 of file elog.c.

 {
     return is_log_level_output(elevel, log_min_messages);
 }

References is_log_level_output(), and log_min_messages.

Referenced by errstart(), message_level_is_interesting(), and pg_re_throw().

◆ ThrowErrorData()

void ThrowErrorData ( ErrorData * edata )

Definition at line 1895 of file elog.c.

 {
     ErrorData  *newedata;
     MemoryContext oldcontext;
  
     if (!errstart(edata->elevel, edata->domain))
         return;                 /* error is not to be reported at all */
  
     newedata = &errordata[errordata_stack_depth];
     recursion_depth++;
     oldcontext = MemoryContextSwitchTo(newedata->assoc_context);
  
     /* Copy the supplied fields to the error stack entry. */
     if (edata->sqlerrcode != 0)
         newedata->sqlerrcode = edata->sqlerrcode;
     if (edata->message)
         newedata->message = pstrdup(edata->message);
     if (edata->detail)
         newedata->detail = pstrdup(edata->detail);
     if (edata->detail_log)
         newedata->detail_log = pstrdup(edata->detail_log);
     if (edata->hint)
         newedata->hint = pstrdup(edata->hint);
     if (edata->context)
         newedata->context = pstrdup(edata->context);
     if (edata->backtrace)
         newedata->backtrace = pstrdup(edata->backtrace);
     /* assume message_id is not available */
     if (edata->schema_name)
         newedata->schema_name = pstrdup(edata->schema_name);
     if (edata->table_name)
         newedata->table_name = pstrdup(edata->table_name);
     if (edata->column_name)
         newedata->column_name = pstrdup(edata->column_name);
     if (edata->datatype_name)
         newedata->datatype_name = pstrdup(edata->datatype_name);
     if (edata->constraint_name)
         newedata->constraint_name = pstrdup(edata->constraint_name);
     newedata->cursorpos = edata->cursorpos;
     newedata->internalpos = edata->internalpos;
     if (edata->internalquery)
         newedata->internalquery = pstrdup(edata->internalquery);
  
     MemoryContextSwitchTo(oldcontext);
     recursion_depth--;
  
     /* Process the error. */
     errfinish(edata->filename, edata->lineno, edata->funcname);
 }

References ErrorData::assoc_context, ErrorData::backtrace, ErrorData::column_name, ErrorData::constraint_name, ErrorData::context, ErrorData::cursorpos, ErrorData::datatype_name, ErrorData::detail, ErrorData::detail_log, ErrorData::domain, ErrorData::elevel, errfinish(), errordata, errordata_stack_depth, errstart(), ErrorData::filename, ErrorData::funcname, ErrorData::hint, ErrorData::internalpos, ErrorData::internalquery, ErrorData::lineno, MemoryContextSwitchTo(), ErrorData::message, pstrdup(), recursion_depth, ErrorData::schema_name, ErrorData::sqlerrcode, and ErrorData::table_name.

Referenced by HandleParallelMessage(), and text_to_stavalues().

◆ unpack_sql_state()

char* unpack_sql_state ( int sql_state )

Definition at line 3169 of file elog.c.

 {
     static char buf[12];
     int         i;
  
     for (i = 0; i < 5; i++)
     {
         buf[i] = PGUNSIXBIT(sql_state);
         sql_state >>= 6;
     }
  
     buf[i] = '\0';
     return buf;
 }

References buf, i, and PGUNSIXBIT.

Referenced by exec_stmt_block(), exec_stmt_getdiag(), exec_stmt_raise(), log_status_format(), pg_input_error_info(), pltcl_construct_errorCode(), PLy_exception_set_with_details(), PLy_generate_spi_exceptions(), send_message_to_frontend(), send_message_to_server_log(), write_csvlog(), and write_jsonlog().

◆ write_console()

static void write_console	(	const char *	line,
		int	len
	)

static

Definition at line 2579 of file elog.c.

 {
     int         rc;
  
 #ifdef WIN32
  
     /*
      * Try to convert the message to UTF16 and write it with WriteConsoleW().
      * Fall back on write() if anything fails.
      *
      * In contrast to write_eventlog(), don't skip straight to write() based
      * on the applicable encodings.  Unlike WriteConsoleW(), write() depends
      * on the suitability of the console output code page.  Since we put
      * stderr into binary mode in SubPostmasterMain(), write() skips the
      * necessary translation anyway.
      *
      * WriteConsoleW() will fail if stderr is redirected, so just fall through
      * to writing unconverted to the logfile in this case.
      *
      * Since we palloc the structure required for conversion, also fall
      * through to writing unconverted if we have not yet set up
      * CurrentMemoryContext.
      */
     if (!in_error_recursion_trouble() &&
         !redirection_done &&
         CurrentMemoryContext != NULL)
     {
         WCHAR      *utf16;
         int         utf16len;
  
         utf16 = pgwin32_message_to_UTF16(line, len, &utf16len);
         if (utf16 != NULL)
         {
             HANDLE      stdHandle;
             DWORD       written;
  
             stdHandle = GetStdHandle(STD_ERROR_HANDLE);
             if (WriteConsoleW(stdHandle, utf16, utf16len, &written, NULL))
             {
                 pfree(utf16);
                 return;
             }
  
             /*
              * In case WriteConsoleW() failed, fall back to writing the
              * message unconverted.
              */
             pfree(utf16);
         }
     }
 #else
  
     /*
      * Conversion on non-win32 platforms is not implemented yet. It requires
      * non-throw version of pg_do_encoding_conversion(), that converts
      * unconvertible characters to '?' without errors.
      *
      * XXX: We have a no-throw version now. It doesn't convert to '?' though.
      */
 #endif
  
     /*
      * We ignore any error from write() here.  We have no useful way to report
      * it ... certainly whining on stderr isn't likely to be productive.
      */
     rc = write(fileno(stderr), line, len);
     (void) rc;
 }

References CurrentMemoryContext, in_error_recursion_trouble(), len, pfree(), redirection_done, and write.

Referenced by send_message_to_server_log(), and write_stderr().

◆ write_pipe_chunks()

void write_pipe_chunks	(	char *	data,
		int	len,
		int	dest
	)

Definition at line 3429 of file elog.c.

 {
     PipeProtoChunk p;
     int         fd = fileno(stderr);
     int         rc;
  
     Assert(len > 0);
  
     p.proto.nuls[0] = p.proto.nuls[1] = '\0';
     p.proto.pid = MyProcPid;
     p.proto.flags = 0;
     if (dest == LOG_DESTINATION_STDERR)
         p.proto.flags |= PIPE_PROTO_DEST_STDERR;
     else if (dest == LOG_DESTINATION_CSVLOG)
         p.proto.flags |= PIPE_PROTO_DEST_CSVLOG;
     else if (dest == LOG_DESTINATION_JSONLOG)
         p.proto.flags |= PIPE_PROTO_DEST_JSONLOG;
  
     /* write all but the last chunk */
     while (len > PIPE_MAX_PAYLOAD)
     {
         /* no need to set PIPE_PROTO_IS_LAST yet */
         p.proto.len = PIPE_MAX_PAYLOAD;
         memcpy(p.proto.data, data, PIPE_MAX_PAYLOAD);
         rc = write(fd, &p, PIPE_HEADER_SIZE + PIPE_MAX_PAYLOAD);
         (void) rc;
         data += PIPE_MAX_PAYLOAD;
         len -= PIPE_MAX_PAYLOAD;
     }
  
     /* write the last chunk */
     p.proto.flags |= PIPE_PROTO_IS_LAST;
     p.proto.len = len;
     memcpy(p.proto.data, data, len);
     rc = write(fd, &p, PIPE_HEADER_SIZE + len);
     (void) rc;
 }

References Assert, PipeProtoHeader::data, data, generate_unaccent_rules::dest, fd(), PipeProtoHeader::flags, PipeProtoHeader::len, len, LOG_DESTINATION_CSVLOG, LOG_DESTINATION_JSONLOG, LOG_DESTINATION_STDERR, MyProcPid, PipeProtoHeader::nuls, PipeProtoHeader::pid, PIPE_HEADER_SIZE, PIPE_MAX_PAYLOAD, PIPE_PROTO_DEST_CSVLOG, PIPE_PROTO_DEST_JSONLOG, PIPE_PROTO_DEST_STDERR, PIPE_PROTO_IS_LAST, PipeProtoChunk::proto, and write.

Referenced by send_message_to_server_log(), write_csvlog(), and write_jsonlog().

◆ write_stderr()

static void write_stderr	(	const char *	fmt,
			...
	)

Definition at line 3741 of file elog.c.

 {
     va_list     ap;
  
 #ifdef WIN32
     char        errbuf[2048];   /* Arbitrary size? */
 #endif
  
     fmt = _(fmt);
  
     va_start(ap, fmt);
 #ifndef WIN32
     /* On Unix, we just fprintf to stderr */
     vfprintf(stderr, fmt, ap);
     fflush(stderr);
 #else
     vsnprintf(errbuf, sizeof(errbuf), fmt, ap);
  
     /*
      * On Win32, we print to stderr if running on a console, or write to
      * eventlog if running as a service
      */
     if (pgwin32_is_service())   /* Running as a service */
     {
         write_eventlog(ERROR, errbuf, strlen(errbuf));
     }
     else
     {
         /* Not running as service, write to stderr */
         write_console(errbuf, strlen(errbuf));
         fflush(stderr);
     }
 #endif
     va_end(ap);
 }

References _, ERROR, fflush(), fmt, pgwin32_is_service(), va_end(), va_start(), vfprintf(), vsnprintf, and write_console().

Referenced by errstart().

Variable Documentation

◆ backtrace_function_list

char* backtrace_function_list

static

Definition at line 116 of file elog.c.

Referenced by assign_backtrace_functions(), and matches_backtrace_functions().

◆ emit_log_hook

emit_log_hook_type emit_log_hook = NULL

Definition at line 105 of file elog.c.

Referenced by EmitErrorReport().

◆ error_context_stack

ErrorContextCallback* error_context_stack = NULL

Definition at line 94 of file elog.c.

◆ errordata

◆ errordata_stack_depth

int errordata_stack_depth = -1

static

◆ formatted_log_time

char formatted_log_time[FORMATTED_TS_LEN]

static

Definition at line 160 of file elog.c.

Referenced by EmitErrorReport(), get_formatted_log_time(), and log_status_format().

◆ formatted_start_time

char formatted_start_time[FORMATTED_TS_LEN]

static

Definition at line 159 of file elog.c.

Referenced by get_formatted_start_time(), and reset_formatted_start_time().

◆ Log_destination

int Log_destination = LOG_DESTINATION_STDERR

Definition at line 110 of file elog.c.

Referenced by assign_log_destination(), logfile_rotate_dest(), PostmasterMain(), send_message_to_server_log(), SysLogger_Start(), SysLoggerMain(), and update_metainfo_datafile().

◆ Log_destination_string

char* Log_destination_string = NULL

Definition at line 111 of file elog.c.

Referenced by PostmasterMain().

◆ Log_error_verbosity

int Log_error_verbosity = PGERROR_DEFAULT

Definition at line 108 of file elog.c.

Referenced by send_message_to_server_log(), write_csvlog(), and write_jsonlog().

◆ Log_line_prefix

char* Log_line_prefix = NULL

Definition at line 109 of file elog.c.

Referenced by log_line_prefix().

◆ PG_exception_stack

sigjmp_buf* PG_exception_stack = NULL

Definition at line 96 of file elog.c.

Referenced by AutoVacWorkerMain(), BackgroundWorkerMain(), BackgroundWriterMain(), CheckpointerMain(), errfinish(), errstart(), pg_re_throw(), pgarch_archiveXlog(), PostgresMain(), ReplSlotSyncWorkerMain(), WalSummarizerMain(), and WalWriterMain().

◆ recursion_depth

int recursion_depth = 0

static

◆ save_format_domain

const char* save_format_domain

static

Definition at line 1642 of file elog.c.

Referenced by format_elog_string(), and pre_format_elog_string().

◆ save_format_errnumber

int save_format_errnumber

static

Definition at line 1641 of file elog.c.

Referenced by format_elog_string(), and pre_format_elog_string().

◆ saved_timeval

struct timeval saved_timeval

static

Definition at line 149 of file elog.c.

Referenced by get_formatted_log_time(), and log_status_format().

◆ saved_timeval_set

bool saved_timeval_set = false

static

Definition at line 156 of file elog.c.

Referenced by EmitErrorReport(), get_formatted_log_time(), and log_status_format().

◆ syslog_sequence_numbers

bool syslog_sequence_numbers = true

Definition at line 112 of file elog.c.

◆ syslog_split_messages

bool syslog_split_messages = true

Definition at line 113 of file elog.c.

Macros

Functions

Variables

Macro Definition Documentation

◆ _

◆ CHECK_STACK_DEPTH

◆ ERRORDATA_STACK_SIZE

◆ EVALUATE_MESSAGE

◆ EVALUATE_MESSAGE_PLURAL

◆ FORMATTED_TS_LEN

Function Documentation

◆ append_with_tabs()

◆ assign_backtrace_functions()

◆ assign_log_destination()

◆ assign_syslog_facility()

◆ assign_syslog_ident()

◆ check_backtrace_functions()

◆ check_log_destination()

◆ check_log_of_query()

◆ CopyErrorData()

◆ DebugFileOpen()

◆ EmitErrorReport()

◆ err_generic_string()

◆ err_gettext()

◆ err_sendstring()

◆ errbacktrace()

◆ errcode()

◆ errcode_for_file_access()

◆ errcode_for_socket_access()

◆ errcontext_msg()

◆ errdetail()

◆ errdetail_internal()

◆ errdetail_log()

◆ errdetail_log_plural()

◆ errdetail_plural()

◆ errfinish()

◆ errhidecontext()

◆ errhidestmt()

◆ errhint()

◆ errhint_plural()

◆ errmsg()

◆ errmsg_internal()

◆ errmsg_plural()

◆ error_severity()

◆ errposition()

◆ errsave_finish()

◆ errsave_start()

◆ errstart()

◆ errstart_cold()

◆ FlushErrorState()

◆ format_elog_string()

◆ FreeErrorData()

◆ FreeErrorDataContents()

◆ get_backend_type_for_log()

◆ get_error_stack_entry()

◆ get_formatted_log_time()

◆ get_formatted_start_time()

◆ geterrcode()

◆ geterrlevel()

◆ GetErrorContextStack()

◆ geterrposition()

◆ getinternalerrposition()

◆ in_error_recursion_trouble()

◆ internalerrposition()

◆ internalerrquery()

◆ is_log_level_output()

◆ log_line_prefix()

◆ log_status_format()

◆ matches_backtrace_functions()

◆ message_level_is_interesting()

◆ pg_re_throw()

◆ pre_format_elog_string()

◆ process_log_prefix_padding()

◆ reset_formatted_start_time()

◆ ReThrowError()

◆ send_message_to_frontend()

◆ send_message_to_server_log()

◆ set_backtrace()

◆ set_errcontext_domain()

◆ set_errdata_field()