#include "postgres.h"
#include <fcntl.h>
#include <time.h>
#include <unistd.h>
#include <signal.h>
#include <ctype.h>
#include "access/xact.h"
#include "common/ip.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 "postmaster/proctypelist.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)

#define	PG_PROCTYPE(bktype, bkcategory, description, main_func, shmem_attach) [bktype] = bkcategory,

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	backtrace_cleanup (int code, Datum arg)

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

static void	FreeErrorDataContents (ErrorData *edata)

static int	log_min_messages_cmp (const ListCell a, const ListCell b)

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)

	pg_attribute_unused () static void backtrace_cleanup(int code

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_log_min_messages (char newval, void extra, GucSource source)

void	assign_log_min_messages (const char newval, void extra)

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,...)

void	vwrite_stderr (const char *fmt, va_list ap)

Macro Definition Documentation

◆ _

#define _ ( x ) err_gettext(x)

Definition at line 95 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 174 of file elog.c.

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

◆ ERRORDATA_STACK_SIZE

#define ERRORDATA_STACK_SIZE 5

Definition at line 153 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 1012 of file elog.c.

    { \
        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); \
    }

◆ EVALUATE_MESSAGE_PLURAL

#define EVALUATE_MESSAGE_PLURAL	(	domain,
		targetfield,
		appendval
	)

Definition at line 1048 of file elog.c.

    { \
        const char     *fmt; \
        StringInfoData  buf; \
        /* Internationalize the error format string */ \
		if (!in_error_recursion_trouble()) \
            fmt = dngettext((domain), fmt_singular, fmt_plural, n); \
        else \
			fmt = (n == 1 ? fmt_singular : fmt_plural); \
		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, n); \
            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); \
    }

◆ FORMATTED_TS_LEN

#define FORMATTED_TS_LEN 128

Definition at line 168 of file elog.c.

◆ PG_PROCTYPE

#define PG_PROCTYPE	(	bktype,
		bkcategory,
		description,
		main_func,
		shmem_attach
	)	[bktype] = bkcategory,

Function Documentation

◆ append_with_tabs()

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

static

Definition at line 4206 of file elog.c.

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

References appendStringInfoCharMacro, buf, fb(), and str.

Referenced by send_message_to_server_log().

◆ assign_backtrace_functions()

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

Definition at line 2668 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 2741 of file elog.c.

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

References Log_destination.

◆ assign_log_min_messages()

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

Definition at line 2590 of file elog.c.

{
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
        log_min_messages[i] = ((int *) extra)[i];
}

References BACKEND_NUM_TYPES, i, and log_min_messages.

◆ assign_syslog_facility()

void assign_syslog_facility	(	int	newval,
		void *	extra
	)

Definition at line 2782 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 fb(), newval, and syslog_facility.

◆ assign_syslog_ident()

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

Definition at line 2750 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 fb(), free, and newval.

◆ backtrace_cleanup()

static void backtrace_cleanup	(	int	code,
		Datum	arg
	)

static

Referenced by set_backtrace().

◆ check_backtrace_functions()

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

Definition at line 2607 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(LOG, newvallen + 1 + 1);
    if (!someval)
        return false;
    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 fb(), GUC_check_errdetail, guc_malloc(), i, j, LOG, and newval.

◆ check_log_destination()

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

Definition at line 2677 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(LOG, sizeof(int));
    if (!myextra)
        return false;
    *myextra = newlogdest;
    *extra = myextra;
 
    return true;
}

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

◆ check_log_min_messages()

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

Definition at line 2362 of file elog.c.

{
    char       *rawstring;
    List       *elemlist;
    StringInfoData buf;
    char       *result;
    int         newlevel[BACKEND_NUM_TYPES];
    bool        assigned[BACKEND_NUM_TYPES] = {0};
    int         defaultlevel = -1;  /* -1 means not assigned */
 
    const char *const process_types[] = {
#define PG_PROCTYPE(bktype, bkcategory, description, main_func, shmem_attach) \
        [bktype] = bkcategory,
#include "postmaster/proctypelist.h"
#undef PG_PROCTYPE
    };
 
    /* Need a modifiable copy of string. */
    rawstring = guc_strdup(LOG, *newval);
    if (rawstring == NULL)
        return false;
 
    /* Parse the string into a list. */
    if (!SplitGUCList(rawstring, ',', &elemlist))
    {
        /* syntax error in list */
        GUC_check_errdetail("List syntax is invalid.");
        list_free(elemlist);
        guc_free(rawstring);
        return false;
    }
 
    /* Validate and assign log level and process type. */
    foreach_ptr(char, elem, elemlist)
    {
        char       *sep = strchr(elem, ':');
 
        /*
         * If there's no ':' separator in the entry, this is the default log
         * level.  Otherwise it's a process type-specific entry.
         */
        if (sep == NULL)
        {
            const struct config_enum_entry *entry;
            bool        found;
 
            /* Reject duplicates for default log level. */
            if (defaultlevel != -1)
            {
                GUC_check_errdetail("Redundant specification of default log level.");
                goto lmm_fail;
            }
 
            /* Validate the log level */
            found = false;
            for (entry = server_message_level_options; entry && entry->name; entry++)
            {
                if (pg_strcasecmp(entry->name, elem) == 0)
                {
                    defaultlevel = entry->val;
                    found = true;
                    break;
                }
            }
 
            if (!found)
            {
                GUC_check_errdetail("Unrecognized log level: \"%s\".", elem);
                goto lmm_fail;
            }
        }
        else
        {
            char       *loglevel = sep + 1;
            char       *ptype = elem;
            bool        found;
            int         level;
            const struct config_enum_entry *entry;
 
            /*
             * Temporarily clobber the ':' with a string terminator, so that
             * we can validate it.  We restore this at the bottom.
             */
            *sep = '\0';
 
            /* Validate the log level */
            found = false;
            for (entry = server_message_level_options; entry && entry->name; entry++)
            {
                if (pg_strcasecmp(entry->name, loglevel) == 0)
                {
                    level = entry->val;
                    found = true;
                    break;
                }
            }
 
            if (!found)
            {
                GUC_check_errdetail("Unrecognized log level for process type \"%s\": \"%s\".",
                                    ptype, loglevel);
                goto lmm_fail;
            }
 
            /* Is the process type name valid and unique? */
            found = false;
            for (int i = 0; i < BACKEND_NUM_TYPES; i++)
            {
                if (pg_strcasecmp(process_types[i], ptype) == 0)
                {
                    /* Reject duplicates for a process type. */
                    if (assigned[i])
                    {
                        GUC_check_errdetail("Redundant log level specification for process type \"%s\".",
                                            ptype);
                        goto lmm_fail;
                    }
 
                    newlevel[i] = level;
                    assigned[i] = true;
                    found = true;
 
                    /*
                     * note: we must keep looking! some process types appear
                     * multiple times in proctypelist.h.
                     */
                }
            }
 
            if (!found)
            {
                GUC_check_errdetail("Unrecognized process type \"%s\".", ptype);
                goto lmm_fail;
            }
 
            /* Put the separator back in place */
            *sep = ':';
        }
 
        /* all good */
        continue;
 
lmm_fail:
        guc_free(rawstring);
        list_free(elemlist);
        return false;
    }
 
    /*
     * The default log level must be specified. It is the fallback value.
     */
    if (defaultlevel == -1)
    {
        GUC_check_errdetail("Default log level was not defined.");
        guc_free(rawstring);
        list_free(elemlist);
        return false;
    }
 
    /* Apply the default log level to all processes not listed. */
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
    {
        if (!assigned[i])
            newlevel[i] = defaultlevel;
    }
 
    /*
     * Save an ordered representation of the user-specified string, for the
     * show_hook.
     */
    list_sort(elemlist, log_min_messages_cmp);
 
    initStringInfoExt(&buf, strlen(rawstring) + 1);
    foreach_ptr(char, elem, elemlist)
    {
        if (foreach_current_index(elem) == 0)
            appendStringInfoString(&buf, elem);
        else
            appendStringInfo(&buf, ", %s", elem);
    }
 
    result = guc_strdup(LOG, buf.data);
    if (!result)
    {
        pfree(buf.data);
        return false;
    }
 
    guc_free(*newval);
    *newval = result;
 
    guc_free(rawstring);
    list_free(elemlist);
    pfree(buf.data);
 
    /*
     * Pass back data for assign_log_min_messages to use.
     */
    *extra = guc_malloc(LOG, BACKEND_NUM_TYPES * sizeof(int));
    if (!*extra)
        return false;
    memcpy(*extra, newlevel, BACKEND_NUM_TYPES * sizeof(int));
 
    return true;
}

References appendStringInfo(), appendStringInfoString(), BACKEND_NUM_TYPES, buf, fb(), foreach_current_index, foreach_ptr, GUC_check_errdetail, guc_free(), guc_malloc(), guc_strdup(), i, initStringInfoExt(), list_free(), list_sort(), LOG, log_min_messages_cmp(), config_enum_entry::name, newval, pfree(), pg_strcasecmp(), server_message_level_options, SplitGUCList(), and config_enum_entry::val.

◆ check_log_of_query()

bool check_log_of_query ( ErrorData * edata )

Definition at line 3178 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, fb(), 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 1941 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 = palloc_object(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, CHECK_STACK_DEPTH, CurrentMemoryContext, ErrorContext, errordata, errordata_stack_depth, fb(), palloc_object, and pstrdup().

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 2306 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, fb(), fd(), IsUnderPostmaster, and OutputFileName.

Referenced by BaseInit().

◆ EmitErrorReport()

void EmitErrorReport ( void )

Definition at line 1882 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 CHECK_STACK_DEPTH, emit_log_hook, errordata, errordata_stack_depth, fb(), formatted_log_time, MemoryContextSwitchTo(), recursion_depth, saved_timeval_set, send_message_to_frontend(), and send_message_to_server_log().

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

◆ err_gettext()

static const char * err_gettext ( const char * str )

inlinestatic

Definition at line 317 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 3964 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 1115 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 CHECK_STACK_DEPTH, errordata, errordata_stack_depth, fb(), MemoryContextSwitchTo(), recursion_depth, and set_backtrace().

◆ errcode()

int errcode ( int sqlerrcode )

Definition at line 874 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 fb().

◆ errcode_for_file_access()

int errcode_for_file_access ( void )

Definition at line 897 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 */
#if defined(ENOTEMPTY) && (ENOTEMPTY != EEXIST) /* same code on AIX */
        case ENOTEMPTY:         /* Directory not empty */
#endif
            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, and fb().

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(), clone_file(), 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(), get_tablespace_location(), 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(), md_readv_report(), mdcreate(), mdextend(), mdimmedsync(), mdopenfork(), mdreadv(), mdstartreadv(), mdtruncate(), mdunlinkfork(), mdwritev(), mdzeroextend(), normalize_exec_path(), open_auth_file(), OpenWalSummaryFile(), parse_extension_control_file(), ParseConfigFile(), 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_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(), test_custom_stats_var_finish(), test_custom_stats_var_from_serialized_data(), test_custom_stats_var_to_serialized_data(), 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 976 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, and fb().

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().

◆ errfinish()

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

Definition at line 485 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();
 
    /*
     * If this is the outermost recursion level, we can clean up by resetting
     * ErrorContext altogether (compare FlushErrorState), which is good
     * because it cleans up any random leakages that might have occurred in
     * places such as context callback functions.  If we're nested, we can
     * only safely remove the subsidiary data of the current stack entry.
     */
    if (errordata_stack_depth == 0 && recursion_depth == 1)
        MemoryContextReset(ErrorContext);
    else
        FreeErrorDataContents(edata);
 
    /* Release stack entry and exit error-handling context */
    errordata_stack_depth--;
    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, backtrace_functions, ErrorContextCallback::callback, CHECK_FOR_INTERRUPTS, CHECK_STACK_DEPTH, CritSectionCount, DestNone, DestRemote, DISCONNECT_FATAL, DISCONNECT_NORMAL, EmitErrorReport(), ERROR, error_context_stack, ErrorContext, errordata, errordata_stack_depth, FATAL, fb(), filename, FreeErrorDataContents(), funcname, InterruptHoldoffCount, matches_backtrace_functions(), MemoryContextReset(), 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().

◆ errmsg()

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

Definition at line 1093 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 CHECK_STACK_DEPTH, errordata, errordata_stack_depth, EVALUATE_MESSAGE, fb(), MemoryContextSwitchTo(), and recursion_depth.

◆ error_severity()

const char * error_severity ( int elevel )

Definition at line 4154 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().

◆ errsave_finish()

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

Definition at line 702 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, errfinish(), ERROR, ErrorSaveContext::error_data, errordata, errordata_stack_depth, fb(), 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 650 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 CurrentMemoryContext, ErrorSaveContext::details_wanted, ERROR, ErrorSaveContext::error_occurred, errstart(), fb(), get_error_stack_entry(), IsA, LOG, recursion_depth, and set_stack_entry_domain().

◆ errstart()

bool errstart	(	int	elevel,
		const char *	domain
	)

Definition at line 354 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 CritSectionCount, debug_query_string, ERROR, error_context_stack, ErrorContext, errordata, errordata_stack_depth, ExitOnAnyError, FATAL, fb(), get_error_stack_entry(), i, in_error_recursion_trouble(), Max, MemoryContextReset(), PANIC, PG_exception_stack, proc_exit_inprogress, recursion_depth, set_stack_entry_domain(), should_output_to_client(), should_output_to_server(), 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 338 of file elog.c.

{
    return errstart(elevel, domain);
}

References errstart().

◆ FlushErrorState()

void FlushErrorState ( void )

Definition at line 2062 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(), AutoVacLauncherMain(), 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 1849 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 ErrorContext, EVALUATE_MESSAGE, fb(), MemoryContextSwitchTo(), MemSet, PG_TEXTDOMAIN, and save_format_domain.

◆ FreeErrorData()

void FreeErrorData ( ErrorData * edata )

Definition at line 2013 of file elog.c.

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

References fb(), 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 2025 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 fb(), and pfree().

Referenced by errfinish(), and FreeErrorData().

◆ get_backend_type_for_log()

const char * get_backend_type_for_log ( void )

Definition at line 3201 of file elog.c.

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

References B_BG_WORKER, BackgroundWorker::bgw_type, fb(), 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 772 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, fb(), PANIC, and unlikely.

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

◆ get_formatted_log_time()

char * get_formatted_log_time ( void )

Definition at line 3104 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 fb(), 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 3154 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 fb(), formatted_start_time, FORMATTED_TS_LEN, log_timezone, MyStartTime, pg_localtime(), and pg_strftime().

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

◆ GetErrorContextStack()

char * GetErrorContextStack ( void )

Definition at line 2254 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, ErrorContextCallback::callback, CurrentMemoryContext, error_context_stack, errordata_stack_depth, fb(), get_error_stack_entry(), ErrorContextCallback::previous, and recursion_depth.

Referenced by exec_stmt_getdiag().

◆ in_error_recursion_trouble()

bool in_error_recursion_trouble ( void )

Definition at line 305 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().

◆ is_log_level_output()

static bool is_log_level_output	(	int	elevel,
		int	log_min_level
	)

inlinestatic

Definition at line 213 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, fb(), 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 3259 of file elog.c.

{
    log_status_format(buf, Log_line_prefix, edata);
}

References buf, fb(), Log_line_prefix, and log_status_format().

Referenced by send_message_to_server_log().

◆ log_min_messages_cmp()

static int log_min_messages_cmp	(	const ListCell *	a,
		const ListCell *	b
	)

static

Definition at line 2573 of file elog.c.

{
    const char *s = lfirst(a);
    const char *t = lfirst(b);
 
    if (strchr(s, ':') == NULL)
        return -1;
    else if (strchr(t, ':') == NULL)
        return 1;
    else
        return strcmp(s, t);
}

References a, b, fb(), and lfirst.

Referenced by check_log_min_messages().

◆ log_status_format()

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

Definition at line 3268 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, "%" PRIx64 ".%x",
                             MyStartTime, MyProcPid);
                    appendStringInfo(buf, "%*s", padding, strfbuf);
                }
                else
                    appendStringInfo(buf, "%" PRIx64 ".%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 'L':
                {
                    const char *local_host;
 
                    if (MyProcPort)
                    {
                        if (MyProcPort->local_host[0] == '\0')
                        {
                            /*
                             * First time through: cache the lookup, since it
                             * might not have trivial cost.
                             */
                            (void) pg_getnameinfo_all(&MyProcPort->laddr.addr,
                                                      MyProcPort->laddr.salen,
                                                      MyProcPort->local_host,
                                                      sizeof(MyProcPort->local_host),
                                                      NULL, 0,
                                                      NI_NUMERICHOST | NI_NUMERICSERV);
                        }
                        local_host = MyProcPort->local_host;
                    }
                    else
                    {
                        /* Background process, or connection not yet made */
                        local_host = "[none]";
                    }
                    if (padding != 0)
                        appendStringInfo(buf, "%*s", padding, local_host);
                    else
                        appendStringInfoString(buf, local_host);
                }
                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, "%*" PRId64, padding,
                                     pgstat_get_my_query_id());
                else
                    appendStringInfo(buf, "%" PRId64,
                                     pgstat_get_my_query_id());
                break;
            default:
                /* format error - ignore it */
                break;
        }
    }
}

References _, SockAddr::addr, appendBinaryStringInfo(), appendStringInfo(), appendStringInfoChar(), appendStringInfoSpaces(), appendStringInfoString(), application_name, buf, Port::database_name, dbname, fb(), 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, Port::laddr, Port::local_host, PGPROC::lockGroupLeader, log_timezone, PGPROC::lxid, MyProc, MyProcPid, MyProcPort, MyStartTime, pfree(), pg_getnameinfo_all(), 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(), SockAddr::salen, saved_timeval, saved_timeval_set, snprintf, 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 846 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, fb(), and funcname.

Referenced by errfinish().

◆ message_level_is_interesting()

bool message_level_is_interesting ( int elevel )

Definition at line 284 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 log_invalid_page(), PostmasterMain(), ProcessStandbyHSFeedbackMessage(), ProcessStandbyReplyMessage(), ProcessWalSndrMessage(), ProcSleep(), reportDependentObjects(), ShowTransactionState(), and VacuumUpdateCosts().

◆ pg_attribute_unused()

pg_attribute_unused ( )

◆ pg_re_throw()

void pg_re_throw ( void )

Definition at line 2199 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, errfinish(), ERROR, error_context_stack, errordata, errordata_stack_depth, ExceptionalCondition(), FATAL, fb(), 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 1840 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 fb(), and save_format_domain.

◆ process_log_prefix_padding()

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

static

Definition at line 3228 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;
}

References fb().

Referenced by log_status_format().

◆ reset_formatted_start_time()

void reset_formatted_start_time ( void )

Definition at line 3142 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 2149 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, ERROR, ErrorContext, fb(), get_error_stack_entry(), MemoryContextSwitchTo(), PG_RE_THROW, pstrdup(), and recursion_depth.

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 3976 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, err_sendstring(), ERROR, error_severity(), fb(), FrontendProtocol, initStringInfo(), 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, snprintf, 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 3673 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, buf, check_log_of_query(), DEBUG1, DEBUG2, DEBUG3, DEBUG4, DEBUG5, debug_query_string, DestDebug, ERROR, error_severity(), FATAL, fb(), INFO, initStringInfo(), 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, MyBackendType, NOTICE, PANIC, pfree(), PGERROR_DEFAULT, PGERROR_VERBOSE, pgwin32_is_service(), redirection_done, 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 1146 of file elog.c.

{
    StringInfoData errtrace;
 
    initStringInfo(&errtrace);
 
#ifdef HAVE_BACKTRACE_SYMBOLS
    {
        void       *frames[100];
        int         nframes;
        char      **strfrms;
 
        nframes = backtrace(frames, lengthof(frames));
        strfrms = backtrace_symbols(frames, nframes);
        if (strfrms != NULL)
        {
            for (int i = num_skip; i < nframes; i++)
                appendStringInfo(&errtrace, "\n%s", strfrms[i]);
            free(strfrms);
        }
        else
            appendStringInfoString(&errtrace,
                                   "insufficient memory for backtrace generation");
    }
#elif defined(_MSC_VER)
    {
        void       *frames[100];
        int         nframes;
        char        buffer[sizeof(SYMBOL_INFOW) + MAX_SYM_NAME * sizeof(wchar_t)];
        PSYMBOL_INFOW psymbol;
 
        /*
         * This is arranged so that we don't retry if we happen to fail to
         * initialize state on the first attempt in any one process.
         */
        if (!backtrace_symbols_initialized)
        {
            backtrace_symbols_initialized = true;
 
            if (DuplicateHandle(GetCurrentProcess(),
                                GetCurrentProcess(),
                                GetCurrentProcess(),
                                &backtrace_process,
                                0,
                                FALSE,
                                DUPLICATE_SAME_ACCESS) == 0)
            {
                appendStringInfo(&errtrace,
                                 "could not get process handle for backtrace: error code %lu",
                                 GetLastError());
                edata->backtrace = errtrace.data;
                return;
            }
 
            SymSetOptions(SYMOPT_DEFERRED_LOADS |
                          SYMOPT_FAIL_CRITICAL_ERRORS |
                          SYMOPT_LOAD_LINES |
                          SYMOPT_UNDNAME);
 
            if (!SymInitialize(backtrace_process, NULL, TRUE))
            {
                CloseHandle(backtrace_process);
                backtrace_process = NULL;
                appendStringInfo(&errtrace,
                                 "could not initialize symbol handler: error code %lu",
                                 GetLastError());
                edata->backtrace = errtrace.data;
                return;
            }
 
            on_proc_exit(backtrace_cleanup, 0);
        }
 
        if (backtrace_process == NULL)
            return;
 
        nframes = CaptureStackBackTrace(num_skip, lengthof(frames), frames, NULL);
 
        if (nframes == 0)
        {
            appendStringInfoString(&errtrace, "zero stack frames captured");
            edata->backtrace = errtrace.data;
            return;
        }
 
        psymbol = (PSYMBOL_INFOW) buffer;
        psymbol->MaxNameLen = MAX_SYM_NAME;
        psymbol->SizeOfStruct = sizeof(SYMBOL_INFOW);
 
        for (int i = 0; i < nframes; i++)
        {
            DWORD64     address = (DWORD64) frames[i];
            DWORD64     displacement = 0;
            BOOL        sym_result;
 
            sym_result = SymFromAddrW(backtrace_process,
                                      address,
                                      &displacement,
                                      psymbol);
            if (sym_result == TRUE)
            {
                char        symbol_name[MAX_SYM_NAME];
                size_t      result;
 
                /*
                 * Convert symbol name from UTF-16 to database encoding using
                 * wchar2char(), which handles both UTF-8 and non-UTF-8
                 * databases correctly on Windows.
                 */
                result = wchar2char(symbol_name, (const wchar_t *) psymbol->Name,
                                    sizeof(symbol_name), NULL);
 
                if (result == (size_t) -1 || result == sizeof(symbol_name))
                {
                    /* Conversion failed, use address only */
                    appendStringInfo(&errtrace,
                                     "\n[0x%llx]",
                                     (unsigned long long) address);
                }
                else
                {
                    IMAGEHLP_LINEW64 line;
                    DWORD       line_displacement = 0;
                    char        filename[MAX_PATH];
 
                    line.SizeOfStruct = sizeof(IMAGEHLP_LINEW64);
 
                    /* Start with the common part: symbol+offset [address] */
                    appendStringInfo(&errtrace,
                                     "\n%s+0x%llx [0x%llx]",
                                     symbol_name,
                                     (unsigned long long) displacement,
                                     (unsigned long long) address);
 
                    /* Try to append line info if available */
                    if (SymGetLineFromAddrW64(backtrace_process,
                                              address,
                                              &line_displacement,
                                              &line))
                    {
                        result = wchar2char(filename, (const wchar_t *) line.FileName,
                                            sizeof(filename), NULL);
 
                        if (result != (size_t) -1 && result != sizeof(filename))
                        {
                            appendStringInfo(&errtrace,
                                             " [%s:%lu]",
                                             filename,
                                             (unsigned long) line.LineNumber);
                        }
                    }
                }
            }
            else
            {
                appendStringInfo(&errtrace,
                                 "\n[0x%llx] (symbol lookup failed: error code %lu)",
                                 (unsigned long long) address,
                                 GetLastError());
            }
        }
    }
#else
    appendStringInfoString(&errtrace,
                           "backtrace generation is not supported by this installation");
#endif
 
    edata->backtrace = errtrace.data;
}

References appendStringInfo(), appendStringInfoString(), backtrace_cleanup(), fb(), filename, free, i, initStringInfo(), lengthof, on_proc_exit(), and wchar2char().

Referenced by errbacktrace(), and errfinish().

◆ set_errdata_field()

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

static

◆ set_stack_entry_domain()

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

static

Definition at line 799 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 fb(), 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 816 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 fb(), filename, and funcname.

Referenced by errfinish(), and errsave_finish().

◆ should_output_to_client()

static bool should_output_to_client ( int elevel )

inlinestatic

Definition at line 256 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 247 of file elog.c.

{
    return is_log_level_output(elevel, log_min_messages[MyBackendType]);
}

References is_log_level_output(), log_min_messages, and MyBackendType.

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

◆ ThrowErrorData()

void ThrowErrorData ( ErrorData * edata )

Definition at line 2090 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 errfinish(), errordata, errordata_stack_depth, errstart(), fb(), MemoryContextSwitchTo(), pstrdup(), and recursion_depth.

Referenced by ProcessParallelMessage(), and statatt_build_stavalues().

◆ unpack_sql_state()

char * unpack_sql_state ( int sql_state )

Definition at line 3653 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, fb(), 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().

◆ vwrite_stderr()

void vwrite_stderr	(	const char *	fmt,
		va_list	ap
	)

Definition at line 4240 of file elog.c.

{
#ifdef WIN32
    char        errbuf[2048];   /* Arbitrary size? */
#endif
 
    fmt = _(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
}

References _, ERROR, fb(), pgwin32_is_service(), vfprintf, vsnprintf, and write_console().

Referenced by log_error(), and write_stderr().

◆ write_console()

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

static

Definition at line 3026 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, fb(), in_error_recursion_trouble(), len, pfree(), redirection_done, and write.

Referenced by send_message_to_server_log(), and vwrite_stderr().

◆ write_pipe_chunks()

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

Definition at line 3913 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, fb(), 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 4225 of file elog.c.

{
    va_list     ap;
 
    va_start(ap, fmt);
    vwrite_stderr(fmt, ap);
    va_end(ap);
}

References fb(), and vwrite_stderr().

Variable Documentation

◆ arg

Datum arg

Definition at line 1321 of file elog.c.

{
#ifdef _MSC_VER
    /*
     * Currently only used to clean up after SymInitialize.  We shouldn't ever
     * be called if backtrace_process is NULL, but better be safe.
     */
    if (backtrace_process)
    {
        SymCleanup(backtrace_process);
        backtrace_process = NULL;
    }
#endif
}
 
/*
 * errmsg_internal --- add a primary error message text to the current error
 *
 * This is exactly like errmsg() except that strings passed to errmsg_internal
 * are not translated, and are customarily left out of the
 * internationalization message dictionary.  This should be used for "can't
 * happen" cases that are probably not worth spending translation effort on.
 * We also use this for certain cases where we *must* not try to translate
 * the message because the translation would fail and result in infinite
 * error recursion.
 */
int
errmsg_internal(const char *fmt,...)
{
    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 */
}
 
 
/*
 * errmsg_plural --- add a primary error message text to the current error,
 * with support for pluralization of the message text
 */
int
errmsg_plural(const char *fmt_singular, const char *fmt_plural,
              unsigned long n,...)
{
    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 */
}
 
 
/*
 * errdetail --- add a detail error message text to the current error
 */
int
errdetail(const char *fmt,...)
{
    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 */
}
 
 
/*
 * errdetail_internal --- add a detail error message text to the current error
 *
 * This is exactly like errdetail() except that strings passed to
 * errdetail_internal are not translated, and are customarily left out of the
 * internationalization message dictionary.  This should be used for detail
 * messages that seem not worth translating for one reason or another
 * (typically, that they don't seem to be useful to average users).
 */
int
errdetail_internal(const char *fmt,...)
{
    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 */
}
 
 
/*
 * errdetail_log --- add a detail_log error message text to the current error
 */
int
errdetail_log(const char *fmt,...)
{
    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 */
}
 
/*
 * errdetail_log_plural --- add a detail_log error message text to the current error
 * with support for pluralization of the message text
 */
int
errdetail_log_plural(const char *fmt_singular, const char *fmt_plural,
                     unsigned long n,...)
{
    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 */
}
 
 
/*
 * errdetail_plural --- add a detail error message text to the current error,
 * with support for pluralization of the message text
 */
int
errdetail_plural(const char *fmt_singular, const char *fmt_plural,
                 unsigned long n,...)
{
    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 */
}
 
 
/*
 * errhint --- add a hint error message text to the current error
 */
int
errhint(const char *fmt,...)
{
    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 */
}
 
/*
 * errhint_internal --- add a hint error message text to the current error
 *
 * Non-translated version of errhint(), see also errmsg_internal().
 */
int
errhint_internal(const char *fmt,...)
{
    ErrorData  *edata = &errordata[errordata_stack_depth];
    MemoryContext oldcontext;
 
    recursion_depth++;
    CHECK_STACK_DEPTH();
    oldcontext = MemoryContextSwitchTo(edata->assoc_context);
 
    EVALUATE_MESSAGE(edata->domain, hint, false, false);
 
    MemoryContextSwitchTo(oldcontext);
    recursion_depth--;
    return 0;                   /* return value does not matter */
}
 
/*
 * errhint_plural --- add a hint error message text to the current error,
 * with support for pluralization of the message text
 */
int
errhint_plural(const char *fmt_singular, const char *fmt_plural,
               unsigned long n,...)
{
    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 */
}
 
 
/*
 * errcontext_msg --- add a context error message text to the current error
 *
 * Unlike other cases, multiple calls are allowed to build up a stack of
 * context information.  We assume earlier calls represent more-closely-nested
 * states.
 */
int
errcontext_msg(const char *fmt,...)
{
    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 */
}
 
/*
 * set_errcontext_domain --- set message domain to be used by errcontext()
 *
 * errcontext_msg() can be called from a different module than the original
 * ereport(), so we cannot use the message domain passed in errstart() to
 * translate it.  Instead, each errcontext_msg() call should be preceded by
 * a set_errcontext_domain() call to specify the domain.  This is usually
 * done transparently by the errcontext() macro.
 */
int
set_errcontext_domain(const char *domain)
{
    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 */
}
 
 
/*
 * errhidestmt --- optionally suppress STATEMENT: field of log entry
 *
 * This should be called if the message text already includes the statement.
 */
int
errhidestmt(bool hide_stmt)
{
    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 */
}
 
/*
 * errhidecontext --- optionally suppress CONTEXT: field of log entry
 *
 * This should only be used for verbose debugging messages where the repeated
 * inclusion of context would bloat the log volume too much.
 */
int
errhidecontext(bool hide_ctx)
{
    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 */
}
 
/*
 * errposition --- add cursor position to the current error
 */
int
errposition(int cursorpos)
{
    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 */
}
 
/*
 * internalerrposition --- add internal cursor position to the current error
 */
int
internalerrposition(int cursorpos)
{
    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 */
}
 
/*
 * internalerrquery --- add internal query text to the current error
 *
 * Can also pass NULL to drop the internal query text entry.  This case
 * is intended for use in error callback subroutines that are editorializing
 * on the layout of the error report.
 */
int
internalerrquery(const char *query)
{
    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 */
}
 
/*
 * err_generic_string -- used to set individual ErrorData string fields
 * identified by PG_DIAG_xxx codes.
 *
 * This intentionally only supports fields that don't use localized strings,
 * so that there are no translation considerations.
 *
 * Most potential callers should not use this directly, but instead prefer
 * higher-level abstractions, such as errtablecol() (see relcache.c).
 */
int
err_generic_string(int field, const char *str)
{
    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 */
}
 
/*
 * set_errdata_field --- set an ErrorData string field
 */
static void
set_errdata_field(MemoryContextData *cxt, char **ptr, const char *str)
{
    Assert(*ptr == NULL);
    *ptr = MemoryContextStrdup(cxt, str);
}
 
/*
 * geterrcode --- return the currently set SQLSTATE error code
 *
 * This is only intended for use in error callback subroutines, since there
 * is no other place outside elog.c where the concept is meaningful.
 */
int
geterrcode(void)
{
    ErrorData  *edata = &errordata[errordata_stack_depth];
 
    /* we don't bother incrementing recursion_depth */
    CHECK_STACK_DEPTH();
 
    return edata->sqlerrcode;
}
 
/*
 * geterrposition --- return the currently set error position (0 if none)
 *
 * This is only intended for use in error callback subroutines, since there
 * is no other place outside elog.c where the concept is meaningful.
 */
int
geterrposition(void)
{
    ErrorData  *edata = &errordata[errordata_stack_depth];
 
    /* we don't bother incrementing recursion_depth */
    CHECK_STACK_DEPTH();
 
    return edata->cursorpos;
}
 
/*
 * getinternalerrposition --- same for internal error position
 *
 * This is only intended for use in error callback subroutines, since there
 * is no other place outside elog.c where the concept is meaningful.
 */
int
getinternalerrposition(void)
{
    ErrorData  *edata = &errordata[errordata_stack_depth];
 
    /* we don't bother incrementing recursion_depth */
    CHECK_STACK_DEPTH();
 
    return edata->internalpos;
}

Referenced by _bt_compare_array_elements(), _bt_end_vacuum_callback(), _bt_mkscankey(), _SPI_error_callback(), accesstype_arg_to_string(), accumArrayResultArr(), add_one(), add_one_float8(), add_tablespace_mapping(), adjacent_cmp_bounds(), adjacent_inner_consistent(), adjust_group_pathkeys_for_groupagg(), advance_windowaggregate(), advance_windowaggregate_base(), AggRegisterCallback(), applyRelabelType(), archive_close_connection(), array_append_support(), array_prepend_support(), ATColumnChangeRequiresRewrite(), auto_mem_destructor(), AuxiliaryProcKill(), bcTruelen(), before_shmem_exit(), binaryheap_allocate(), bind_param_error_callback(), bit(), bit_bit_count(), bitlength(), bitnot(), bitoctetlength(), bitshiftleft(), bitshiftright(), bitsubstring(), bittoint4(), bittoint8(), booltestsel(), boolvarsel(), bound_cmp(), bpcharlen(), bpcharoctetlen(), bsearch_arg(), build_subplan(), CacheRegisterRelcacheCallback(), CacheRegisterRelSyncCallback(), CacheRegisterSyscacheCallback(), cancel_before_shmem_exit(), cancel_on_dsm_detach(), chr(), clause_is_strict_for(), clause_selectivity_ext(), cleanup_background_workers(), CleanupInvalidationState(), cmpEntries(), cmpEntryAccumulator(), coerce_record_to_complex(), coerce_to_domain(), coerce_to_target_type(), compare_expanded_ranges(), compare_scalars(), compare_scalars_simple(), compare_values(), compareentry(), compareQueryOperand(), comparetup_cluster_tiebreak(), comparetup_index_btree_tiebreak(), comparetup_index_hash(), ComputeIndexAttrs(), ComputePartitionAttrs(), contain_nonstrict_functions_walker(), conversion_error_callback(), convert_and_check_filename(), CopyFromErrorCallback(), createdb_failure_callback(), daitch_mokotoff(), dccref_deletion_callback(), decrypt_init(), defaultNoticeProcessor(), defaultNoticeReceiver(), deparseAggref(), deparseFuncExpr(), descriptor_destructor(), dmetaphone(), dmetaphone_alt(), do_pg_abort_backup(), dshash_attach(), dshash_create(), dsm_detach(), dsm_postmaster_shutdown(), dumpLOs(), ec_member_matches_foreign(), ec_member_matches_indexcol(), ecpg_sqlca_key_destructor(), ECPGnoticeReceiver(), element_compare(), entryIndexByFrequencyCmp(), enum_known_sorted(), ER_mc_callback(), eval_const_expressions_mutator(), evaluate_function(), examine_opclause_args(), examine_variable(), ExecBuildAggTrans(), ExecEvalFuncArgs(), ExecEvalXmlExpr(), ExecIndexBuildScanKeys(), ExecInitExprRec(), ExecInitFunc(), ExecInitSubPlanExpr(), ExecuteDoStmt(), exp_var(), expand_function_arguments(), expr_is_nonnullable(), exprCollation(), expression_tree_walker_impl(), exprIsNullConstant(), exprLocation(), exprSetCollation(), exprType(), exprTypmod(), extract_jsp_bool_expr(), extract_jsp_path_expr_nodes(), FigureColnameInternal(), find_duplicate_ors(), find_enumitem(), find_param_referent(), find_window_run_conditions(), fix_indexqual_operand(), flatten_set_variable_args(), flattenJsonPathParseItem(), float4up(), float8up(), fn(), fn(), freestate_cluster(), gbt_vsrt_cmp(), gen_partprune_steps_internal(), get_agg_expr_helper(), get_call_expr_arg_stable(), get_cast_hashentry(), get_coercion_expr(), get_func_expr(), get_oper_expr(), get_rule_expr(), get_stats_option_name(), get_windowfunc_expr_helper(), GetNamedDSMSegment(), ginAllocEntryAccumulator(), ginCombineData(), gincost_opexpr(), gincost_scalararrayopexpr(), ginExtractEntries(), group_similar_or_args(), guc_restore_error_context_callback(), HandleSlashCmds(), heap_compare_slots(), heap_compare_slots(), heap_inplace_lock(), i8tod(), i8tof(), i8tooid(), ignore_slash_filepipe(), ignore_slash_options(), ignore_slash_whole_line(), import_error_callback(), indexOfColumn(), init_tdr_dsm(), injection_error(), injection_notice(), injection_points_cached(), injection_points_run(), InjectionPointCached(), InjectionPointRun(), inline_function(), int28(), int2um(), int2up(), int48(), int4inc(), int4um(), int4up(), int82(), int84(), int8dec(), int8inc(), int8inc_support(), int8um(), int8up(), interval_cmp_lower(), interval_cmp_upper(), InvalidateTSCacheCallBack(), isort_cmp(), isotesterNoticeProcessor(), isSimpleNode(), IsSquashableConstant(), json_object_agg_transfn_worker(), jsonb_agg_finalfn(), jsonb_object_agg_finalfn(), jspIsMutableWalker(), left_oper(), libpqsrv_notice_receiver(), ln_var(), local_buffer_write_error_callback(), main(), make_nulltest_from_distinct(), makeDefElem(), makeDefElemExtended(), makeRelabelType(), match_boolean_index_clause(), match_boolean_partition_clause(), match_clause_to_partition_key(), match_eclass_clauses_to_index(), match_eclasses_to_foreign_key_col(), match_expr_to_partition_keys(), match_index_to_operand(), matches_boolean_partition_clause(), mdc_init(), mdcbuf_init(), movedb_failure_callback(), multi_sort_compare(), notice_processor(), NoticeProcessor(), nulltestsel(), numeric_exp(), numeric_inc(), numeric_is_integral(), numeric_ln(), numeric_min_scale(), numeric_round(), numeric_sqrt(), numeric_trunc(), oidtoi8(), oidtooid8(), on_dsm_detach(), on_proc_exit(), on_shmem_exit(), ordered_set_shutdown(), output_plugin_error_callback(), pa_shutdown(), pairingheap_allocate(), pairingheap_GISTSearchItem_cmp(), pairingheap_initialize(), pairingheap_SpGistSearchItem_cmp(), parallel_vacuum_error_callback(), ParallelWorkerShutdown(), paramlist_parser_setup(), ParamsErrorCallback(), ParseFuncOrColumn(), pcb_error_callback(), pg_digest(), pg_hmac(), pg_size_bytes(), pg_snapshot_xip(), pgaio_worker_error_callback(), pgp_pub_decrypt_bytea(), pgp_pub_decrypt_text(), pgp_pub_encrypt_bytea(), pgp_pub_encrypt_text(), pgp_sym_decrypt_bytea(), pgp_sym_decrypt_text(), pgp_sym_encrypt_bytea(), pgp_sym_encrypt_text(), pgstat_cmp_hash_key(), pgstat_hash_hash_key(), plperl_compile_callback(), plperl_exec_callback(), plperl_ref_from_pg_array(), plpgsql_compile_error_callback(), plpgsql_exec_error_callback(), plpython_error_callback(), plpython_srf_cleanup_callback(), PLy_cursor_plan(), PLy_function_build_args(), PLy_input_convert(), PLy_input_from_tuple(), PLy_input_setup_func(), PLy_input_setup_tuple(), PLy_output_convert(), PLy_output_setup_func(), PLy_output_setup_record(), PLy_output_setup_tuple(), PLy_result_ass_subscript(), PLy_result_item(), PLy_result_length(), PLy_result_str(), PLy_result_subscript(), PLy_spi_execute_plan(), PLyDict_FromComposite(), PLyDict_FromTuple(), PLyGenericObject_ToComposite(), PLyList_FromArray(), PLyMapping_ToComposite(), PLyObject_FromTransform(), PLyObject_ToComposite(), PLyObject_ToDomain(), PLyObject_ToScalar(), PLyObject_ToTransform(), PLySequence_ToArray(), PLySequence_ToComposite(), PLyUnicode_FromScalar(), PLyUnicode_ToComposite(), postgresGetForeignPaths(), PQsetnonblocking(), PQsetNoticeProcessor(), PQsetNoticeReceiver(), prefix_init(), proc_exit_prepare(), process_data_type_check(), process_extension_updates(), process_gist_inet_ops_check(), process_incompat_polymorphics(), process_inconsistent_notnull(), process_isn_and_int8_passing_mismatch(), process_loadable_libraries(), process_matched_tle(), process_old_sub_state_check(), process_unicode_update(), process_user_defined_encoding_conversions(), process_user_defined_postfix_ops(), process_with_oids_check(), pts_error_callback(), pull_ands(), pull_from_mbuf(), pull_ors(), push_into_mbuf(), qsort_partition_list_value_cmp(), qsort_partition_rbound_cmp(), qunique_arg(), quote_postgres(), range_bound_qsort_cmp(), range_compare(), RangeVarCallbackForAlterRelation(), RangeVarCallbackForAttachIndex(), RangeVarCallbackForDblink(), RangeVarCallbackForDropRelation(), RangeVarCallbackForLockTable(), RangeVarCallbackForReindexIndex(), RangeVarCallbackForStats(), raw_expression_tree_walker_impl(), rbt_create(), readtup_cluster(), readtup_index(), RegisterExprContextCallback(), RegisterResourceReleaseCallback(), RegisterSubXactCallback(), RegisterXactCallback(), REGRESS_object_access_hook(), REGRESS_object_access_hook_str(), reindex_error_callback(), removeabbrev_cluster(), removeabbrev_index(), RemoveSQLFunctionCache(), reorder_function_arguments(), ReorderBufferIterCompare(), reorderqueue_cmp(), rm_redo_error_callback(), runShellCommand(), scb_error_callback(), script_error_callback(), sepgsql_object_access(), set_option(), set_plan_disabling_options(), shared_buffer_write_error_callback(), shared_record_table_compare(), shared_record_table_hash(), shm_mq_detach_callback(), shmem_exit(), show_tablesample(), shutdown_MultiFuncCall(), ShutdownSetExpr(), ShutdownSQLFunction(), simplify_and_arguments(), simplify_or_arguments(), single_bound_cmp(), slotsync_failure_callback(), slotsync_worker_disconnect(), sort_item_compare(), soundex(), split_selfjoin_quals(), sql_compile_error_callback(), sql_exec_error_callback(), sql_function_parse_error_callback(), sql_inline_error_callback(), sql_postrewrite_callback(), sqrt_var(), start_proc_error_callback(), statext_is_compatible_clause_internal(), strip_array_coercion(), tablesample_init(), tablespace_list_append(), tbm_shared_comparator(), test_custom_rmgrs_insert_wal_record(), test_thread(), text_format(), threadRun(), tokenize_error_callback(), transformAggregateCall(), transformBoolExpr(), transformCaseExpr(), transformFuncCall(), transformJsonArrayAgg(), transformJsonParseExpr(), transformJsonPassingArgs(), transformJsonScalarExpr(), transformJsonSerializeExpr(), transformRangeFunction(), transformRangeTableSample(), transformTypeCast(), TS_execute(), TS_execute_locations(), TS_execute_locations_recurse(), TS_execute_recurse(), TS_execute_ternary(), TS_phrase_execute(), tsearch_readline_callback(), tuplesort_begin_cluster(), tuplesort_begin_datum(), tuplesort_begin_index_btree(), tuplesort_begin_index_gist(), tuplesort_begin_index_hash(), tuplesort_getdatum(), tuplesort_putdatum(), tuplesort_putheaptuple(), tuplesort_putindextuplevalues(), UnregisterExprContextCallback(), UnregisterResourceReleaseCallback(), UnregisterSubXactCallback(), UnregisterXactCallback(), upgrade_task_add_step(), vacuum_error_callback(), varbit(), waitonlock_error_callback(), WalRcvDie(), writetup_datum(), XactLockTableWaitErrorCb(), xml_is_document(), xmlcomment(), xmlelement(), xmlpi(), and xmltext().

◆ backtrace_function_list

char* backtrace_function_list

static

Definition at line 121 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 110 of file elog.c.

Referenced by EmitErrorReport().

◆ error_context_stack

ErrorContextCallback* error_context_stack = NULL

Definition at line 99 of file elog.c.

◆ errordata

ErrorData errordata[ERRORDATA_STACK_SIZE]

static

Definition at line 155 of file elog.c.

Referenced by CopyErrorData(), EmitErrorReport(), errbacktrace(), errcode(), errcode_for_file_access(), errcode_for_socket_access(), errfinish(), errmsg(), errsave_finish(), errstart(), get_error_stack_entry(), pg_re_throw(), and ThrowErrorData().

◆ errordata_stack_depth

int errordata_stack_depth = -1

static

Definition at line 157 of file elog.c.

Referenced by CopyErrorData(), EmitErrorReport(), errbacktrace(), errcode(), errcode_for_file_access(), errcode_for_socket_access(), errfinish(), errmsg(), errsave_finish(), errstart(), FlushErrorState(), get_error_stack_entry(), GetErrorContextStack(), pg_re_throw(), and ThrowErrorData().

◆ formatted_log_time

char formatted_log_time[FORMATTED_TS_LEN]

static

Definition at line 170 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 169 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 115 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 116 of file elog.c.

Referenced by PostmasterMain().

◆ Log_error_verbosity

int Log_error_verbosity = PGERROR_DEFAULT

Definition at line 113 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 114 of file elog.c.

Referenced by log_line_prefix().

◆ PG_exception_stack

sigjmp_buf* PG_exception_stack = NULL

Definition at line 101 of file elog.c.

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

◆ recursion_depth

int recursion_depth = 0

static

Definition at line 159 of file elog.c.

Referenced by AcceptInvalidationMessages(), EmitErrorReport(), errbacktrace(), errfinish(), errmsg(), errsave_finish(), errsave_start(), errstart(), FlushErrorState(), GetErrorContextStack(), in_error_recursion_trouble(), ReThrowError(), and ThrowErrorData().

◆ save_format_domain

const char* save_format_domain

static

Definition at line 1837 of file elog.c.

Referenced by format_elog_string(), and pre_format_elog_string().

◆ saved_timeval

struct timeval saved_timeval

static

Definition at line 165 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 166 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 117 of file elog.c.

◆ syslog_split_messages

bool syslog_split_messages = true

Definition at line 118 of file elog.c.

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]

Datum	arg

static const char *	save_format_domain

Macros

Functions

Variables

Macro Definition Documentation

◆ _

◆ CHECK_STACK_DEPTH

◆ ERRORDATA_STACK_SIZE

◆ EVALUATE_MESSAGE

◆ EVALUATE_MESSAGE_PLURAL

◆ FORMATTED_TS_LEN

◆ PG_PROCTYPE

Function Documentation

◆ append_with_tabs()

◆ assign_backtrace_functions()

◆ assign_log_destination()

◆ assign_log_min_messages()

◆ assign_syslog_facility()

◆ assign_syslog_ident()

◆ backtrace_cleanup()

◆ check_backtrace_functions()

◆ check_log_destination()

◆ check_log_min_messages()

◆ check_log_of_query()

◆ CopyErrorData()

◆ DebugFileOpen()

◆ EmitErrorReport()

◆ err_gettext()

◆ err_sendstring()

◆ errbacktrace()

◆ errcode()

◆ errcode_for_file_access()

◆ errcode_for_socket_access()

◆ errfinish()

◆ errmsg()

◆ error_severity()

◆ 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()

◆ GetErrorContextStack()

◆ in_error_recursion_trouble()

◆ is_log_level_output()

◆ log_line_prefix()

◆ log_min_messages_cmp()

◆ log_status_format()

◆ matches_backtrace_functions()

◆ message_level_is_interesting()

◆ pg_attribute_unused()

◆ 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_errdata_field()

◆ set_stack_entry_domain()

◆ set_stack_entry_location()

◆ should_output_to_client()

◆ should_output_to_server()

◆ ThrowErrorData()

◆ unpack_sql_state()

◆ vwrite_stderr()

◆ write_console()

◆ write_pipe_chunks()

◆ write_stderr()

Variable Documentation

◆ arg

◆ backtrace_function_list

◆ emit_log_hook

◆ error_context_stack