wait_event.c File Reference

#include "postgres.h"
#include "storage/lmgr.h"
#include "storage/lwlock.h"
#include "storage/spin.h"
#include "utils/wait_event.h"
#include "pgstat_wait_event.c"

Include dependency graph for wait_event.c:

Go to the source code of this file.

Data Structures
struct	WaitEventCustomEntryByInfo
struct	WaitEventCustomEntryByName
struct	WaitEventCustomCounterData

Macros
#define	WAIT_EVENT_CLASS_MASK   0xFF000000
#define	WAIT_EVENT_ID_MASK   0x0000FFFF
#define	WAIT_EVENT_CUSTOM_HASH_INIT_SIZE   16
#define	WAIT_EVENT_CUSTOM_HASH_MAX_SIZE   128
#define	WAIT_EVENT_CUSTOM_INITIAL_ID   1

Typedefs
typedef struct WaitEventCustomEntryByInfo	WaitEventCustomEntryByInfo
typedef struct WaitEventCustomEntryByName	WaitEventCustomEntryByName
typedef struct WaitEventCustomCounterData	WaitEventCustomCounterData

Functions
static const char *	pgstat_get_wait_activity (WaitEventActivity w)
static const char *	pgstat_get_wait_bufferpin (WaitEventBufferPin w)
static const char *	pgstat_get_wait_client (WaitEventClient w)
static const char *	pgstat_get_wait_ipc (WaitEventIPC w)
static const char *	pgstat_get_wait_timeout (WaitEventTimeout w)
static const char *	pgstat_get_wait_io (WaitEventIO w)
static uint32	WaitEventCustomNew (uint32 classId, const char *wait_event_name)
static const char *	GetWaitEventCustomIdentifier (uint32 wait_event_info)
Size	WaitEventCustomShmemSize (void)
void	WaitEventCustomShmemInit (void)
uint32	WaitEventExtensionNew (const char *wait_event_name)
uint32	WaitEventInjectionPointNew (const char *wait_event_name)
char **	GetWaitEventCustomNames (uint32 classId, int *nwaitevents)
void	pgstat_set_wait_event_storage (uint32 *wait_event_info)
void	pgstat_reset_wait_event_storage (void)
const char *	pgstat_get_wait_event_type (uint32 wait_event_info)
const char *	pgstat_get_wait_event (uint32 wait_event_info)

Variables
static uint32	local_my_wait_event_info
uint32 *	my_wait_event_info = &local_my_wait_event_info
static HTAB *	WaitEventCustomHashByInfo
static HTAB *	WaitEventCustomHashByName
static WaitEventCustomCounterData *	WaitEventCustomCounter

Macro Definition Documentation

WAIT_EVENT_CLASS_MASK

#define WAIT_EVENT_CLASS_MASK   0xFF000000

Definition at line 42 of file wait_event.c.

WAIT_EVENT_CUSTOM_HASH_INIT_SIZE

#define WAIT_EVENT_CUSTOM_HASH_INIT_SIZE   16

Definition at line 66 of file wait_event.c.

WAIT_EVENT_CUSTOM_HASH_MAX_SIZE

#define WAIT_EVENT_CUSTOM_HASH_MAX_SIZE   128

Definition at line 67 of file wait_event.c.

WAIT_EVENT_CUSTOM_INITIAL_ID

#define WAIT_EVENT_CUSTOM_INITIAL_ID   1

Definition at line 94 of file wait_event.c.

WAIT_EVENT_ID_MASK

#define WAIT_EVENT_ID_MASK   0x0000FFFF

Definition at line 43 of file wait_event.c.

Typedef Documentation

WaitEventCustomCounterData

typedef struct WaitEventCustomCounterData WaitEventCustomCounterData

WaitEventCustomEntryByInfo

typedef struct WaitEventCustomEntryByInfo WaitEventCustomEntryByInfo

WaitEventCustomEntryByName

typedef struct WaitEventCustomEntryByName WaitEventCustomEntryByName

Function Documentation

GetWaitEventCustomIdentifier()

static const char * GetWaitEventCustomIdentifier ( uint32  wait_event_info )

static

Definition at line 276 of file wait_event.c.

{
    bool        found;
    WaitEventCustomEntryByInfo *entry;
 
    /* Built-in event? */
    if (wait_event_info == PG_WAIT_EXTENSION)
        return "Extension";
 
    /* It is a user-defined wait event, so lookup hash table. */
    LWLockAcquire(WaitEventCustomLock, LW_SHARED);
    entry = (WaitEventCustomEntryByInfo *)
        hash_search(WaitEventCustomHashByInfo, &wait_event_info,
                    HASH_FIND, &found);
    LWLockRelease(WaitEventCustomLock);
 
    if (!entry)
        elog(ERROR,
             "could not find custom name for wait event information %u",
             wait_event_info);
 
    return entry->wait_event_name;
}

References elog, ERROR, HASH_FIND, hash_search(), LW_SHARED, LWLockAcquire(), LWLockRelease(), PG_WAIT_EXTENSION, WaitEventCustomEntryByInfo::wait_event_name, and WaitEventCustomHashByInfo.

Referenced by pgstat_get_wait_event().

GetWaitEventCustomNames()

char** GetWaitEventCustomNames	(	uint32	classId,
		int *	nwaitevents
	)

Definition at line 306 of file wait_event.c.

{
    char      **waiteventnames;
    WaitEventCustomEntryByName *hentry;
    HASH_SEQ_STATUS hash_seq;
    int         index;
    int         els;
 
    LWLockAcquire(WaitEventCustomLock, LW_SHARED);
 
    /* Now we can safely count the number of entries */
    els = hash_get_num_entries(WaitEventCustomHashByName);
 
    /* Allocate enough space for all entries */
    waiteventnames = palloc(els * sizeof(char *));
 
    /* Now scan the hash table to copy the data */
    hash_seq_init(&hash_seq, WaitEventCustomHashByName);
 
    index = 0;
    while ((hentry = (WaitEventCustomEntryByName *) hash_seq_search(&hash_seq)) != NULL)
    {
        if ((hentry->wait_event_info & WAIT_EVENT_CLASS_MASK) != classId)
            continue;
        waiteventnames[index] = pstrdup(hentry->wait_event_name);
        index++;
    }
 
    LWLockRelease(WaitEventCustomLock);
 
    *nwaitevents = index;
    return waiteventnames;
}

References hash_get_num_entries(), hash_seq_init(), hash_seq_search(), LW_SHARED, LWLockAcquire(), LWLockRelease(), palloc(), pstrdup(), WAIT_EVENT_CLASS_MASK, WaitEventCustomEntryByName::wait_event_info, WaitEventCustomEntryByName::wait_event_name, and WaitEventCustomHashByName.

Referenced by pg_get_wait_events().

pgstat_get_wait_activity()

static const char* pgstat_get_wait_activity ( WaitEventActivity  w )

static

Referenced by pgstat_get_wait_event().

pgstat_get_wait_bufferpin()

static const char* pgstat_get_wait_bufferpin ( WaitEventBufferPin  w )

static

Referenced by pgstat_get_wait_event().

pgstat_get_wait_client()

static const char* pgstat_get_wait_client ( WaitEventClient  w )

static

Referenced by pgstat_get_wait_event().

pgstat_get_wait_event()

const char* pgstat_get_wait_event

(

uint32

wait_event_info

)

Definition at line 431 of file wait_event.c.

{
    uint32      classId;
    uint16      eventId;
    const char *event_name;
 
    /* report process as not waiting. */
    if (wait_event_info == 0)
        return NULL;
 
    classId = wait_event_info & WAIT_EVENT_CLASS_MASK;
    eventId = wait_event_info & WAIT_EVENT_ID_MASK;
 
    switch (classId)
    {
        case PG_WAIT_LWLOCK:
            event_name = GetLWLockIdentifier(classId, eventId);
            break;
        case PG_WAIT_LOCK:
            event_name = GetLockNameFromTagType(eventId);
            break;
        case PG_WAIT_EXTENSION:
        case PG_WAIT_INJECTIONPOINT:
            event_name = GetWaitEventCustomIdentifier(wait_event_info);
            break;
        case PG_WAIT_BUFFERPIN:
            {
                WaitEventBufferPin w = (WaitEventBufferPin) wait_event_info;
 
                event_name = pgstat_get_wait_bufferpin(w);
                break;
            }
        case PG_WAIT_ACTIVITY:
            {
                WaitEventActivity w = (WaitEventActivity) wait_event_info;
 
                event_name = pgstat_get_wait_activity(w);
                break;
            }
        case PG_WAIT_CLIENT:
            {
                WaitEventClient w = (WaitEventClient) wait_event_info;
 
                event_name = pgstat_get_wait_client(w);
                break;
            }
        case PG_WAIT_IPC:
            {
                WaitEventIPC w = (WaitEventIPC) wait_event_info;
 
                event_name = pgstat_get_wait_ipc(w);
                break;
            }
        case PG_WAIT_TIMEOUT:
            {
                WaitEventTimeout w = (WaitEventTimeout) wait_event_info;
 
                event_name = pgstat_get_wait_timeout(w);
                break;
            }
        case PG_WAIT_IO:
            {
                WaitEventIO w = (WaitEventIO) wait_event_info;
 
                event_name = pgstat_get_wait_io(w);
                break;
            }
        default:
            event_name = "unknown wait event";
            break;
    }
 
    return event_name;
}

References GetLockNameFromTagType(), GetLWLockIdentifier(), GetWaitEventCustomIdentifier(), PG_WAIT_ACTIVITY, PG_WAIT_BUFFERPIN, PG_WAIT_CLIENT, PG_WAIT_EXTENSION, PG_WAIT_INJECTIONPOINT, PG_WAIT_IO, PG_WAIT_IPC, PG_WAIT_LOCK, PG_WAIT_LWLOCK, PG_WAIT_TIMEOUT, pgstat_get_wait_activity(), pgstat_get_wait_bufferpin(), pgstat_get_wait_client(), pgstat_get_wait_io(), pgstat_get_wait_ipc(), pgstat_get_wait_timeout(), WAIT_EVENT_CLASS_MASK, and WAIT_EVENT_ID_MASK.

Referenced by pg_stat_get_activity(), and pg_stat_get_backend_wait_event().

pgstat_get_wait_event_type()

const char* pgstat_get_wait_event_type

(

uint32

wait_event_info

)

Definition at line 373 of file wait_event.c.

{
    uint32      classId;
    const char *event_type;
 
    /* report process as not waiting. */
    if (wait_event_info == 0)
        return NULL;
 
    classId = wait_event_info & WAIT_EVENT_CLASS_MASK;
 
    switch (classId)
    {
        case PG_WAIT_LWLOCK:
            event_type = "LWLock";
            break;
        case PG_WAIT_LOCK:
            event_type = "Lock";
            break;
        case PG_WAIT_BUFFERPIN:
            event_type = "BufferPin";
            break;
        case PG_WAIT_ACTIVITY:
            event_type = "Activity";
            break;
        case PG_WAIT_CLIENT:
            event_type = "Client";
            break;
        case PG_WAIT_EXTENSION:
            event_type = "Extension";
            break;
        case PG_WAIT_IPC:
            event_type = "IPC";
            break;
        case PG_WAIT_TIMEOUT:
            event_type = "Timeout";
            break;
        case PG_WAIT_IO:
            event_type = "IO";
            break;
        case PG_WAIT_INJECTIONPOINT:
            event_type = "InjectionPoint";
            break;
        default:
            event_type = "???";
            break;
    }
 
    return event_type;
}

References PG_WAIT_ACTIVITY, PG_WAIT_BUFFERPIN, PG_WAIT_CLIENT, PG_WAIT_EXTENSION, PG_WAIT_INJECTIONPOINT, PG_WAIT_IO, PG_WAIT_IPC, PG_WAIT_LOCK, PG_WAIT_LWLOCK, PG_WAIT_TIMEOUT, and WAIT_EVENT_CLASS_MASK.

Referenced by pg_isolation_test_session_is_blocked(), pg_stat_get_activity(), pg_stat_get_backend_wait_event_type(), and WaitEventCustomNew().

pgstat_get_wait_io()

static const char* pgstat_get_wait_io ( WaitEventIO  w )

static

Referenced by pgstat_get_wait_event().

pgstat_get_wait_ipc()

static const char* pgstat_get_wait_ipc ( WaitEventIPC  w )

static

Referenced by pgstat_get_wait_event().

pgstat_get_wait_timeout()

static const char* pgstat_get_wait_timeout ( WaitEventTimeout  w )

static

Referenced by pgstat_get_wait_event().

pgstat_reset_wait_event_storage()

void pgstat_reset_wait_event_storage

(

void

)

Definition at line 361 of file wait_event.c.

{
    my_wait_event_info = &local_my_wait_event_info;
}

References local_my_wait_event_info, and my_wait_event_info.

Referenced by AuxiliaryProcKill(), and ProcKill().

pgstat_set_wait_event_storage()

void pgstat_set_wait_event_storage

(

uint32 *

wait_event_info

)

Definition at line 349 of file wait_event.c.

{
    my_wait_event_info = wait_event_info;
}

References my_wait_event_info.

Referenced by InitAuxiliaryProcess(), and InitProcess().

WaitEventCustomNew()

static uint32 WaitEventCustomNew ( uint32  classId, const char *  wait_event_name  )

static

Definition at line 175 of file wait_event.c.

{
    uint16      eventId;
    bool        found;
    WaitEventCustomEntryByName *entry_by_name;
    WaitEventCustomEntryByInfo *entry_by_info;
    uint32      wait_event_info;
 
    /* Check the limit of the length of the event name */
    if (strlen(wait_event_name) >= NAMEDATALEN)
        elog(ERROR,
             "cannot use custom wait event string longer than %u characters",
             NAMEDATALEN - 1);
 
    /*
     * Check if the wait event info associated to the name is already defined,
     * and return it if so.
     */
    LWLockAcquire(WaitEventCustomLock, LW_SHARED);
    entry_by_name = (WaitEventCustomEntryByName *)
        hash_search(WaitEventCustomHashByName, wait_event_name,
                    HASH_FIND, &found);
    LWLockRelease(WaitEventCustomLock);
    if (found)
    {
        uint32      oldClassId;
 
        oldClassId = entry_by_name->wait_event_info & WAIT_EVENT_CLASS_MASK;
        if (oldClassId != classId)
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("wait event \"%s\" already exists in type \"%s\"",
                            wait_event_name,
                            pgstat_get_wait_event_type(entry_by_name->wait_event_info))));
        return entry_by_name->wait_event_info;
    }
 
    /*
     * Allocate and register a new wait event.  Recheck if the event name
     * exists, as it could be possible that a concurrent process has inserted
     * one with the same name since the LWLock acquired again here was
     * previously released.
     */
    LWLockAcquire(WaitEventCustomLock, LW_EXCLUSIVE);
    entry_by_name = (WaitEventCustomEntryByName *)
        hash_search(WaitEventCustomHashByName, wait_event_name,
                    HASH_FIND, &found);
    if (found)
    {
        uint32      oldClassId;
 
        LWLockRelease(WaitEventCustomLock);
        oldClassId = entry_by_name->wait_event_info & WAIT_EVENT_CLASS_MASK;
        if (oldClassId != classId)
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("wait event \"%s\" already exists in type \"%s\"",
                            wait_event_name,
                            pgstat_get_wait_event_type(entry_by_name->wait_event_info))));
        return entry_by_name->wait_event_info;
    }
 
    /* Allocate a new event Id */
    SpinLockAcquire(&WaitEventCustomCounter->mutex);
 
    if (WaitEventCustomCounter->nextId >= WAIT_EVENT_CUSTOM_HASH_MAX_SIZE)
    {
        SpinLockRelease(&WaitEventCustomCounter->mutex);
        ereport(ERROR,
                errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                errmsg("too many custom wait events"));
    }
 
    eventId = WaitEventCustomCounter->nextId++;
 
    SpinLockRelease(&WaitEventCustomCounter->mutex);
 
    /* Register the new wait event */
    wait_event_info = classId | eventId;
    entry_by_info = (WaitEventCustomEntryByInfo *)
        hash_search(WaitEventCustomHashByInfo, &wait_event_info,
                    HASH_ENTER, &found);
    Assert(!found);
    strlcpy(entry_by_info->wait_event_name, wait_event_name,
            sizeof(entry_by_info->wait_event_name));
 
    entry_by_name = (WaitEventCustomEntryByName *)
        hash_search(WaitEventCustomHashByName, wait_event_name,
                    HASH_ENTER, &found);
    Assert(!found);
    entry_by_name->wait_event_info = wait_event_info;
 
    LWLockRelease(WaitEventCustomLock);
 
    return wait_event_info;
}

References Assert, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, HASH_ENTER, HASH_FIND, hash_search(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), WaitEventCustomCounterData::mutex, NAMEDATALEN, WaitEventCustomCounterData::nextId, pgstat_get_wait_event_type(), SpinLockAcquire, SpinLockRelease, strlcpy(), WAIT_EVENT_CLASS_MASK, WAIT_EVENT_CUSTOM_HASH_MAX_SIZE, WaitEventCustomEntryByName::wait_event_info, WaitEventCustomEntryByInfo::wait_event_name, WaitEventCustomCounter, WaitEventCustomHashByInfo, and WaitEventCustomHashByName.

Referenced by WaitEventExtensionNew(), and WaitEventInjectionPointNew().

WaitEventCustomShmemInit()

void WaitEventCustomShmemInit

(

void

)

Definition at line 119 of file wait_event.c.

{
    bool        found;
    HASHCTL     info;
 
    WaitEventCustomCounter = (WaitEventCustomCounterData *)
        ShmemInitStruct("WaitEventCustomCounterData",
                        sizeof(WaitEventCustomCounterData), &found);
 
    if (!found)
    {
        /* initialize the allocation counter and its spinlock. */
        WaitEventCustomCounter->nextId = WAIT_EVENT_CUSTOM_INITIAL_ID;
        SpinLockInit(&WaitEventCustomCounter->mutex);
    }
 
    /* initialize or attach the hash tables to store custom wait events */
    info.keysize = sizeof(uint32);
    info.entrysize = sizeof(WaitEventCustomEntryByInfo);
    WaitEventCustomHashByInfo =
        ShmemInitHash("WaitEventCustom hash by wait event information",
                      WAIT_EVENT_CUSTOM_HASH_INIT_SIZE,
                      WAIT_EVENT_CUSTOM_HASH_MAX_SIZE,
                      &info,
                      HASH_ELEM | HASH_BLOBS);
 
    /* key is a NULL-terminated string */
    info.keysize = sizeof(char[NAMEDATALEN]);
    info.entrysize = sizeof(WaitEventCustomEntryByName);
    WaitEventCustomHashByName =
        ShmemInitHash("WaitEventCustom hash by name",
                      WAIT_EVENT_CUSTOM_HASH_INIT_SIZE,
                      WAIT_EVENT_CUSTOM_HASH_MAX_SIZE,
                      &info,
                      HASH_ELEM | HASH_STRINGS);
}

References HASHCTL::entrysize, HASH_BLOBS, HASH_ELEM, HASH_STRINGS, HASHCTL::keysize, WaitEventCustomCounterData::mutex, NAMEDATALEN, WaitEventCustomCounterData::nextId, ShmemInitHash(), ShmemInitStruct(), SpinLockInit, WAIT_EVENT_CUSTOM_HASH_INIT_SIZE, WAIT_EVENT_CUSTOM_HASH_MAX_SIZE, WAIT_EVENT_CUSTOM_INITIAL_ID, WaitEventCustomCounter, WaitEventCustomHashByInfo, and WaitEventCustomHashByName.

Referenced by CreateOrAttachShmemStructs().

WaitEventCustomShmemSize()

Size WaitEventCustomShmemSize

(

void

)

Definition at line 103 of file wait_event.c.

{
    Size        sz;
 
    sz = MAXALIGN(sizeof(WaitEventCustomCounterData));
    sz = add_size(sz, hash_estimate_size(WAIT_EVENT_CUSTOM_HASH_MAX_SIZE,
                                         sizeof(WaitEventCustomEntryByInfo)));
    sz = add_size(sz, hash_estimate_size(WAIT_EVENT_CUSTOM_HASH_MAX_SIZE,
                                         sizeof(WaitEventCustomEntryByName)));
    return sz;
}

References add_size(), hash_estimate_size(), MAXALIGN, and WAIT_EVENT_CUSTOM_HASH_MAX_SIZE.

Referenced by CalculateShmemSize().

WaitEventExtensionNew()

uint32 WaitEventExtensionNew

(

const char *

wait_event_name

)

Definition at line 163 of file wait_event.c.

{
    return WaitEventCustomNew(PG_WAIT_EXTENSION, wait_event_name);
}

References PG_WAIT_EXTENSION, and WaitEventCustomNew().

Referenced by connect_pg_server(), dblink_connect(), dblink_get_conn(), dblink_init(), GetConnection(), pgfdw_get_cleanup_result(), test_shm_mq_pipelined(), wait_for_workers_to_become_ready(), and worker_spi_main().

WaitEventInjectionPointNew()

uint32 WaitEventInjectionPointNew

(

const char *

wait_event_name

)

Definition at line 169 of file wait_event.c.

{
    return WaitEventCustomNew(PG_WAIT_INJECTIONPOINT, wait_event_name);
}

References PG_WAIT_INJECTIONPOINT, and WaitEventCustomNew().

Referenced by injection_wait().

Variable Documentation

local_my_wait_event_info

uint32 local_my_wait_event_info

static

Definition at line 39 of file wait_event.c.

Referenced by pgstat_reset_wait_event_storage().

my_wait_event_info

uint32* my_wait_event_info = &local_my_wait_event_info

Definition at line 40 of file wait_event.c.

Referenced by pgstat_report_wait_end(), pgstat_report_wait_start(), pgstat_reset_wait_event_storage(), and pgstat_set_wait_event_storage().

WaitEventCustomCounter

WaitEventCustomCounterData* WaitEventCustomCounter

static

Definition at line 91 of file wait_event.c.

Referenced by WaitEventCustomNew(), and WaitEventCustomShmemInit().

WaitEventCustomHashByInfo

HTAB* WaitEventCustomHashByInfo

static

Definition at line 63 of file wait_event.c.

Referenced by GetWaitEventCustomIdentifier(), WaitEventCustomNew(), and WaitEventCustomShmemInit().

WaitEventCustomHashByName

HTAB* WaitEventCustomHashByName

static

Definition at line 64 of file wait_event.c.

Referenced by GetWaitEventCustomNames(), WaitEventCustomNew(), and WaitEventCustomShmemInit().