#include "postgres.h"
#include "access/xact.h"
#include "libpq/libpq.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "port/atomics.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "storage/sinvaladt.h"
#include "utils/ascii.h"
#include "utils/backend_status.h"
#include "utils/guc.h"
#include "utils/memutils.h"

Include dependency graph for backend_status.c:

Macros
#define	NumBackendStatSlots (MaxBackends + NUM_AUXPROCTYPES)

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

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

PgBackendStatus *	pgstat_get_beentry_by_backend_id (BackendId beid)

LocalPgBackendStatus *	pgstat_get_local_beentry_by_backend_id (BackendId beid)

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_AUXPROCTYPES)

Definition at line 38 of file backend_status.c.

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

◆ cmp_lbestatus()

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

static

Definition at line 1067 of file backend_status.c.

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

References a, b, and LocalPgBackendStatus::backend_id.

Referenced by pgstat_get_local_beentry_by_backend_id().

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

static void pgstat_beshutdown_hook	(	int	code,
		Datum	arg
	)

static

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

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);
         lgssstatus.gss_delegation = be_gssapi_get_delegation(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);
 }

Referenced by AuxiliaryProcessMain(), and InitPostgres().

◆ pgstat_clear_backend_activity_snapshot()

void pgstat_clear_backend_activity_snapshot ( void )

Definition at line 486 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 1182 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 1166 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 903 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_beentry_by_backend_id()

PgBackendStatus* pgstat_get_beentry_by_backend_id ( BackendId beid )

Definition at line 1090 of file backend_status.c.

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

References LocalPgBackendStatus::backendStatus, and pgstat_get_local_beentry_by_backend_id().

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

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

Definition at line 981 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_backend_id()

LocalPgBackendStatus* pgstat_get_local_beentry_by_backend_id ( BackendId beid )

Definition at line 1115 of file backend_status.c.

 {
     LocalPgBackendStatus key;
  
     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;
     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_backend_id().

◆ pgstat_get_local_beentry_by_index()

LocalPgBackendStatus* pgstat_get_local_beentry_by_index ( int idx )

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

uint64 pgstat_get_my_query_id ( void )

Definition at line 1045 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_read_current_status()

static void pgstat_read_current_status ( void )

static

Definition at line 728 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
     int         i;
  
     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,
                                pgstat_track_activity_query_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 (i = 1; i <= NumBackendStatSlots; i++)
     {
         /*
          * 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, (char *) beentry->st_appname);
                 localentry->backendStatus.st_appname = localappname;
                 strcpy(localclienthostname, (char *) beentry->st_clienthostname);
                 localentry->backendStatus.st_clienthostname = localclienthostname;
                 strcpy(localactivity, (char *) 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 BackendId of the
              * source backend.  Note that this means localBackendStatusTable
              * is in order by backend_id.  pgstat_get_beentry_by_backend_id()
              * depends on that.
              */
             localentry->backend_id = i;
             BackendIdGetTransactionIds(i,
                                        &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_backend_id(), and pgstat_get_local_beentry_by_index().

◆ pgstat_report_activity()

void pgstat_report_activity	(	BackendState	state,
		const char *	cmd_str
	)

Definition at line 522 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 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(), PostgresMain(), and worker_spi_main().

◆ pgstat_report_appname()

void pgstat_report_appname ( const char * appname )

Definition at line 672 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 632 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_xact_timestamp()

void pgstat_report_xact_timestamp ( TimestampTz tstamp )

Definition at line 701 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 501 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 56 of file backend_status.c.

Referenced by CreateSharedBackendStatus(), and pgstat_get_crashed_backend_activity().

◆ BackendActivityBufferSize

Size BackendActivityBufferSize = 0

static

Definition at line 57 of file backend_status.c.

Referenced by CreateSharedBackendStatus(), and pgstat_get_crashed_backend_activity().

◆ BackendAppnameBuffer

char* BackendAppnameBuffer = NULL

static

Definition at line 54 of file backend_status.c.

Referenced by CreateSharedBackendStatus().

◆ BackendClientHostnameBuffer

char* BackendClientHostnameBuffer = NULL

static

Definition at line 55 of file backend_status.c.

Referenced by CreateSharedBackendStatus().

◆ BackendStatusArray

PgBackendStatus* BackendStatusArray = NULL

static

Definition at line 53 of file backend_status.c.

Referenced by CreateSharedBackendStatus(), pgstat_beinit(), pgstat_get_backend_current_activity(), pgstat_get_crashed_backend_activity(), and pgstat_read_current_status().

◆ backendStatusSnapContext

MemoryContext backendStatusSnapContext

static

Definition at line 72 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 67 of file backend_status.c.

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

◆ localNumBackends

int localNumBackends = 0

static

Definition at line 70 of file backend_status.c.

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

◆ MyBEEntry

PgBackendStatus* MyBEEntry = NULL

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

bool pgstat_track_activities = false

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

int pgstat_track_activity_query_size = 1024

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

Macros

Functions

Variables

Macro Definition Documentation

◆ NumBackendStatSlots

Function Documentation

◆ BackendStatusShmemSize()

◆ cmp_lbestatus()

◆ CreateSharedBackendStatus()

◆ pgstat_beinit()

◆ pgstat_beshutdown_hook()

◆ pgstat_bestart()

◆ pgstat_clear_backend_activity_snapshot()

◆ pgstat_clip_activity()

◆ pgstat_fetch_stat_numbackends()

◆ pgstat_get_backend_current_activity()

◆ pgstat_get_beentry_by_backend_id()

◆ pgstat_get_crashed_backend_activity()

◆ pgstat_get_local_beentry_by_backend_id()

◆ pgstat_get_local_beentry_by_index()

◆ pgstat_get_my_query_id()

◆ pgstat_read_current_status()

◆ pgstat_report_activity()

◆ pgstat_report_appname()

◆ 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