/*
* XactLockTableWait
*
* Wait for the specified transaction to commit or abort. If an operation
* is specified, an error context callback is set up. If 'oper' is passed as
* None, no error context callback is set up.
*
* Note that this does the right thing for subtransactions: if we wait on a
* subtransaction, we will exit as soon as it aborts or its top parent commits.
* It takes some extra work to ensure this, because to save on shared memory
* the XID lock of a subtransaction is released when it ends, whether
* successfully or unsuccessfully. So we have to check if it's "still running"
* and if so wait for its parent.
*/
void
XactLockTableWait(TransactionId xid, Relation rel, ItemPointer ctid,
XLTW_Oper oper)
{
LOCKTAG tag;
XactLockTableWaitInfo info;
ErrorContextCallback callback;
/*
* If an operation is specified, set up our verbose error context
* callback.
*/
if (oper != XLTW_None)
{
Assert(RelationIsValid(rel));
Assert(ItemPointerIsValid(ctid));
info.rel = rel;
info.ctid = ctid;
info.oper = oper;
callback.callback = XactLockTableWaitErrorCb;
callback.arg = &info;
callback.previous = error_context_stack;
error_context_stack = &callback;
}
for (;;)
{
Assert(TransactionIdIsValid(xid));
Assert(!TransactionIdEquals(xid, GetTopTransactionIdIfAny()));
SET_LOCKTAG_TRANSACTION(tag, xid);
(void) LockAcquire(&tag, ShareLock, false, false);
LockRelease(&tag, ShareLock, false);
if (!TransactionIdIsInProgress(xid))
break;
xid = SubTransGetParent(xid);
}
if (oper != XLTW_None)
error_context_stack = callback.previous;
}
/*
* XactLockTableWait
*
* Wait for the specified transaction to commit or abort.
*
* Note that this does the right thing for subtransactions: if we wait on a
* subtransaction, we will exit as soon as it aborts or its top parent commits.
* It takes some extra work to ensure this, because to save on shared memory
* the XID lock of a subtransaction is released when it ends, whether
* successfully or unsuccessfully. So we have to check if it's "still running"
* and if so wait for its parent.
*/
void
XactLockTableWait(TransactionId xid)
{
LOCKTAG tag;
for (;;)
{
Assert(TransactionIdIsValid(xid));
Assert(!TransactionIdEquals(xid, GetTopTransactionIdIfAny()));
SET_LOCKTAG_TRANSACTION(tag, xid);
(void) LockAcquire(&tag, ShareLock, false, false);
LockRelease(&tag, ShareLock, false);
if (!TransactionIdIsInProgress(xid))
break;
xid = SubTransGetParent(xid);
}
}
/* Initialize SpGistState for working with the given index */
void
initSpGistState(SpGistState *state, Relation index)
{
SpGistCache *cache;
/* Get cached static information about index */
cache = spgGetCache(index);
state->config = cache->config;
state->attType = cache->attType;
state->attPrefixType = cache->attPrefixType;
state->attLabelType = cache->attLabelType;
/* Make workspace for constructing dead tuples */
state->deadTupleStorage = palloc0(SGDTSIZE);
/* Set XID to use in redirection tuples */
state->myXid = GetTopTransactionIdIfAny();
/* Assume we're not in an index build (spgbuild will override) */
state->isBuild = false;
}
/*
* ConditionalXactLockTableWait
*
* As above, but only lock if we can get the lock without blocking.
* Returns TRUE if the lock was acquired.
*/
bool
ConditionalXactLockTableWait(TransactionId xid)
{
LOCKTAG tag;
for (;;)
{
Assert(TransactionIdIsValid(xid));
Assert(!TransactionIdEquals(xid, GetTopTransactionIdIfAny()));
SET_LOCKTAG_TRANSACTION(tag, xid);
if (LockAcquire(&tag, ShareLock, false, true) == LOCKACQUIRE_NOT_AVAIL)
return false;
LockRelease(&tag, ShareLock, false);
if (!TransactionIdIsInProgress(xid))
break;
xid = SubTransGetParent(xid);
}
return true;
}
/*
* ImportSnapshot
* Import a previously exported snapshot. The argument should be a
* filename in SNAPSHOT_EXPORT_DIR. Load the snapshot from that file.
* This is called by "SET TRANSACTION SNAPSHOT 'foo'".
*/
void
ImportSnapshot(const char *idstr)
{
char path[MAXPGPATH];
FILE *f;
struct stat stat_buf;
char *filebuf;
int xcnt;
int i;
TransactionId src_xid;
Oid src_dbid;
int src_isolevel;
bool src_readonly;
SnapshotData snapshot;
/*
* Must be at top level of a fresh transaction. Note in particular that
* we check we haven't acquired an XID --- if we have, it's conceivable
* that the snapshot would show it as not running, making for very
* screwy behavior.
*/
if (FirstSnapshotSet ||
GetTopTransactionIdIfAny() != InvalidTransactionId ||
IsSubTransaction())
ereport(ERROR,
(errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
errmsg("SET TRANSACTION SNAPSHOT must be called before any query")));
/*
* If we are in read committed mode then the next query would execute
* with a new snapshot thus making this function call quite useless.
*/
if (!IsolationUsesXactSnapshot())
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("a snapshot-importing transaction must have isolation level SERIALIZABLE or REPEATABLE READ")));
/*
* Verify the identifier: only 0-9, A-F and hyphens are allowed. We do
* this mainly to prevent reading arbitrary files.
*/
if (strspn(idstr, "0123456789ABCDEF-") != strlen(idstr))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid snapshot identifier \"%s\"", idstr)));
/* OK, read the file */
snprintf(path, MAXPGPATH, SNAPSHOT_EXPORT_DIR "/%s", idstr);
f = AllocateFile(path, PG_BINARY_R);
if (!f)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid snapshot identifier \"%s\"", idstr)));
/* get the size of the file so that we know how much memory we need */
if (fstat(fileno(f), &stat_buf))
elog(ERROR, "could not stat file \"%s\": %m", path);
/* and read the file into a palloc'd string */
filebuf = (char *) palloc(stat_buf.st_size + 1);
if (fread(filebuf, stat_buf.st_size, 1, f) != 1)
elog(ERROR, "could not read file \"%s\": %m", path);
filebuf[stat_buf.st_size] = '\0';
FreeFile(f);
/*
* Construct a snapshot struct by parsing the file content.
*/
memset(&snapshot, 0, sizeof(snapshot));
src_xid = parseXidFromText("xid:", &filebuf, path);
/* we abuse parseXidFromText a bit here ... */
src_dbid = parseXidFromText("dbid:", &filebuf, path);
src_isolevel = parseIntFromText("iso:", &filebuf, path);
src_readonly = parseIntFromText("ro:", &filebuf, path);
snapshot.xmin = parseXidFromText("xmin:", &filebuf, path);
snapshot.xmax = parseXidFromText("xmax:", &filebuf, path);
snapshot.xcnt = xcnt = parseIntFromText("xcnt:", &filebuf, path);
/* sanity-check the xid count before palloc */
if (xcnt < 0 || xcnt > GetMaxSnapshotXidCount())
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid snapshot data in file \"%s\"", path)));
snapshot.xip = (TransactionId *) palloc(xcnt * sizeof(TransactionId));
for (i = 0; i < xcnt; i++)
snapshot.xip[i] = parseXidFromText("xip:", &filebuf, path);
snapshot.suboverflowed = parseIntFromText("sof:", &filebuf, path);
if (!snapshot.suboverflowed)
{
snapshot.subxcnt = xcnt = parseIntFromText("sxcnt:", &filebuf, path);
/* sanity-check the xid count before palloc */
if (xcnt < 0 || xcnt > GetMaxSnapshotSubxidCount())
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid snapshot data in file \"%s\"", path)));
snapshot.subxip = (TransactionId *) palloc(xcnt * sizeof(TransactionId));
for (i = 0; i < xcnt; i++)
snapshot.subxip[i] = parseXidFromText("sxp:", &filebuf, path);
}
else
{
snapshot.subxcnt = 0;
snapshot.subxip = NULL;
}
snapshot.takenDuringRecovery = parseIntFromText("rec:", &filebuf, path);
/*
* Do some additional sanity checking, just to protect ourselves. We
* don't trouble to check the array elements, just the most critical
* fields.
*/
if (!TransactionIdIsNormal(src_xid) ||
!OidIsValid(src_dbid) ||
!TransactionIdIsNormal(snapshot.xmin) ||
!TransactionIdIsNormal(snapshot.xmax))
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid snapshot data in file \"%s\"", path)));
/*
* If we're serializable, the source transaction must be too, otherwise
* predicate.c has problems (SxactGlobalXmin could go backwards). Also,
* a non-read-only transaction can't adopt a snapshot from a read-only
* transaction, as predicate.c handles the cases very differently.
*/
if (IsolationIsSerializable())
{
if (src_isolevel != XACT_SERIALIZABLE)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("a serializable transaction cannot import a snapshot from a non-serializable transaction")));
if (src_readonly && !XactReadOnly)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("a non-read-only serializable transaction cannot import a snapshot from a read-only transaction")));
}
/*
* We cannot import a snapshot that was taken in a different database,
* because vacuum calculates OldestXmin on a per-database basis; so the
* source transaction's xmin doesn't protect us from data loss. This
* restriction could be removed if the source transaction were to mark
* its xmin as being globally applicable. But that would require some
* additional syntax, since that has to be known when the snapshot is
* initially taken. (See pgsql-hackers discussion of 2011-10-21.)
*/
if (src_dbid != MyDatabaseId)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot import a snapshot from a different database")));
/* OK, install the snapshot */
SetTransactionSnapshot(&snapshot, src_xid);
}
/*
* write_jsonlog
* Write logs in json format.
*/
static void
write_jsonlog(ErrorData *edata)
{
StringInfoData buf;
TransactionId txid = GetTopTransactionIdIfAny();
initStringInfo(&buf);
/* Initialize string */
appendStringInfoChar(&buf, '{');
/* Timestamp */
if (log_time[0] == '\0')
setup_formatted_log_time();
appendJSONLiteral(&buf, "timestamp", log_time, true);
/* Username */
if (MyProcPort)
appendJSONLiteral(&buf, "user", MyProcPort->user_name, true);
/* Database name */
if (MyProcPort)
appendJSONLiteral(&buf, "dbname", MyProcPort->database_name, true);
/* Process ID */
if (MyProcPid != 0)
appendStringInfo(&buf, "\"pid\":%d,", MyProcPid);
/* Remote host and port */
if (MyProcPort && MyProcPort->remote_host)
{
appendJSONLiteral(&buf, "remote_host",
MyProcPort->remote_host, true);
if (MyProcPort->remote_port && MyProcPort->remote_port[0] != '\0')
appendJSONLiteral(&buf, "remote_port",
MyProcPort->remote_port, true);
}
/* Session id */
if (MyProcPid != 0)
appendStringInfo(&buf, "\"session_id\":\"%lx.%x\",",
(long) MyStartTime, MyProcPid);
/* Virtual transaction id */
/* keep VXID format in sync with lockfuncs.c */
if (MyProc != NULL && MyProc->backendId != InvalidBackendId)
appendStringInfo(&buf, "\"vxid\":\"%d/%u\",",
MyProc->backendId, MyProc->lxid);
/* Transaction id */
if (txid != InvalidTransactionId)
appendStringInfo(&buf, "\"txid\":%u,", GetTopTransactionIdIfAny());
/* Error severity */
appendJSONLiteral(&buf, "error_severity",
(char *) error_severity(edata->elevel), true);
/* SQL state code */
if (edata->sqlerrcode != ERRCODE_SUCCESSFUL_COMPLETION)
appendJSONLiteral(&buf, "state_code",
unpack_sql_state(edata->sqlerrcode), true);
/* Error detail or Error detail log */
if (edata->detail_log)
appendJSONLiteral(&buf, "detail_log", edata->detail_log, true);
else if (edata->detail)
appendJSONLiteral(&buf, "detail", edata->detail, true);
/* Error hint */
if (edata->hint)
appendJSONLiteral(&buf, "hint", edata->hint, true);
/* Internal query */
if (edata->internalquery)
appendJSONLiteral(&buf, "internal_query",
edata->internalquery, true);
/* Error context */
if (edata->context)
appendJSONLiteral(&buf, "context", edata->context, true);
/* File error location */
if (Log_error_verbosity >= PGERROR_VERBOSE)
{
StringInfoData msgbuf;
initStringInfo(&msgbuf);
if (edata->funcname && edata->filename)
appendStringInfo(&msgbuf, "%s, %s:%d",
edata->funcname, edata->filename,
edata->lineno);
else if (edata->filename)
appendStringInfo(&msgbuf, "%s:%d",
edata->filename, edata->lineno);
appendJSONLiteral(&buf, "file_location", msgbuf.data, true);
pfree(msgbuf.data);
}
/* Application name */
if (application_name && application_name[0] != '\0')
appendJSONLiteral(&buf, "application_name",
application_name, true);
/* Error message */
appendJSONLiteral(&buf, "message", edata->message, false);
/* Finish string */
appendStringInfoChar(&buf, '}');
appendStringInfoChar(&buf, '\n');
/* If in the syslogger process, try to write messages direct to file */
if (am_syslogger)
write_syslogger_file(buf.data, buf.len, LOG_DESTINATION_STDERR);
else
write_pipe_chunks(buf.data, buf.len);
/* Cleanup */
pfree(buf.data);
/* Continue chain to previous hook */
if (prev_log_hook)
(*prev_log_hook) (edata);
}
/*
* redis_log_hook
* Hook for shipping log events to Redis
* (based on jsonlog.c)
*/
static void
redis_log_hook(ErrorData *edata)
{
StringInfoData buf;
TransactionId txid = GetTopTransactionIdIfAny();
bool print_stmt = false;
bool send_status = false;
/* static counter for line numbers */
static long log_line_number = 0;
/*
* 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.
*/
if (lastPid != MyProcPid)
{
log_line_number = 0;
lastPid = MyProcPid;
formatted_start_time[0] = '\0';
redis_close_connection();
}
/*
* Check if the log has to be written, if not just exit.
*/
if (!is_log_level_output(edata->elevel, Redislog_min_messages))
{
goto quickExit;
}
log_line_number++;
initStringInfo(&buf);
/* Initialize string */
appendStringInfoChar(&buf, '{');
/* Timestamp */
setup_formatted_log_time();
append_json_literal(&buf, "@timestamp", formatted_log_time, true);
/* Username */
if (MyProcPort)
append_json_literal(&buf, "user_name", MyProcPort->user_name, true);
/* Database name */
if (MyProcPort)
append_json_literal(&buf, "database_name", MyProcPort->database_name, true);
/* Process ID */
if (MyProcPid != 0)
appendStringInfo(&buf, "\"process_id\":%d,", MyProcPid);
/* Remote host and port */
if (MyProcPort && MyProcPort->remote_host)
{
append_json_literal(&buf, "remote_host",
MyProcPort->remote_host, true);
if (MyProcPort->remote_port && MyProcPort->remote_port[0] != '\0')
append_json_literal(&buf, "remote_port",
MyProcPort->remote_port, true);
}
/* Session id */
if (MyProcPid != 0)
appendStringInfo(&buf, "\"session_id\":\"%lx.%x\",",
(long) MyStartTime, MyProcPid);
/* Process ID */
if (MyProcPid != 0)
appendStringInfo(&buf, "\"session_line_num\":%ld,", log_line_number);
/* PS display */
if (MyProcPort)
{
StringInfoData msgbuf;
const char *psdisp;
int displen;
initStringInfo(&msgbuf);
psdisp = get_ps_display(&displen);
appendBinaryStringInfo(&msgbuf, psdisp, displen);
append_json_literal(&buf, "command_tag", msgbuf.data, true);
pfree(msgbuf.data);
}
/* session start timestamp */
if (formatted_start_time[0] == '\0')
setup_formatted_start_time();
append_json_literal(&buf, "session_start_time", formatted_start_time, true);
/* Virtual transaction id */
/* keep VXID format in sync with lockfuncs.c */
if (MyProc != NULL && MyProc->backendId != InvalidBackendId)
appendStringInfo(&buf, "\"virtual_transaction_id\":\"%d/%u\",",
MyProc->backendId, MyProc->lxid);
/* Transaction id */
if (txid != InvalidTransactionId)
appendStringInfo(&buf, "\"transaction_id\":%u,", GetTopTransactionIdIfAny());
/* Error severity */
append_json_literal(&buf, "error_severity",
(char *) error_severity(edata->elevel), true);
/* SQL state code */
if (edata->sqlerrcode != ERRCODE_SUCCESSFUL_COMPLETION)
append_json_literal(&buf, "sql_state_code",
unpack_sql_state(edata->sqlerrcode), true);
/* Error detail or Error detail log */
if (edata->detail_log)
append_json_literal(&buf, "detail_log", edata->detail_log, true);
else if (edata->detail)
append_json_literal(&buf, "detail", edata->detail, true);
/* Error hint */
if (edata->hint)
append_json_literal(&buf, "hint", edata->hint, true);
/* Internal query */
if (edata->internalquery)
append_json_literal(&buf, "internal_query",
edata->internalquery, true);
/* if printed internal query, print internal pos too */
if (edata->internalpos > 0 && edata->internalquery != NULL)
appendStringInfo(&buf, "\"internal_query_pos\":%d,", edata->internalpos);
/* Error context */
if (edata->context)
append_json_literal(&buf, "context", edata->context, true);
/* user query --- only reported if not disabled by the caller */
if (is_log_level_output(edata->elevel, Redislog_min_error_statement) &&
debug_query_string != NULL &&
!edata->hide_stmt)
print_stmt = true;
if (print_stmt)
append_json_literal(&buf, "query", debug_query_string, true);
/* user query position -- only reposted if not disabled by the caller */
if (print_stmt && edata->cursorpos > 0)
appendStringInfo(&buf, "\"query_pos\":%d,", edata->cursorpos);
/* File error location */
if (Log_error_verbosity >= PGERROR_VERBOSE)
{
StringInfoData msgbuf;
initStringInfo(&msgbuf);
if (edata->funcname && edata->filename)
appendStringInfo(&msgbuf, "%s, %s:%d",
edata->funcname, edata->filename,
edata->lineno);
else if (edata->filename)
appendStringInfo(&msgbuf, "%s:%d",
edata->filename, edata->lineno);
append_json_literal(&buf, "file_location", msgbuf.data, true);
pfree(msgbuf.data);
}
/* Application name */
if (application_name && application_name[0] != '\0')
append_json_literal(&buf, "application_name",
application_name, true);
/* Error message */
append_json_literal(&buf, "message", edata->message, false);
/* Finish string */
appendStringInfoChar(&buf, '}');
appendStringInfoChar(&buf, '\n');
/* Send the data to Redis */
send_status = redis_log_shipper(buf.data, buf.len);
/* Skip sending the event to the server, if it was correctly
* shipped to Redis and if 'ship_to_redis_only' is set to true
*/
if (Redislog_ship_to_redis_only && send_status) {
edata->output_to_server = false;
}
/* Cleanup */
pfree(buf.data);
quickExit:
/* Continue chain to previous hook */
if (prev_log_hook)
(*prev_log_hook) (edata);
}
/*
* write_jsonlog
* Write logs in json format.
*/
static void
write_jsonlog(ErrorData *edata)
{
StringInfoData buf;
TransactionId txid = GetTopTransactionIdIfAny();
/*
* Disable logs to server, we don't want duplicate entries in
* the server.
*/
edata->output_to_server = false;
/* Determine whether message is enabled for server log output */
if (!is_log_level_output(edata->elevel, log_min_messages))
return;
initStringInfo(&buf);
/* Initialize string */
appendStringInfoChar(&buf, '{');
/* Timestamp */
setup_formatted_log_time();
appendJSONLiteral(&buf, "timestamp", formatted_log_time, true);
/* Username */
if (MyProcPort && MyProcPort->user_name)
appendJSONLiteral(&buf, "user", MyProcPort->user_name, true);
/* Database name */
if (MyProcPort && MyProcPort->database_name)
appendJSONLiteral(&buf, "dbname", MyProcPort->database_name, true);
/* Process ID */
if (MyProcPid != 0)
appendStringInfo(&buf, "\"pid\":%d,", MyProcPid);
/* Remote host and port */
if (MyProcPort && MyProcPort->remote_host)
{
appendJSONLiteral(&buf, "remote_host",
MyProcPort->remote_host, true);
if (MyProcPort->remote_port && MyProcPort->remote_port[0] != '\0')
appendJSONLiteral(&buf, "remote_port",
MyProcPort->remote_port, true);
}
/* Session id */
if (MyProcPid != 0)
appendStringInfo(&buf, "\"session_id\":\"%lx.%x\",",
(long) MyStartTime, MyProcPid);
/* Virtual transaction id */
/* keep VXID format in sync with lockfuncs.c */
if (MyProc != NULL && MyProc->backendId != InvalidBackendId)
appendStringInfo(&buf, "\"vxid\":\"%d/%u\",",
MyProc->backendId, MyProc->lxid);
/* Transaction id */
if (txid != InvalidTransactionId)
appendStringInfo(&buf, "\"txid\":%u,", GetTopTransactionIdIfAny());
/* Error severity */
appendJSONLiteral(&buf, "error_severity",
(char *) error_severity(edata->elevel), true);
/* SQL state code */
if (edata->sqlerrcode != ERRCODE_SUCCESSFUL_COMPLETION)
appendJSONLiteral(&buf, "state_code",
unpack_sql_state(edata->sqlerrcode), true);
/* Error detail or Error detail log */
if (edata->detail_log)
appendJSONLiteral(&buf, "detail_log", edata->detail_log, true);
else if (edata->detail)
appendJSONLiteral(&buf, "detail", edata->detail, true);
/* Error hint */
if (edata->hint)
appendJSONLiteral(&buf, "hint", edata->hint, true);
/* Internal query */
if (edata->internalquery)
appendJSONLiteral(&buf, "internal_query",
edata->internalquery, true);
/* Error context */
if (edata->context)
appendJSONLiteral(&buf, "context", edata->context, true);
/* user query --- only reported if not disabled by the caller */
if (is_log_level_output(edata->elevel, log_min_error_statement) &&
debug_query_string != NULL &&
!edata->hide_stmt)
{
appendJSONLiteral(&buf, "statement", debug_query_string, true);
if (edata->cursorpos > 0)
appendStringInfo(&buf, "\"cursor_position\":%d,",
edata->cursorpos);
else if (edata->internalpos > 0)
appendStringInfo(&buf, "\"internal_position\":%d,",
edata->internalpos);
}
/* File error location */
if (Log_error_verbosity >= PGERROR_VERBOSE)
{
StringInfoData msgbuf;
initStringInfo(&msgbuf);
if (edata->funcname && edata->filename)
appendStringInfo(&msgbuf, "%s, %s:%d",
edata->funcname, edata->filename,
edata->lineno);
else if (edata->filename)
appendStringInfo(&msgbuf, "%s:%d",
edata->filename, edata->lineno);
appendJSONLiteral(&buf, "file_location", msgbuf.data, true);
pfree(msgbuf.data);
}
/* Application name */
if (application_name && application_name[0] != '\0')
appendJSONLiteral(&buf, "application_name",
application_name, true);
/* Error message */
appendJSONLiteral(&buf, "message", edata->message, false);
/* Finish string */
appendStringInfoChar(&buf, '}');
appendStringInfoChar(&buf, '\n');
/* Write to stderr, if enabled */
if ((Log_destination & LOG_DESTINATION_STDERR) != 0)
{
if (Logging_collector && redirection_done && !am_syslogger)
write_pipe_chunks(buf.data, buf.len);
else
write_console(buf.data, buf.len);
}
/* If in the syslogger process, try to write messages direct to file */
if (am_syslogger)
write_syslogger_file(buf.data, buf.len, LOG_DESTINATION_STDERR);
/* Cleanup */
pfree(buf.data);
/* Continue chain to previous hook */
if (prev_log_hook)
(*prev_log_hook) (edata);
}
static void
fmtLogMsg(StringInfo dst, ErrorData *edata)
{
{
char formattedLogTime[FORMATTED_TS_LEN];
/* timestamp with milliseconds */
formatNow(formattedLogTime, sizeof formattedLogTime);
/*
* Always present, non-nullable; don't need to write the N/P
* header.
*/
appendStringInfoString(dst, formattedLogTime);
appendStringInfoChar(dst, '\0');
}
/* username */
if (MyProcPort)
appendStringInfoPtr(dst, MyProcPort->user_name);
else
appendStringInfoPtr(dst, NULL);
/* database name */
if (MyProcPort)
appendStringInfoPtr(dst, MyProcPort->database_name);
else
appendStringInfoPtr(dst, NULL);
/* Process id */
{
uint32_t nPid = htobe32(savedPid);
appendBinaryStringInfo(dst, (void *) &nPid, sizeof nPid);
}
/* Remote host and port */
if (MyProcPort && MyProcPort->remote_host)
{
/* 'present' string header, since this string is nullable */
appendStringInfoChar(dst, 'P');
appendStringInfoString(dst, MyProcPort->remote_host);
if (MyProcPort->remote_port && MyProcPort->remote_port[0] != '\0')
{
appendStringInfoChar(dst, ':');
appendStringInfoString(dst, MyProcPort->remote_port);
}
appendStringInfoChar(dst, '\0');
}
else
appendStringInfoPtr(dst, NULL);
/* session id; non-nullable */
appendStringInfo(dst, "%lx.%x", (long) MyStartTime, MyProcPid);
appendStringInfoChar(dst, '\0');
/* Line number */
{
uint64_t nSeqNum = htobe64(seqNum);
appendBinaryStringInfo(dst, (void *) &nSeqNum, sizeof nSeqNum);
}
/* PS display */
if (MyProcPort)
{
StringInfoData msgbuf;
const char *psdisp;
int displen;
initStringInfo(&msgbuf);
psdisp = get_ps_display(&displen);
appendBinaryStringInfo(&msgbuf, psdisp, displen);
appendStringInfoChar(dst, 'P');
appendStringInfoString(dst, msgbuf.data);
appendStringInfoChar(dst, '\0');
pfree(msgbuf.data);
}
else
appendStringInfoPtr(dst, NULL);
/* session start timestamp */
if (cachedBackendStartTime[0] == '\0')
{
/* Rebuild the cache if it was blown */
reCacheBackendStartTime();
}
/* backend start time; non-nullable string */
appendStringInfoString(dst, cachedBackendStartTime);
appendStringInfoChar(dst, '\0');
/*
* Virtual transaction id
*
* keep VXID format in sync with lockfuncs.c
*/
if (MyProc != NULL && MyProc->backendId != InvalidBackendId)
{
appendStringInfoChar(dst, 'P');
appendStringInfo(dst, "%d/%u", MyProc->backendId, MyProc->lxid);
appendStringInfoChar(dst, '\0');
}
else
appendStringInfoPtr(dst, NULL);
/*
* Transaction id
*
* This seems to be a mistake both here and in elog.c; in particular, it's
* not clear how the epoch would get added here. However, leave room in
* the protocol to fix this later by upcasting.
*/
{
uint64_t nTxid = htobe64((uint64) GetTopTransactionIdIfAny());
appendBinaryStringInfo(dst, (void *) &nTxid, sizeof nTxid);
}
/* Error severity */
{
uint32_t nelevel = htobe32(edata->elevel);
appendBinaryStringInfo(dst, (void *) &nelevel, sizeof nelevel);
}
/* SQL state code */
appendStringInfoPtr(dst, unpack_sql_state(edata->sqlerrcode));
/* errmessage */
appendStringInfoPtr(dst, edata->message);
/* errdetail or errdetail_log */
if (edata->detail_log)
appendStringInfoPtr(dst, edata->detail_log);
else
appendStringInfoPtr(dst, edata->detail);
/* errhint */
appendStringInfoPtr(dst, edata->hint);
/* internal query */
appendStringInfoPtr(dst, edata->internalquery);
/* if printed internal query, print internal pos too */
if (edata->internalpos > 0 && edata->internalquery != NULL)
{
uint32_t ninternalpos = htobe32(edata->internalpos);
appendBinaryStringInfo(dst, (void *) &ninternalpos,
sizeof ninternalpos);
}
else
{
uint32_t ninternalpos = htobe32(-1);
appendBinaryStringInfo(dst, (void *) &ninternalpos,
sizeof ninternalpos);
}
/* errcontext */
appendStringInfoPtr(dst, edata->context);
/*
* user query --- only reported if not disabled by the caller.
*
* Also include query position.
*/
if (isLogLevelOutput(edata->elevel, log_min_error_statement) &&
debug_query_string != NULL && !edata->hide_stmt)
{
uint32_t nCursorPos = htobe32(edata->cursorpos);
appendStringInfoPtr(dst, debug_query_string);
appendBinaryStringInfo(dst, (void *) &nCursorPos, sizeof nCursorPos);
}
else
{
uint32_t nCursorPos = htobe32(-1);
appendStringInfoPtr(dst, NULL);
appendBinaryStringInfo(dst, (void *) &nCursorPos, sizeof nCursorPos);
}
/* file error location */
if (Log_error_verbosity >= PGERROR_VERBOSE)
{
StringInfoData msgbuf;
initStringInfo(&msgbuf);
if (edata->funcname && edata->filename)
appendStringInfo(&msgbuf, "%s, %s:%d",
edata->funcname, edata->filename,
edata->lineno);
else if (edata->filename)
appendStringInfo(&msgbuf, "%s:%d",
edata->filename, edata->lineno);
appendStringInfoChar(dst, 'P');
appendStringInfoString(dst, msgbuf.data);
appendStringInfoChar(dst, '\0');
pfree(msgbuf.data);
}
else
appendStringInfoPtr(dst, NULL);
/* application name */
appendStringInfoPtr(dst, application_name);
}