#include "postgres.h"
#include "access/xact.h"
#include "libpq/libpq-be.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/ascii.h"
#include "utils/guc.h"
#include "utils/memutils.h"

Include dependency graph for backend_status.c:

Macros
#define	NumBackendStatSlots (MaxBackends + NUM_AUXILIARY_PROCS)

Functions
static void	pgstat_beshutdown_hook (int code, Datum arg)

static void	pgstat_read_current_status (void)

static void	pgstat_setup_backend_status_context (void)

Size	BackendStatusShmemSize (void)

void	BackendStatusShmemInit (void)

void	pgstat_beinit (void)

void	pgstat_bestart_initial (void)

void	pgstat_bestart_security (void)

void	pgstat_bestart_final (void)

void	pgstat_clear_backend_activity_snapshot (void)

void	pgstat_report_activity (BackendState state, const char *cmd_str)

void	pgstat_report_query_id (uint64 query_id, bool force)

void	pgstat_report_plan_id (uint64 plan_id, bool force)

void	pgstat_report_appname (const char *appname)

void	pgstat_report_xact_timestamp (TimestampTz tstamp)

const char *	pgstat_get_backend_current_activity (int pid, bool checkUser)

const char *	pgstat_get_crashed_backend_activity (int pid, char *buffer, int buflen)

uint64	pgstat_get_my_query_id (void)

uint64	pgstat_get_my_plan_id (void)

BackendType	pgstat_get_backend_type_by_proc_number (ProcNumber procNumber)

static int	cmp_lbestatus (const void a, const void b)

PgBackendStatus *	pgstat_get_beentry_by_proc_number (ProcNumber procNumber)

LocalPgBackendStatus *	pgstat_get_local_beentry_by_proc_number (ProcNumber procNumber)

LocalPgBackendStatus *	pgstat_get_local_beentry_by_index (int idx)

int	pgstat_fetch_stat_numbackends (void)

char *	pgstat_clip_activity (const char *raw_activity)

Variables
bool	pgstat_track_activities = false

int	pgstat_track_activity_query_size = 1024

PgBackendStatus *	MyBEEntry = NULL

static PgBackendStatus *	BackendStatusArray = NULL

static char *	BackendAppnameBuffer = NULL

static char *	BackendClientHostnameBuffer = NULL

static char *	BackendActivityBuffer = NULL

static Size	BackendActivityBufferSize = 0

static LocalPgBackendStatus *	localBackendStatusTable = NULL

static int	localNumBackends = 0

static MemoryContext	backendStatusSnapContext

Macro Definition Documentation

◆ NumBackendStatSlots

#define NumBackendStatSlots (MaxBackends + NUM_AUXILIARY_PROCS)

Definition at line 35 of file backend_status.c.

Function Documentation

◆ BackendStatusShmemInit()

void BackendStatusShmemInit ( void )

Definition at line 114 of file backend_status.c.

{
    Size        size;
    bool        found;
    int         i;
    char       *buffer;
 
    /* Create or attach to the shared array */
    size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
    BackendStatusArray = (PgBackendStatus *)
        ShmemInitStruct("Backend Status Array", size, &found);
 
    if (!found)
    {
        /*
         * We're the first - initialize.
         */
        MemSet(BackendStatusArray, 0, size);
    }
 
    /* Create or attach to the shared appname buffer */
    size = mul_size(NAMEDATALEN, NumBackendStatSlots);
    BackendAppnameBuffer = (char *)
        ShmemInitStruct("Backend Application Name Buffer", size, &found);
 
    if (!found)
    {
        MemSet(BackendAppnameBuffer, 0, size);
 
        /* Initialize st_appname pointers. */
        buffer = BackendAppnameBuffer;
        for (i = 0; i < NumBackendStatSlots; i++)
        {
            BackendStatusArray[i].st_appname = buffer;
            buffer += NAMEDATALEN;
        }
    }
 
    /* Create or attach to the shared client hostname buffer */
    size = mul_size(NAMEDATALEN, NumBackendStatSlots);
    BackendClientHostnameBuffer = (char *)
        ShmemInitStruct("Backend Client Host Name Buffer", size, &found);
 
    if (!found)
    {
        MemSet(BackendClientHostnameBuffer, 0, size);
 
        /* Initialize st_clienthostname pointers. */
        buffer = BackendClientHostnameBuffer;
        for (i = 0; i < NumBackendStatSlots; i++)
        {
            BackendStatusArray[i].st_clienthostname = buffer;
            buffer += NAMEDATALEN;
        }
    }
 
    /* Create or attach to the shared activity buffer */
    BackendActivityBufferSize = mul_size(pgstat_track_activity_query_size,
                                         NumBackendStatSlots);
    BackendActivityBuffer = (char *)
        ShmemInitStruct("Backend Activity Buffer",
                        BackendActivityBufferSize,
                        &found);
 
    if (!found)
    {
        MemSet(BackendActivityBuffer, 0, BackendActivityBufferSize);
 
        /* Initialize st_activity pointers. */
        buffer = BackendActivityBuffer;
        for (i = 0; i < NumBackendStatSlots; i++)
        {
            BackendStatusArray[i].st_activity_raw = buffer;
            buffer += pgstat_track_activity_query_size;
        }
    }
 
#ifdef USE_SSL
    /* Create or attach to the shared SSL status buffer */
    size = mul_size(sizeof(PgBackendSSLStatus), NumBackendStatSlots);
    BackendSslStatusBuffer = (PgBackendSSLStatus *)
        ShmemInitStruct("Backend SSL Status Buffer", size, &found);
 
    if (!found)
    {
        PgBackendSSLStatus *ptr;
 
        MemSet(BackendSslStatusBuffer, 0, size);
 
        /* Initialize st_sslstatus pointers. */
        ptr = BackendSslStatusBuffer;
        for (i = 0; i < NumBackendStatSlots; i++)
        {
            BackendStatusArray[i].st_sslstatus = ptr;
            ptr++;
        }
    }
#endif
 
#ifdef ENABLE_GSS
    /* Create or attach to the shared GSSAPI status buffer */
    size = mul_size(sizeof(PgBackendGSSStatus), NumBackendStatSlots);
    BackendGssStatusBuffer = (PgBackendGSSStatus *)
        ShmemInitStruct("Backend GSS Status Buffer", size, &found);
 
    if (!found)
    {
        PgBackendGSSStatus *ptr;
 
        MemSet(BackendGssStatusBuffer, 0, size);
 
        /* Initialize st_gssstatus pointers. */
        ptr = BackendGssStatusBuffer;
        for (i = 0; i < NumBackendStatSlots; i++)
        {
            BackendStatusArray[i].st_gssstatus = ptr;
            ptr++;
        }
    }
#endif
}

References BackendActivityBuffer, BackendActivityBufferSize, BackendAppnameBuffer, BackendClientHostnameBuffer, BackendStatusArray, i, MemSet, mul_size(), NAMEDATALEN, NumBackendStatSlots, pgstat_track_activity_query_size, ShmemInitStruct(), PgBackendStatus::st_activity_raw, PgBackendStatus::st_appname, PgBackendStatus::st_clienthostname, PgBackendStatus::st_gssstatus, and PgBackendStatus::st_sslstatus.

Referenced by CreateOrAttachShmemStructs().

◆ BackendStatusShmemSize()

Size BackendStatusShmemSize ( void )

Definition at line 81 of file backend_status.c.

{
    Size        size;
 
    /* BackendStatusArray: */
    size = mul_size(sizeof(PgBackendStatus), NumBackendStatSlots);
    /* BackendAppnameBuffer: */
    size = add_size(size,
                    mul_size(NAMEDATALEN, NumBackendStatSlots));
    /* BackendClientHostnameBuffer: */
    size = add_size(size,
                    mul_size(NAMEDATALEN, NumBackendStatSlots));
    /* BackendActivityBuffer: */
    size = add_size(size,
                    mul_size(pgstat_track_activity_query_size, NumBackendStatSlots));
#ifdef USE_SSL
    /* BackendSslStatusBuffer: */
    size = add_size(size,
                    mul_size(sizeof(PgBackendSSLStatus), NumBackendStatSlots));
#endif
#ifdef ENABLE_GSS
    /* BackendGssStatusBuffer: */
    size = add_size(size,
                    mul_size(sizeof(PgBackendGSSStatus), NumBackendStatSlots));
#endif
    return size;
}

References add_size(), mul_size(), NAMEDATALEN, NumBackendStatSlots, and pgstat_track_activity_query_size.

Referenced by CalculateShmemSize().

◆ cmp_lbestatus()

static int cmp_lbestatus	(	const void *	a,
		const void *	b
	)

static

Definition at line 1200 of file backend_status.c.

{
    const LocalPgBackendStatus *lbestatus1 = (const LocalPgBackendStatus *) a;
    const LocalPgBackendStatus *lbestatus2 = (const LocalPgBackendStatus *) b;
 
    return lbestatus1->proc_number - lbestatus2->proc_number;
}

References a, b, and LocalPgBackendStatus::proc_number.

Referenced by pgstat_get_local_beentry_by_proc_number().

◆ pgstat_beinit()

void pgstat_beinit ( void )

Definition at line 245 of file backend_status.c.

{
    /* Initialize MyBEEntry */
    Assert(MyProcNumber != INVALID_PROC_NUMBER);
    Assert(MyProcNumber >= 0 && MyProcNumber < NumBackendStatSlots);
    MyBEEntry = &BackendStatusArray[MyProcNumber];
 
    /* Set up a process-exit hook to clean up */
    on_shmem_exit(pgstat_beshutdown_hook, 0);
}

References Assert(), BackendStatusArray, INVALID_PROC_NUMBER, MyBEEntry, MyProcNumber, NumBackendStatSlots, on_shmem_exit(), and pgstat_beshutdown_hook().

Referenced by AuxiliaryProcessMainCommon(), and InitPostgres().

◆ pgstat_beshutdown_hook()

static void pgstat_beshutdown_hook	(	int	code,
		Datum	arg
	)

static

Definition at line 509 of file backend_status.c.

{
    volatile PgBackendStatus *beentry = MyBEEntry;
 
    /*
     * Clear my status entry, following the protocol of bumping st_changecount
     * before and after.  We use a volatile pointer here to ensure the
     * compiler doesn't try to get cute.
     */
    PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
 
    beentry->st_procpid = 0;    /* mark invalid */
 
    PGSTAT_END_WRITE_ACTIVITY(beentry);
 
    /* so that functions can check if backend_status.c is up via MyBEEntry */
    MyBEEntry = NULL;
}

References MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, and PgBackendStatus::st_procpid.

Referenced by pgstat_beinit().

◆ pgstat_bestart_final()

void pgstat_bestart_final ( void )

Definition at line 467 of file backend_status.c.

{
    volatile PgBackendStatus *beentry = MyBEEntry;
    Oid         userid;
 
    /* pgstats state must be initialized from pgstat_beinit() */
    Assert(beentry != NULL);
 
    /* We have userid for client-backends, wal-sender and bgworker processes */
    if (MyBackendType == B_BACKEND
        || MyBackendType == B_WAL_SENDER
        || MyBackendType == B_BG_WORKER)
        userid = GetSessionUserId();
    else
        userid = InvalidOid;
 
    /*
     * Update my status entry, following the protocol of bumping
     * st_changecount before and after.  We use a volatile pointer here to
     * ensure the compiler doesn't try to get cute.
     */
    PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
 
    beentry->st_databaseid = MyDatabaseId;
    beentry->st_userid = userid;
    beentry->st_state = STATE_UNDEFINED;
 
    PGSTAT_END_WRITE_ACTIVITY(beentry);
 
    /* Create the backend statistics entry */
    if (pgstat_tracks_backend_bktype(MyBackendType))
        pgstat_create_backend(MyProcNumber);
 
    /* Update app name to current GUC setting */
    if (application_name)
        pgstat_report_appname(application_name);
}

References application_name, Assert(), B_BACKEND, B_BG_WORKER, B_WAL_SENDER, GetSessionUserId(), InvalidOid, MyBackendType, MyBEEntry, MyDatabaseId, MyProcNumber, PGSTAT_BEGIN_WRITE_ACTIVITY, pgstat_create_backend(), PGSTAT_END_WRITE_ACTIVITY, pgstat_report_appname(), pgstat_tracks_backend_bktype(), PgBackendStatus::st_databaseid, PgBackendStatus::st_state, PgBackendStatus::st_userid, and STATE_UNDEFINED.

Referenced by AuxiliaryProcessMainCommon(), and InitPostgres().

◆ pgstat_bestart_initial()

void pgstat_bestart_initial ( void )

Definition at line 270 of file backend_status.c.

{
    volatile PgBackendStatus *vbeentry = MyBEEntry;
    PgBackendStatus lbeentry;
 
    /* pgstats state must be initialized from pgstat_beinit() */
    Assert(vbeentry != NULL);
 
    /*
     * To minimize the time spent modifying the PgBackendStatus entry, and
     * avoid risk of errors inside the critical section, we first copy the
     * shared-memory struct to a local variable, then modify the data in the
     * local variable, then copy the local variable back to shared memory.
     * Only the last step has to be inside the critical section.
     *
     * Most of the data we copy from shared memory is just going to be
     * overwritten, but the struct's not so large that it's worth the
     * maintenance hassle to copy only the needful fields.
     */
    memcpy(&lbeentry,
           unvolatize(PgBackendStatus *, vbeentry),
           sizeof(PgBackendStatus));
 
    /*
     * Now fill in all the fields of lbeentry, except for strings that are
     * out-of-line data.  Those have to be handled separately, below.
     */
    lbeentry.st_procpid = MyProcPid;
    lbeentry.st_backendType = MyBackendType;
    lbeentry.st_proc_start_timestamp = MyStartTimestamp;
    lbeentry.st_activity_start_timestamp = 0;
    lbeentry.st_state_start_timestamp = 0;
    lbeentry.st_xact_start_timestamp = 0;
    lbeentry.st_databaseid = InvalidOid;
    lbeentry.st_userid = InvalidOid;
 
    /*
     * We may not have a MyProcPort (eg, if this is the autovacuum process).
     * If so, use all-zeroes client address, which is dealt with specially in
     * pg_stat_get_backend_client_addr and pg_stat_get_backend_client_port.
     */
    if (MyProcPort)
        memcpy(&lbeentry.st_clientaddr, &MyProcPort->raddr,
               sizeof(lbeentry.st_clientaddr));
    else
        MemSet(&lbeentry.st_clientaddr, 0, sizeof(lbeentry.st_clientaddr));
 
    lbeentry.st_ssl = false;
    lbeentry.st_gss = false;
 
    lbeentry.st_state = STATE_STARTING;
    lbeentry.st_progress_command = PROGRESS_COMMAND_INVALID;
    lbeentry.st_progress_command_target = InvalidOid;
    lbeentry.st_query_id = UINT64CONST(0);
    lbeentry.st_plan_id = UINT64CONST(0);
 
    /*
     * we don't zero st_progress_param here to save cycles; nobody should
     * examine it until st_progress_command has been set to something other
     * than PROGRESS_COMMAND_INVALID
     */
 
    /*
     * We're ready to enter the critical section that fills the shared-memory
     * status entry.  We follow the protocol of bumping st_changecount before
     * and after; and make sure it's even afterwards.  We use a volatile
     * pointer here to ensure the compiler doesn't try to get cute.
     */
    PGSTAT_BEGIN_WRITE_ACTIVITY(vbeentry);
 
    /* make sure we'll memcpy the same st_changecount back */
    lbeentry.st_changecount = vbeentry->st_changecount;
 
    memcpy(unvolatize(PgBackendStatus *, vbeentry),
           &lbeentry,
           sizeof(PgBackendStatus));
 
    /*
     * We can write the out-of-line strings and structs using the pointers
     * that are in lbeentry; this saves some de-volatilizing messiness.
     */
    lbeentry.st_appname[0] = '\0';
    if (MyProcPort && MyProcPort->remote_hostname)
        strlcpy(lbeentry.st_clienthostname, MyProcPort->remote_hostname,
                NAMEDATALEN);
    else
        lbeentry.st_clienthostname[0] = '\0';
    lbeentry.st_activity_raw[0] = '\0';
    /* Also make sure the last byte in each string area is always 0 */
    lbeentry.st_appname[NAMEDATALEN - 1] = '\0';
    lbeentry.st_clienthostname[NAMEDATALEN - 1] = '\0';
    lbeentry.st_activity_raw[pgstat_track_activity_query_size - 1] = '\0';
 
    /* These structs can just start from zeroes each time */
#ifdef USE_SSL
    memset(lbeentry.st_sslstatus, 0, sizeof(PgBackendSSLStatus));
#endif
#ifdef ENABLE_GSS
    memset(lbeentry.st_gssstatus, 0, sizeof(PgBackendGSSStatus));
#endif
 
    PGSTAT_END_WRITE_ACTIVITY(vbeentry);
}

Referenced by AuxiliaryProcessMainCommon(), and InitPostgres().

◆ pgstat_bestart_security()

void pgstat_bestart_security ( void )

Definition at line 385 of file backend_status.c.

{
    volatile PgBackendStatus *beentry = MyBEEntry;
    bool        ssl = false;
    bool        gss = false;
#ifdef USE_SSL
    PgBackendSSLStatus lsslstatus;
    PgBackendSSLStatus *st_sslstatus;
#endif
#ifdef ENABLE_GSS
    PgBackendGSSStatus lgssstatus;
    PgBackendGSSStatus *st_gssstatus;
#endif
 
    /* pgstats state must be initialized from pgstat_beinit() */
    Assert(beentry != NULL);
    Assert(MyProcPort);         /* otherwise there's no point */
 
#ifdef USE_SSL
    st_sslstatus = beentry->st_sslstatus;
    memset(&lsslstatus, 0, sizeof(lsslstatus));
 
    if (MyProcPort->ssl_in_use)
    {
        ssl = true;
        lsslstatus.ssl_bits = be_tls_get_cipher_bits(MyProcPort);
        strlcpy(lsslstatus.ssl_version, be_tls_get_version(MyProcPort), NAMEDATALEN);
        strlcpy(lsslstatus.ssl_cipher, be_tls_get_cipher(MyProcPort), NAMEDATALEN);
        be_tls_get_peer_subject_name(MyProcPort, lsslstatus.ssl_client_dn, NAMEDATALEN);
        be_tls_get_peer_serial(MyProcPort, lsslstatus.ssl_client_serial, NAMEDATALEN);
        be_tls_get_peer_issuer_name(MyProcPort, lsslstatus.ssl_issuer_dn, NAMEDATALEN);
    }
#endif
 
#ifdef ENABLE_GSS
    st_gssstatus = beentry->st_gssstatus;
    memset(&lgssstatus, 0, sizeof(lgssstatus));
 
    if (MyProcPort->gss != NULL)
    {
        const char *princ = be_gssapi_get_princ(MyProcPort);
 
        gss = true;
        lgssstatus.gss_auth = be_gssapi_get_auth(MyProcPort);
        lgssstatus.gss_enc = be_gssapi_get_enc(MyProcPort);
        lgssstatus.gss_delegation = be_gssapi_get_delegation(MyProcPort);
        if (princ)
            strlcpy(lgssstatus.gss_princ, princ, NAMEDATALEN);
    }
#endif
 
    /*
     * Update my status entry, following the protocol of bumping
     * st_changecount before and after.  We use a volatile pointer here to
     * ensure the compiler doesn't try to get cute.
     */
    PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
 
    beentry->st_ssl = ssl;
    beentry->st_gss = gss;
 
#ifdef USE_SSL
    memcpy(st_sslstatus, &lsslstatus, sizeof(PgBackendSSLStatus));
#endif
#ifdef ENABLE_GSS
    memcpy(st_gssstatus, &lgssstatus, sizeof(PgBackendGSSStatus));
#endif
 
    PGSTAT_END_WRITE_ACTIVITY(beentry);
}

References Assert(), be_gssapi_get_auth(), be_gssapi_get_delegation(), be_gssapi_get_enc(), be_gssapi_get_princ(), be_tls_get_cipher(), be_tls_get_cipher_bits(), be_tls_get_peer_issuer_name(), be_tls_get_peer_serial(), be_tls_get_peer_subject_name(), be_tls_get_version(), Port::gss, PgBackendGSSStatus::gss_auth, PgBackendGSSStatus::gss_delegation, PgBackendGSSStatus::gss_enc, PgBackendGSSStatus::gss_princ, MyBEEntry, MyProcPort, NAMEDATALEN, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, PgBackendSSLStatus::ssl_bits, PgBackendSSLStatus::ssl_cipher, PgBackendSSLStatus::ssl_client_dn, PgBackendSSLStatus::ssl_client_serial, Port::ssl_in_use, PgBackendSSLStatus::ssl_issuer_dn, PgBackendSSLStatus::ssl_version, PgBackendStatus::st_gss, PgBackendStatus::st_gssstatus, PgBackendStatus::st_ssl, PgBackendStatus::st_sslstatus, and strlcpy().

Referenced by InitPostgres().

◆ pgstat_clear_backend_activity_snapshot()

void pgstat_clear_backend_activity_snapshot ( void )

Definition at line 536 of file backend_status.c.

{
    /* Release memory, if any was allocated */
    if (backendStatusSnapContext)
    {
        MemoryContextDelete(backendStatusSnapContext);
        backendStatusSnapContext = NULL;
    }
 
    /* Reset variables */
    localBackendStatusTable = NULL;
    localNumBackends = 0;
}

References backendStatusSnapContext, localBackendStatusTable, localNumBackends, and MemoryContextDelete().

Referenced by pgstat_clear_snapshot().

◆ pgstat_clip_activity()

char * pgstat_clip_activity ( const char * raw_activity )

Definition at line 1315 of file backend_status.c.

{
    char       *activity;
    int         rawlen;
    int         cliplen;
 
    /*
     * Some callers, like pgstat_get_backend_current_activity(), do not
     * guarantee that the buffer isn't concurrently modified. We try to take
     * care that the buffer is always terminated by a NUL byte regardless, but
     * let's still be paranoid about the string's length. In those cases the
     * underlying buffer is guaranteed to be pgstat_track_activity_query_size
     * large.
     */
    activity = pnstrdup(raw_activity, pgstat_track_activity_query_size - 1);
 
    /* now double-guaranteed to be NUL terminated */
    rawlen = strlen(activity);
 
    /*
     * All supported server-encodings make it possible to determine the length
     * of a multi-byte character from its first byte (this is not the case for
     * client encodings, see GB18030). As st_activity is always stored using
     * server encoding, this allows us to perform multi-byte aware truncation,
     * even if the string earlier was truncated in the middle of a multi-byte
     * character.
     */
    cliplen = pg_mbcliplen(activity, rawlen,
                           pgstat_track_activity_query_size - 1);
 
    activity[cliplen] = '\0';
 
    return activity;
}

References cliplen(), pg_mbcliplen(), pgstat_track_activity_query_size, and pnstrdup().

Referenced by pg_stat_get_activity(), pg_stat_get_backend_activity(), and pgstat_get_backend_current_activity().

◆ pgstat_fetch_stat_numbackends()

int pgstat_fetch_stat_numbackends ( void )

Definition at line 1299 of file backend_status.c.

{
    pgstat_read_current_status();
 
    return localNumBackends;
}

References localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_activity(), pg_stat_get_backend_idset(), pg_stat_get_db_numbackends(), and pg_stat_get_progress_info().

◆ pgstat_get_backend_current_activity()

const char * pgstat_get_backend_current_activity	(	int	pid,
		bool	checkUser
	)

Definition at line 996 of file backend_status.c.

{
    PgBackendStatus *beentry;
    int         i;
 
    beentry = BackendStatusArray;
    for (i = 1; i <= MaxBackends; i++)
    {
        /*
         * Although we expect the target backend's entry to be stable, that
         * doesn't imply that anyone else's is.  To avoid identifying the
         * wrong backend, while we check for a match to the desired PID we
         * must follow the protocol of retrying if st_changecount changes
         * while we examine the entry, or if it's odd.  (This might be
         * unnecessary, since fetching or storing an int is almost certainly
         * atomic, but let's play it safe.)  We use a volatile pointer here to
         * ensure the compiler doesn't try to get cute.
         */
        volatile PgBackendStatus *vbeentry = beentry;
        bool        found;
 
        for (;;)
        {
            int         before_changecount;
            int         after_changecount;
 
            pgstat_begin_read_activity(vbeentry, before_changecount);
 
            found = (vbeentry->st_procpid == pid);
 
            pgstat_end_read_activity(vbeentry, after_changecount);
 
            if (pgstat_read_activity_complete(before_changecount,
                                              after_changecount))
                break;
 
            /* Make sure we can break out of loop if stuck... */
            CHECK_FOR_INTERRUPTS();
        }
 
        if (found)
        {
            /* Now it is safe to use the non-volatile pointer */
            if (checkUser && !superuser() && beentry->st_userid != GetUserId())
                return "<insufficient privilege>";
            else if (*(beentry->st_activity_raw) == '\0')
                return "<command string not enabled>";
            else
            {
                /* this'll leak a bit of memory, but that seems acceptable */
                return pgstat_clip_activity(beentry->st_activity_raw);
            }
        }
 
        beentry++;
    }
 
    /* If we get here, caller is in error ... */
    return "<backend information not available>";
}

References BackendStatusArray, CHECK_FOR_INTERRUPTS, GetUserId(), i, MaxBackends, pgstat_begin_read_activity, pgstat_clip_activity(), pgstat_end_read_activity, pgstat_read_activity_complete, PgBackendStatus::st_activity_raw, PgBackendStatus::st_procpid, PgBackendStatus::st_userid, and superuser().

Referenced by DeadLockReport().

◆ pgstat_get_backend_type_by_proc_number()

BackendType pgstat_get_backend_type_by_proc_number ( ProcNumber procNumber )

Definition at line 1181 of file backend_status.c.

{
    volatile PgBackendStatus *status = &BackendStatusArray[procNumber];
 
    /*
     * We bypass the changecount mechanism since fetching and storing an int
     * is almost certainly atomic.
     */
    return status->st_backendType;
}

References BackendStatusArray, and PgBackendStatus::st_backendType.

Referenced by pg_signal_backend().

◆ pgstat_get_beentry_by_proc_number()

PgBackendStatus * pgstat_get_beentry_by_proc_number ( ProcNumber procNumber )

Definition at line 1223 of file backend_status.c.

{
    LocalPgBackendStatus *ret = pgstat_get_local_beentry_by_proc_number(procNumber);
 
    if (ret)
        return &ret->backendStatus;
 
    return NULL;
}

References LocalPgBackendStatus::backendStatus, and pgstat_get_local_beentry_by_proc_number().

Referenced by pg_stat_get_backend_activity(), pg_stat_get_backend_activity_start(), pg_stat_get_backend_client_addr(), pg_stat_get_backend_client_port(), pg_stat_get_backend_dbid(), pg_stat_get_backend_pid(), pg_stat_get_backend_start(), pg_stat_get_backend_userid(), pg_stat_get_backend_wait_event(), pg_stat_get_backend_wait_event_type(), pg_stat_get_backend_xact_start(), pg_stat_reset_backend_stats(), and pgstat_fetch_stat_backend_by_pid().

◆ pgstat_get_crashed_backend_activity()

const char * pgstat_get_crashed_backend_activity	(	int	pid,
		char *	buffer,
		int	buflen
	)

Definition at line 1074 of file backend_status.c.

{
    volatile PgBackendStatus *beentry;
    int         i;
 
    beentry = BackendStatusArray;
 
    /*
     * We probably shouldn't get here before shared memory has been set up,
     * but be safe.
     */
    if (beentry == NULL || BackendActivityBuffer == NULL)
        return NULL;
 
    for (i = 1; i <= MaxBackends; i++)
    {
        if (beentry->st_procpid == pid)
        {
            /* Read pointer just once, so it can't change after validation */
            const char *activity = beentry->st_activity_raw;
            const char *activity_last;
 
            /*
             * We mustn't access activity string before we verify that it
             * falls within the BackendActivityBuffer. To make sure that the
             * entire string including its ending is contained within the
             * buffer, subtract one activity length from the buffer size.
             */
            activity_last = BackendActivityBuffer + BackendActivityBufferSize
                - pgstat_track_activity_query_size;
 
            if (activity < BackendActivityBuffer ||
                activity > activity_last)
                return NULL;
 
            /* If no string available, no point in a report */
            if (activity[0] == '\0')
                return NULL;
 
            /*
             * Copy only ASCII-safe characters so we don't run into encoding
             * problems when reporting the message; and be sure not to run off
             * the end of memory.  As only ASCII characters are reported, it
             * doesn't seem necessary to perform multibyte aware clipping.
             */
            ascii_safe_strlcpy(buffer, activity,
                               Min(buflen, pgstat_track_activity_query_size));
 
            return buffer;
        }
 
        beentry++;
    }
 
    /* PID not found */
    return NULL;
}

References ascii_safe_strlcpy(), BackendActivityBuffer, BackendActivityBufferSize, BackendStatusArray, i, MaxBackends, Min, pgstat_track_activity_query_size, PgBackendStatus::st_activity_raw, and PgBackendStatus::st_procpid.

Referenced by LogChildExit().

◆ pgstat_get_local_beentry_by_index()

LocalPgBackendStatus * pgstat_get_local_beentry_by_index ( int idx )

Definition at line 1279 of file backend_status.c.

{
    pgstat_read_current_status();
 
    if (idx < 1 || idx > localNumBackends)
        return NULL;
 
    return &localBackendStatusTable[idx - 1];
}

References idx(), localBackendStatusTable, localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_activity(), pg_stat_get_backend_idset(), pg_stat_get_db_numbackends(), and pg_stat_get_progress_info().

◆ pgstat_get_local_beentry_by_proc_number()

LocalPgBackendStatus * pgstat_get_local_beentry_by_proc_number ( ProcNumber procNumber )

Definition at line 1248 of file backend_status.c.

{
    LocalPgBackendStatus key;
 
    pgstat_read_current_status();
 
    /*
     * Since the localBackendStatusTable is in order by proc_number, we can
     * use bsearch() to search it efficiently.
     */
    key.proc_number = procNumber;
    return bsearch(&key, localBackendStatusTable, localNumBackends,
                   sizeof(LocalPgBackendStatus), cmp_lbestatus);
}

References cmp_lbestatus(), sort-test::key, localBackendStatusTable, localNumBackends, and pgstat_read_current_status().

Referenced by pg_stat_get_backend_subxact(), and pgstat_get_beentry_by_proc_number().

◆ pgstat_get_my_plan_id()

uint64 pgstat_get_my_plan_id ( void )

Definition at line 1158 of file backend_status.c.

{
    if (!MyBEEntry)
        return 0;
 
    /* No need for a lock, for roughly the same reasons as above. */
    return MyBEEntry->st_plan_id;
}

References MyBEEntry, and PgBackendStatus::st_plan_id.

Referenced by ExecSerializePlan().

◆ pgstat_get_my_query_id()

uint64 pgstat_get_my_query_id ( void )

Definition at line 1138 of file backend_status.c.

{
    if (!MyBEEntry)
        return 0;
 
    /*
     * There's no need for a lock around pgstat_begin_read_activity /
     * pgstat_end_read_activity here as it's only called from
     * pg_stat_get_activity which is already protected, or from the same
     * backend which means that there won't be concurrent writes.
     */
    return MyBEEntry->st_query_id;
}

References MyBEEntry, and PgBackendStatus::st_query_id.

Referenced by _brin_begin_parallel(), _bt_begin_parallel(), ExecSerializePlan(), log_status_format(), parallel_vacuum_init(), write_csvlog(), and write_jsonlog().

◆ pgstat_read_current_status()

static void pgstat_read_current_status ( void )

static

Definition at line 820 of file backend_status.c.

{
    volatile PgBackendStatus *beentry;
    LocalPgBackendStatus *localtable;
    LocalPgBackendStatus *localentry;
    char       *localappname,
               *localclienthostname,
               *localactivity;
#ifdef USE_SSL
    PgBackendSSLStatus *localsslstatus;
#endif
#ifdef ENABLE_GSS
    PgBackendGSSStatus *localgssstatus;
#endif
    ProcNumber  procNumber;
 
    if (localBackendStatusTable)
        return;                 /* already done */
 
    pgstat_setup_backend_status_context();
 
    /*
     * Allocate storage for local copy of state data.  We can presume that
     * none of these requests overflow size_t, because we already calculated
     * the same values using mul_size during shmem setup.  However, with
     * probably-silly values of pgstat_track_activity_query_size and
     * max_connections, the localactivity buffer could exceed 1GB, so use
     * "huge" allocation for that one.
     */
    localtable = (LocalPgBackendStatus *)
        MemoryContextAlloc(backendStatusSnapContext,
                           sizeof(LocalPgBackendStatus) * NumBackendStatSlots);
    localappname = (char *)
        MemoryContextAlloc(backendStatusSnapContext,
                           NAMEDATALEN * NumBackendStatSlots);
    localclienthostname = (char *)
        MemoryContextAlloc(backendStatusSnapContext,
                           NAMEDATALEN * NumBackendStatSlots);
    localactivity = (char *)
        MemoryContextAllocHuge(backendStatusSnapContext,
                               (Size) pgstat_track_activity_query_size *
                               (Size) NumBackendStatSlots);
#ifdef USE_SSL
    localsslstatus = (PgBackendSSLStatus *)
        MemoryContextAlloc(backendStatusSnapContext,
                           sizeof(PgBackendSSLStatus) * NumBackendStatSlots);
#endif
#ifdef ENABLE_GSS
    localgssstatus = (PgBackendGSSStatus *)
        MemoryContextAlloc(backendStatusSnapContext,
                           sizeof(PgBackendGSSStatus) * NumBackendStatSlots);
#endif
 
    localNumBackends = 0;
 
    beentry = BackendStatusArray;
    localentry = localtable;
    for (procNumber = 0; procNumber < NumBackendStatSlots; procNumber++)
    {
        /*
         * Follow the protocol of retrying if st_changecount changes while we
         * copy the entry, or if it's odd.  (The check for odd is needed to
         * cover the case where we are able to completely copy the entry while
         * the source backend is between increment steps.)  We use a volatile
         * pointer here to ensure the compiler doesn't try to get cute.
         */
        for (;;)
        {
            int         before_changecount;
            int         after_changecount;
 
            pgstat_begin_read_activity(beentry, before_changecount);
 
            localentry->backendStatus.st_procpid = beentry->st_procpid;
            /* Skip all the data-copying work if entry is not in use */
            if (localentry->backendStatus.st_procpid > 0)
            {
                memcpy(&localentry->backendStatus, unvolatize(PgBackendStatus *, beentry), sizeof(PgBackendStatus));
 
                /*
                 * For each PgBackendStatus field that is a pointer, copy the
                 * pointed-to data, then adjust the local copy of the pointer
                 * field to point at the local copy of the data.
                 *
                 * strcpy is safe even if the string is modified concurrently,
                 * because there's always a \0 at the end of the buffer.
                 */
                strcpy(localappname, beentry->st_appname);
                localentry->backendStatus.st_appname = localappname;
                strcpy(localclienthostname, beentry->st_clienthostname);
                localentry->backendStatus.st_clienthostname = localclienthostname;
                strcpy(localactivity, beentry->st_activity_raw);
                localentry->backendStatus.st_activity_raw = localactivity;
#ifdef USE_SSL
                if (beentry->st_ssl)
                {
                    memcpy(localsslstatus, beentry->st_sslstatus, sizeof(PgBackendSSLStatus));
                    localentry->backendStatus.st_sslstatus = localsslstatus;
                }
#endif
#ifdef ENABLE_GSS
                if (beentry->st_gss)
                {
                    memcpy(localgssstatus, beentry->st_gssstatus, sizeof(PgBackendGSSStatus));
                    localentry->backendStatus.st_gssstatus = localgssstatus;
                }
#endif
            }
 
            pgstat_end_read_activity(beentry, after_changecount);
 
            if (pgstat_read_activity_complete(before_changecount,
                                              after_changecount))
                break;
 
            /* Make sure we can break out of loop if stuck... */
            CHECK_FOR_INTERRUPTS();
        }
 
        /* Only valid entries get included into the local array */
        if (localentry->backendStatus.st_procpid > 0)
        {
            /*
             * The BackendStatusArray index is exactly the ProcNumber of the
             * source backend.  Note that this means localBackendStatusTable
             * is in order by proc_number. pgstat_get_beentry_by_proc_number()
             * depends on that.
             */
            localentry->proc_number = procNumber;
            ProcNumberGetTransactionIds(procNumber,
                                        &localentry->backend_xid,
                                        &localentry->backend_xmin,
                                        &localentry->backend_subxact_count,
                                        &localentry->backend_subxact_overflowed);
 
            localentry++;
            localappname += NAMEDATALEN;
            localclienthostname += NAMEDATALEN;
            localactivity += pgstat_track_activity_query_size;
#ifdef USE_SSL
            localsslstatus++;
#endif
#ifdef ENABLE_GSS
            localgssstatus++;
#endif
            localNumBackends++;
        }
 
        beentry++;
    }
 
    /* Set the pointer only after completion of a valid table */
    localBackendStatusTable = localtable;
}

Referenced by pgstat_fetch_stat_numbackends(), pgstat_get_local_beentry_by_index(), and pgstat_get_local_beentry_by_proc_number().

◆ pgstat_report_activity()

void pgstat_report_activity	(	BackendState	state,
		const char *	cmd_str
	)

Definition at line 572 of file backend_status.c.

{
    volatile PgBackendStatus *beentry = MyBEEntry;
    TimestampTz start_timestamp;
    TimestampTz current_timestamp;
    int         len = 0;
 
    TRACE_POSTGRESQL_STATEMENT_STATUS(cmd_str);
 
    if (!beentry)
        return;
 
    if (!pgstat_track_activities)
    {
        if (beentry->st_state != STATE_DISABLED)
        {
            volatile PGPROC *proc = MyProc;
 
            /*
             * track_activities is disabled, but we last reported a
             * non-disabled state.  As our final update, change the state and
             * clear fields we will not be updating anymore.
             */
            PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
            beentry->st_state = STATE_DISABLED;
            beentry->st_state_start_timestamp = 0;
            beentry->st_activity_raw[0] = '\0';
            beentry->st_activity_start_timestamp = 0;
            /* st_xact_start_timestamp and wait_event_info are also disabled */
            beentry->st_xact_start_timestamp = 0;
            beentry->st_query_id = UINT64CONST(0);
            beentry->st_plan_id = UINT64CONST(0);
            proc->wait_event_info = 0;
            PGSTAT_END_WRITE_ACTIVITY(beentry);
        }
        return;
    }
 
    /*
     * To minimize the time spent modifying the entry, and avoid risk of
     * errors inside the critical section, fetch all the needed data first.
     */
    start_timestamp = GetCurrentStatementStartTimestamp();
    if (cmd_str != NULL)
    {
        /*
         * Compute length of to-be-stored string unaware of multi-byte
         * characters. For speed reasons that'll get corrected on read, rather
         * than computed every write.
         */
        len = Min(strlen(cmd_str), pgstat_track_activity_query_size - 1);
    }
    current_timestamp = GetCurrentTimestamp();
 
    /*
     * If the state has changed from "active" or "idle in transaction",
     * calculate the duration.
     */
    if ((beentry->st_state == STATE_RUNNING ||
         beentry->st_state == STATE_FASTPATH ||
         beentry->st_state == STATE_IDLEINTRANSACTION ||
         beentry->st_state == STATE_IDLEINTRANSACTION_ABORTED) &&
        state != beentry->st_state)
    {
        long        secs;
        int         usecs;
 
        TimestampDifference(beentry->st_state_start_timestamp,
                            current_timestamp,
                            &secs, &usecs);
 
        if (beentry->st_state == STATE_RUNNING ||
            beentry->st_state == STATE_FASTPATH)
            pgstat_count_conn_active_time((PgStat_Counter) secs * 1000000 + usecs);
        else
            pgstat_count_conn_txn_idle_time((PgStat_Counter) secs * 1000000 + usecs);
    }
 
    /*
     * Now update the status entry
     */
    PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
 
    beentry->st_state = state;
    beentry->st_state_start_timestamp = current_timestamp;
 
    /*
     * If a new query is started, we reset the query identifier as it'll only
     * be known after parse analysis, to avoid reporting last query's
     * identifier.
     */
    if (state == STATE_RUNNING)
    {
        beentry->st_query_id = UINT64CONST(0);
        beentry->st_plan_id = UINT64CONST(0);
    }
 
    if (cmd_str != NULL)
    {
        memcpy(beentry->st_activity_raw, cmd_str, len);
        beentry->st_activity_raw[len] = '\0';
        beentry->st_activity_start_timestamp = start_timestamp;
    }
 
    PGSTAT_END_WRITE_ACTIVITY(beentry);
}

References GetCurrentStatementStartTimestamp(), GetCurrentTimestamp(), len, Min, MyBEEntry, MyProc, PGSTAT_BEGIN_WRITE_ACTIVITY, pgstat_count_conn_active_time, pgstat_count_conn_txn_idle_time, PGSTAT_END_WRITE_ACTIVITY, pgstat_track_activities, pgstat_track_activity_query_size, PgBackendStatus::st_activity_raw, PgBackendStatus::st_activity_start_timestamp, PgBackendStatus::st_plan_id, PgBackendStatus::st_query_id, PgBackendStatus::st_state, PgBackendStatus::st_state_start_timestamp, PgBackendStatus::st_xact_start_timestamp, STATE_DISABLED, STATE_FASTPATH, STATE_IDLEINTRANSACTION, STATE_IDLEINTRANSACTION_ABORTED, STATE_RUNNING, TimestampDifference(), UINT64CONST, and PGPROC::wait_event_info.

Referenced by _brin_parallel_build_main(), _bt_parallel_build_main(), _gin_parallel_build_main(), apply_handle_begin(), apply_handle_begin_prepare(), apply_handle_commit(), apply_handle_commit_prepared(), apply_handle_prepare(), apply_handle_rollback_prepared(), apply_handle_stream_commit(), apply_handle_stream_prepare(), apply_handle_stream_start(), apply_handle_stream_stop(), apply_spooled_messages(), autovac_report_activity(), autovac_report_workitem(), exec_bind_message(), exec_execute_message(), exec_parse_message(), exec_replication_command(), exec_simple_query(), initialize_worker_spi(), LogicalRepApplyLoop(), pa_stream_abort(), parallel_vacuum_main(), ParallelQueryMain(), PostgresMain(), and worker_spi_main().

◆ pgstat_report_appname()

void pgstat_report_appname ( const char * appname )

Definition at line 764 of file backend_status.c.

{
    volatile PgBackendStatus *beentry = MyBEEntry;
    int         len;
 
    if (!beentry)
        return;
 
    /* This should be unnecessary if GUC did its job, but be safe */
    len = pg_mbcliplen(appname, strlen(appname), NAMEDATALEN - 1);
 
    /*
     * Update my status entry, following the protocol of bumping
     * st_changecount before and after.  We use a volatile pointer here to
     * ensure the compiler doesn't try to get cute.
     */
    PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
 
    memcpy(beentry->st_appname, appname, len);
    beentry->st_appname[len] = '\0';
 
    PGSTAT_END_WRITE_ACTIVITY(beentry);
}

References len, MyBEEntry, NAMEDATALEN, pg_mbcliplen(), PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, and PgBackendStatus::st_appname.

Referenced by assign_application_name(), and pgstat_bestart_final().

◆ pgstat_report_plan_id()

void pgstat_report_plan_id	(	uint64	plan_id,
		bool	force
	)

Definition at line 725 of file backend_status.c.

{
    volatile PgBackendStatus *beentry = MyBEEntry;
 
    /*
     * if track_activities is disabled, st_plan_id should already have been
     * reset
     */
    if (!beentry || !pgstat_track_activities)
        return;
 
    /*
     * We only report the top-level plan identifiers.  The stored plan_id is
     * reset when a backend calls pgstat_report_activity(STATE_RUNNING), or
     * with an explicit call to this function using the force flag.  If the
     * saved plan identifier is not zero it means that it's not a top-level
     * command, so ignore the one provided unless it's an explicit call to
     * reset the identifier.
     */
    if (beentry->st_plan_id != 0 && !force)
        return;
 
    /*
     * Update my status entry, following the protocol of bumping
     * st_changecount before and after.  We use a volatile pointer here to
     * ensure the compiler doesn't try to get cute.
     */
    PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
    beentry->st_plan_id = plan_id;
    PGSTAT_END_WRITE_ACTIVITY(beentry);
}

References MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_track_activities, and PgBackendStatus::st_plan_id.

Referenced by exec_bind_message(), exec_execute_message(), exec_simple_query(), and planner().

◆ pgstat_report_query_id()

void pgstat_report_query_id	(	uint64	query_id,
		bool	force
	)

Definition at line 686 of file backend_status.c.

{
    volatile PgBackendStatus *beentry = MyBEEntry;
 
    /*
     * if track_activities is disabled, st_query_id should already have been
     * reset
     */
    if (!beentry || !pgstat_track_activities)
        return;
 
    /*
     * We only report the top-level query identifiers.  The stored query_id is
     * reset when a backend calls pgstat_report_activity(STATE_RUNNING), or
     * with an explicit call to this function using the force flag.  If the
     * saved query identifier is not zero it means that it's not a top-level
     * command, so ignore the one provided unless it's an explicit call to
     * reset the identifier.
     */
    if (beentry->st_query_id != 0 && !force)
        return;
 
    /*
     * Update my status entry, following the protocol of bumping
     * st_changecount before and after.  We use a volatile pointer here to
     * ensure the compiler doesn't try to get cute.
     */
    PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
    beentry->st_query_id = query_id;
    PGSTAT_END_WRITE_ACTIVITY(beentry);
}

References MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_track_activities, and PgBackendStatus::st_query_id.

Referenced by _brin_parallel_build_main(), _bt_parallel_build_main(), exec_bind_message(), exec_execute_message(), exec_simple_query(), ExecutorStart(), parallel_vacuum_main(), parse_analyze_fixedparams(), parse_analyze_varparams(), and parse_analyze_withcb().

◆ pgstat_report_xact_timestamp()

void pgstat_report_xact_timestamp ( TimestampTz tstamp )

Definition at line 793 of file backend_status.c.

{
    volatile PgBackendStatus *beentry = MyBEEntry;
 
    if (!pgstat_track_activities || !beentry)
        return;
 
    /*
     * Update my status entry, following the protocol of bumping
     * st_changecount before and after.  We use a volatile pointer here to
     * ensure the compiler doesn't try to get cute.
     */
    PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
 
    beentry->st_xact_start_timestamp = tstamp;
 
    PGSTAT_END_WRITE_ACTIVITY(beentry);
}

References MyBEEntry, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_track_activities, and PgBackendStatus::st_xact_start_timestamp.

Referenced by AbortTransaction(), CommitTransaction(), PrepareTransaction(), and StartTransaction().

◆ pgstat_setup_backend_status_context()

static void pgstat_setup_backend_status_context ( void )

static

Definition at line 551 of file backend_status.c.

{
    if (!backendStatusSnapContext)
        backendStatusSnapContext = AllocSetContextCreate(TopMemoryContext,
                                                         "Backend Status Snapshot",
                                                         ALLOCSET_SMALL_SIZES);
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, backendStatusSnapContext, and TopMemoryContext.

Referenced by pgstat_read_current_status().

Variable Documentation

◆ BackendActivityBuffer

char* BackendActivityBuffer = NULL

static

Definition at line 53 of file backend_status.c.

Referenced by BackendStatusShmemInit(), and pgstat_get_crashed_backend_activity().

◆ BackendActivityBufferSize

Size BackendActivityBufferSize = 0

static

Definition at line 54 of file backend_status.c.

Referenced by BackendStatusShmemInit(), and pgstat_get_crashed_backend_activity().

◆ BackendAppnameBuffer

char* BackendAppnameBuffer = NULL

static

Definition at line 51 of file backend_status.c.

Referenced by BackendStatusShmemInit().

◆ BackendClientHostnameBuffer

char* BackendClientHostnameBuffer = NULL

static

Definition at line 52 of file backend_status.c.

Referenced by BackendStatusShmemInit().

◆ BackendStatusArray

PgBackendStatus* BackendStatusArray = NULL

static

Definition at line 50 of file backend_status.c.

Referenced by BackendStatusShmemInit(), pgstat_beinit(), pgstat_get_backend_current_activity(), pgstat_get_backend_type_by_proc_number(), pgstat_get_crashed_backend_activity(), and pgstat_read_current_status().

◆ backendStatusSnapContext

MemoryContext backendStatusSnapContext

static

Definition at line 69 of file backend_status.c.

Referenced by pgstat_clear_backend_activity_snapshot(), pgstat_read_current_status(), and pgstat_setup_backend_status_context().

◆ localBackendStatusTable

LocalPgBackendStatus* localBackendStatusTable = NULL

static

Definition at line 64 of file backend_status.c.

Referenced by pgstat_clear_backend_activity_snapshot(), pgstat_get_local_beentry_by_index(), pgstat_get_local_beentry_by_proc_number(), and pgstat_read_current_status().

◆ localNumBackends

int localNumBackends = 0

static

Definition at line 67 of file backend_status.c.

Referenced by pgstat_clear_backend_activity_snapshot(), pgstat_fetch_stat_numbackends(), pgstat_get_local_beentry_by_index(), pgstat_get_local_beentry_by_proc_number(), and pgstat_read_current_status().

◆ MyBEEntry

◆ pgstat_track_activities

bool pgstat_track_activities = false

Definition at line 42 of file backend_status.c.

Referenced by pgstat_progress_end_command(), pgstat_progress_incr_param(), pgstat_progress_start_command(), pgstat_progress_update_multi_param(), pgstat_progress_update_param(), pgstat_report_activity(), pgstat_report_plan_id(), pgstat_report_query_id(), and pgstat_report_xact_timestamp().

◆ pgstat_track_activity_query_size

int pgstat_track_activity_query_size = 1024

Definition at line 43 of file backend_status.c.

Referenced by BackendStatusShmemInit(), BackendStatusShmemSize(), pgstat_bestart_initial(), pgstat_clip_activity(), pgstat_get_crashed_backend_activity(), pgstat_read_current_status(), and pgstat_report_activity().

Macros

Functions

Variables

Macro Definition Documentation

◆ NumBackendStatSlots

Function Documentation

◆ BackendStatusShmemInit()

◆ BackendStatusShmemSize()

◆ cmp_lbestatus()

◆ pgstat_beinit()

◆ pgstat_beshutdown_hook()

◆ pgstat_bestart_final()

◆ pgstat_bestart_initial()

◆ pgstat_bestart_security()

◆ pgstat_clear_backend_activity_snapshot()

◆ pgstat_clip_activity()

◆ pgstat_fetch_stat_numbackends()

◆ pgstat_get_backend_current_activity()

◆ pgstat_get_backend_type_by_proc_number()

◆ pgstat_get_beentry_by_proc_number()

◆ pgstat_get_crashed_backend_activity()

◆ pgstat_get_local_beentry_by_index()

◆ pgstat_get_local_beentry_by_proc_number()

◆ pgstat_get_my_plan_id()

◆ pgstat_get_my_query_id()

◆ pgstat_read_current_status()

◆ pgstat_report_activity()

◆ pgstat_report_appname()

◆ pgstat_report_plan_id()

◆ pgstat_report_query_id()

◆ pgstat_report_xact_timestamp()

◆ pgstat_setup_backend_status_context()

Variable Documentation

◆ BackendActivityBuffer

◆ BackendActivityBufferSize

◆ BackendAppnameBuffer

◆ BackendClientHostnameBuffer

◆ BackendStatusArray

◆ backendStatusSnapContext

◆ localBackendStatusTable

◆ localNumBackends

◆ MyBEEntry

◆ pgstat_track_activities

◆ pgstat_track_activity_query_size