backend_status.h File Reference

#include "datatype/timestamp.h"
#include "libpq/pqcomm.h"
#include "miscadmin.h"
#include "storage/procnumber.h"
#include "utils/backend_progress.h"

Include dependency graph for backend_status.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PgBackendSSLStatus
struct	PgBackendGSSStatus
struct	PgBackendStatus
struct	LocalPgBackendStatus

Macros
#define	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry)
#define	PGSTAT_END_WRITE_ACTIVITY(beentry)
#define	pgstat_begin_read_activity(beentry, before_changecount)
#define	pgstat_end_read_activity(beentry, after_changecount)
#define	pgstat_read_activity_complete(before_changecount, after_changecount)

Typedefs
typedef enum BackendState	BackendState
typedef struct PgBackendSSLStatus	PgBackendSSLStatus
typedef struct PgBackendGSSStatus	PgBackendGSSStatus
typedef struct PgBackendStatus	PgBackendStatus
typedef struct LocalPgBackendStatus	LocalPgBackendStatus

Enumerations
enum	BackendState {   STATE_UNDEFINED , STATE_STARTING , STATE_IDLE , STATE_RUNNING ,   STATE_IDLEINTRANSACTION , STATE_FASTPATH , STATE_IDLEINTRANSACTION_ABORTED , STATE_DISABLED }

Functions
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_tempfile (size_t filesize)
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)
int	pgstat_fetch_stat_numbackends (void)
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)
char *	pgstat_clip_activity (const char *raw_activity)

Variables
PGDLLIMPORT bool	pgstat_track_activities
PGDLLIMPORT int	pgstat_track_activity_query_size
PGDLLIMPORT PgBackendStatus *	MyBEEntry

Macro Definition Documentation

pgstat_begin_read_activity

#define pgstat_begin_read_activity	(		beentry,
			before_changecount
	)

Value:

    do { \
        (before_changecount) = (beentry)->st_changecount; \
        pg_read_barrier(); \
    } while (0)

Definition at line 224 of file backend_status.h.

PGSTAT_BEGIN_WRITE_ACTIVITY

#define PGSTAT_BEGIN_WRITE_ACTIVITY

(

beentry

)

Value:

    do { \
        START_CRIT_SECTION(); \
        (beentry)->st_changecount++; \
        pg_write_barrier(); \
    } while (0)

Definition at line 209 of file backend_status.h.

pgstat_end_read_activity

#define pgstat_end_read_activity	(		beentry,
			after_changecount
	)

Value:

    do { \
        pg_read_barrier(); \
        (after_changecount) = (beentry)->st_changecount; \
    } while (0)

Definition at line 230 of file backend_status.h.

PGSTAT_END_WRITE_ACTIVITY

#define PGSTAT_END_WRITE_ACTIVITY

(

beentry

)

Value:

    do { \
        pg_write_barrier(); \
        (beentry)->st_changecount++; \
        Assert(((beentry)->st_changecount & 1) == 0); \
        END_CRIT_SECTION(); \
    } while (0)

Definition at line 216 of file backend_status.h.

pgstat_read_activity_complete

#define pgstat_read_activity_complete	(		before_changecount,
			after_changecount
	)

Value:

    ((before_changecount) == (after_changecount) && \
     ((before_changecount) & 1) == 0)

Definition at line 236 of file backend_status.h.

Typedef Documentation

BackendState

typedef enum BackendState BackendState

LocalPgBackendStatus

typedef struct LocalPgBackendStatus LocalPgBackendStatus

PgBackendGSSStatus

typedef struct PgBackendGSSStatus PgBackendGSSStatus

PgBackendSSLStatus

typedef struct PgBackendSSLStatus PgBackendSSLStatus

PgBackendStatus

typedef struct PgBackendStatus PgBackendStatus

Enumeration Type Documentation

BackendState

enum BackendState

Enumerator
STATE_UNDEFINED
STATE_STARTING
STATE_IDLE
STATE_RUNNING
STATE_IDLEINTRANSACTION
STATE_FASTPATH
STATE_IDLEINTRANSACTION_ABORTED
STATE_DISABLED

Definition at line 24 of file backend_status.h.

{
    STATE_UNDEFINED,
    STATE_STARTING,
    STATE_IDLE,
    STATE_RUNNING,
    STATE_IDLEINTRANSACTION,
    STATE_FASTPATH,
    STATE_IDLEINTRANSACTION_ABORTED,
    STATE_DISABLED,
} BackendState;

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

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_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);
}

References Assert(), InvalidOid, MemSet, MyBackendType, MyBEEntry, MyProcPid, MyProcPort, MyStartTimestamp, NAMEDATALEN, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_track_activity_query_size, PROGRESS_COMMAND_INVALID, Port::raddr, Port::remote_hostname, PgBackendStatus::st_activity_raw, PgBackendStatus::st_activity_start_timestamp, PgBackendStatus::st_appname, PgBackendStatus::st_backendType, PgBackendStatus::st_changecount, PgBackendStatus::st_clientaddr, PgBackendStatus::st_clienthostname, PgBackendStatus::st_databaseid, PgBackendStatus::st_gss, PgBackendStatus::st_gssstatus, PgBackendStatus::st_plan_id, PgBackendStatus::st_proc_start_timestamp, PgBackendStatus::st_procpid, PgBackendStatus::st_progress_command, PgBackendStatus::st_progress_command_target, PgBackendStatus::st_query_id, PgBackendStatus::st_ssl, PgBackendStatus::st_sslstatus, PgBackendStatus::st_state, PgBackendStatus::st_state_start_timestamp, PgBackendStatus::st_userid, PgBackendStatus::st_xact_start_timestamp, STATE_STARTING, strlcpy(), UINT64CONST, and unvolatize.

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_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_tempfile()

void pgstat_report_tempfile

(

size_t

filesize

)

Definition at line 211 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbent;
 
    if (!pgstat_track_counts)
        return;
 
    dbent = pgstat_prep_database_pending(MyDatabaseId);
    dbent->temp_bytes += filesize;
    dbent->temp_files++;
}

References MyDatabaseId, pgstat_prep_database_pending(), pgstat_track_counts, PgStat_StatDBEntry::temp_bytes, and PgStat_StatDBEntry::temp_files.

Referenced by ReportTemporaryFileUsage().

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

Variable Documentation

MyBEEntry

PGDLLIMPORT PgBackendStatus* MyBEEntry

extern

Definition at line 47 of file backend_status.c.

Referenced by do_analyze_rel(), heap_vacuum_rel(), pgstat_beinit(), pgstat_beshutdown_hook(), pgstat_bestart_final(), pgstat_bestart_initial(), pgstat_bestart_security(), pgstat_get_my_plan_id(), pgstat_get_my_query_id(), 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_appname(), pgstat_report_plan_id(), pgstat_report_query_id(), and pgstat_report_xact_timestamp().

pgstat_track_activities

PGDLLIMPORT bool pgstat_track_activities

extern

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

PGDLLIMPORT int pgstat_track_activity_query_size

extern

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