backend_status.h File Reference

#include "datatype/timestamp.h"
#include "libpq/pqcomm.h"
#include "miscadmin.h"
#include "storage/backendid.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_IDLE , STATE_RUNNING , STATE_IDLEINTRANSACTION ,   STATE_FASTPATH , STATE_IDLEINTRANSACTION_ABORTED , STATE_DISABLED }

Functions
Size	BackendStatusShmemSize (void)
void	CreateSharedBackendStatus (void)
void	pgstat_beinit (void)
void	pgstat_bestart (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_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)
int	pgstat_fetch_stat_numbackends (void)
PgBackendStatus *	pgstat_fetch_stat_beentry (BackendId beid)
LocalPgBackendStatus *	pgstat_fetch_stat_local_beentry (int beid)
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 219 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 204 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 225 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 211 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 231 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_IDLE
STATE_RUNNING
STATE_IDLEINTRANSACTION
STATE_FASTPATH
STATE_IDLEINTRANSACTION_ABORTED
STATE_DISABLED

Definition at line 24 of file backend_status.h.

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

Function Documentation

BackendStatusShmemSize()

Size BackendStatusShmemSize

(

void

)

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

CreateSharedBackendStatus()

void CreateSharedBackendStatus

(

void

)

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

pgstat_beinit()

void pgstat_beinit

(

void

)

Definition at line 249 of file backend_status.c.

{
    /* Initialize MyBEEntry */
    if (MyBackendId != InvalidBackendId)
    {
        Assert(MyBackendId >= 1 && MyBackendId <= MaxBackends);
        MyBEEntry = &BackendStatusArray[MyBackendId - 1];
    }
    else
    {
        /* Must be an auxiliary process */
        Assert(MyAuxProcType != NotAnAuxProcess);
 
        /*
         * Assign the MyBEEntry for an auxiliary process.  Since it doesn't
         * have a BackendId, the slot is statically allocated based on the
         * auxiliary process type (MyAuxProcType).  Backends use slots indexed
         * in the range from 1 to MaxBackends (inclusive), so we use
         * MaxBackends + AuxBackendType + 1 as the index of the slot for an
         * auxiliary process.
         */
        MyBEEntry = &BackendStatusArray[MaxBackends + MyAuxProcType];
    }
 
    /* Set up a process-exit hook to clean up */
    on_shmem_exit(pgstat_beshutdown_hook, 0);
}

References Assert(), BackendStatusArray, InvalidBackendId, MaxBackends, MyAuxProcType, MyBackendId, MyBEEntry, NotAnAuxProcess, on_shmem_exit(), and pgstat_beshutdown_hook().

Referenced by AuxiliaryProcessMain(), and InitPostgres().

pgstat_bestart()

void pgstat_bestart

(

void

)

Definition at line 292 of file backend_status.c.

{
    volatile PgBackendStatus *vbeentry = MyBEEntry;
    PgBackendStatus lbeentry;
#ifdef USE_SSL
    PgBackendSSLStatus lsslstatus;
#endif
#ifdef ENABLE_GSS
    PgBackendGSSStatus lgssstatus;
#endif
 
    /* 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));
 
    /* These structs can just start from zeroes each time, though */
#ifdef USE_SSL
    memset(&lsslstatus, 0, sizeof(lsslstatus));
#endif
#ifdef ENABLE_GSS
    memset(&lgssstatus, 0, sizeof(lgssstatus));
#endif
 
    /*
     * 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 = MyDatabaseId;
 
    /* We have userid for client-backends, wal-sender and bgworker processes */
    if (lbeentry.st_backendType == B_BACKEND
        || lbeentry.st_backendType == B_WAL_SENDER
        || lbeentry.st_backendType == B_BG_WORKER)
        lbeentry.st_userid = GetSessionUserId();
    else
        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));
 
#ifdef USE_SSL
    if (MyProcPort && MyProcPort->ssl_in_use)
    {
        lbeentry.st_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);
    }
    else
    {
        lbeentry.st_ssl = false;
    }
#else
    lbeentry.st_ssl = false;
#endif
 
#ifdef ENABLE_GSS
    if (MyProcPort && MyProcPort->gss != NULL)
    {
        const char *princ = be_gssapi_get_princ(MyProcPort);
 
        lbeentry.st_gss = true;
        lgssstatus.gss_auth = be_gssapi_get_auth(MyProcPort);
        lgssstatus.gss_enc = be_gssapi_get_enc(MyProcPort);
        if (princ)
            strlcpy(lgssstatus.gss_princ, princ, NAMEDATALEN);
    }
    else
    {
        lbeentry.st_gss = false;
    }
#else
    lbeentry.st_gss = false;
#endif
 
    lbeentry.st_state = STATE_UNDEFINED;
    lbeentry.st_progress_command = PROGRESS_COMMAND_INVALID;
    lbeentry.st_progress_command_target = InvalidOid;
    lbeentry.st_query_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';
 
#ifdef USE_SSL
    memcpy(lbeentry.st_sslstatus, &lsslstatus, sizeof(PgBackendSSLStatus));
#endif
#ifdef ENABLE_GSS
    memcpy(lbeentry.st_gssstatus, &lgssstatus, sizeof(PgBackendGSSStatus));
#endif
 
    PGSTAT_END_WRITE_ACTIVITY(vbeentry);
 
    /* 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, be_gssapi_get_auth(), 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(), GetSessionUserId(), Port::gss, PgBackendGSSStatus::gss_auth, PgBackendGSSStatus::gss_enc, PgBackendGSSStatus::gss_princ, InvalidOid, MemSet, MyBackendType, MyBEEntry, MyDatabaseId, MyProcPid, MyProcPort, MyStartTimestamp, NAMEDATALEN, PGSTAT_BEGIN_WRITE_ACTIVITY, PGSTAT_END_WRITE_ACTIVITY, pgstat_report_appname(), pgstat_track_activity_query_size, PROGRESS_COMMAND_INVALID, Port::raddr, Port::remote_hostname, 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_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_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_UNDEFINED, strlcpy(), and unvolatize.

Referenced by AuxiliaryProcessMain(), and InitPostgres().

pgstat_clear_backend_activity_snapshot()

void pgstat_clear_backend_activity_snapshot

(

void

)

Definition at line 485 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 1163 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_beentry()

PgBackendStatus* pgstat_fetch_stat_beentry

(

BackendId

beid

)

Definition at line 1089 of file backend_status.c.

{
    LocalPgBackendStatus key;
    LocalPgBackendStatus *ret;
 
    pgstat_read_current_status();
 
    /*
     * Since the localBackendStatusTable is in order by backend_id, we can use
     * bsearch() to search it efficiently.
     */
    key.backend_id = beid;
    ret = (LocalPgBackendStatus *) bsearch(&key, localBackendStatusTable,
                                           localNumBackends,
                                           sizeof(LocalPgBackendStatus),
                                           cmp_lbestatus);
    if (ret)
        return &ret->backendStatus;
 
    return NULL;
}

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

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(), and pg_stat_get_backend_xact_start().

pgstat_fetch_stat_local_beentry()

LocalPgBackendStatus* pgstat_fetch_stat_local_beentry

(

int

beid

)

Definition at line 1127 of file backend_status.c.

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

References localBackendStatusTable, localNumBackends, and pgstat_read_current_status().

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

pgstat_fetch_stat_numbackends()

int pgstat_fetch_stat_numbackends

(

void

)

Definition at line 1147 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 902 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_crashed_backend_activity()

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

Definition at line 980 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_my_query_id()

uint64 pgstat_get_my_query_id

(

void

)

Definition at line 1044 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 ExecSerializePlan(), log_status_format(), write_csvlog(), and write_jsonlog().

pgstat_report_activity()

void pgstat_report_activity	(	BackendState	state,
		const char *	cmd_str
	)

Definition at line 521 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);
            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);
 
    if (cmd_str != NULL)
    {
        memcpy((char *) 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 current_timestamp(), 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_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(), and PGPROC::wait_event_info.

Referenced by _bt_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(), and PostgresMain().

pgstat_report_appname()

void pgstat_report_appname

(

const char *

appname

)

Definition at line 671 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((char *) 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().

pgstat_report_query_id()

void pgstat_report_query_id	(	uint64	query_id,
		bool	force
	)

Definition at line 631 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 exec_simple_query(), ExecutorStart(), parse_analyze_fixedparams(), parse_analyze_varparams(), and parse_analyze_withcb().

pgstat_report_tempfile()

void pgstat_report_tempfile

(

size_t

filesize

)

Definition at line 172 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 700 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 50 of file backend_status.c.

Referenced by pgstat_beinit(), pgstat_beshutdown_hook(), pgstat_bestart(), 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_query_id(), and pgstat_report_xact_timestamp().

pgstat_track_activities

PGDLLIMPORT bool pgstat_track_activities

extern

Definition at line 45 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_query_id(), and pgstat_report_xact_timestamp().

pgstat_track_activity_query_size

PGDLLIMPORT int pgstat_track_activity_query_size

extern

Definition at line 46 of file backend_status.c.

Referenced by BackendStatusShmemSize(), CreateSharedBackendStatus(), pgstat_bestart(), pgstat_clip_activity(), pgstat_get_crashed_backend_activity(), pgstat_read_current_status(), and pgstat_report_activity().