wait_event.c File Reference

#include "postgres.h"
#include "storage/lmgr.h"
#include "storage/lwlock.h"
#include "storage/shmem.h"
#include "storage/subsystems.h"
#include "storage/spin.h"
#include "utils/wait_event.h"
#include "utils/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_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_buffer (WaitEventBuffer 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)
static void	WaitEventCustomShmemRequest (void *arg)
static void	WaitEventCustomShmemInit (void *arg)
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
const ShmemCallbacks	WaitEventCustomShmemCallbacks

Macro Definition Documentation

WAIT_EVENT_CLASS_MASK

#define WAIT_EVENT_CLASS_MASK   0xFF000000

Definition at line 44 of file wait_event.c.

WAIT_EVENT_CUSTOM_HASH_SIZE

#define WAIT_EVENT_CUSTOM_HASH_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 45 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 262 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, fb(), 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 292 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_array(char *, els);
 
    /* 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 fb(), hash_get_num_entries(), hash_seq_init(), hash_seq_search(), LW_SHARED, LWLockAcquire(), LWLockRelease(), palloc_array, pstrdup(), WAIT_EVENT_CLASS_MASK, 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_buffer()

static const char * pgstat_get_wait_buffer ( WaitEventBuffer  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 417 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_BUFFER:
            {
                WaitEventBuffer w = (WaitEventBuffer) wait_event_info;
 
                event_name = pgstat_get_wait_buffer(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 fb(), GetLockNameFromTagType(), GetLWLockIdentifier(), GetWaitEventCustomIdentifier(), PG_WAIT_ACTIVITY, PG_WAIT_BUFFER, 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_buffer(), 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 359 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_BUFFER:
            event_type = "Buffer";
            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 fb(), PG_WAIT_ACTIVITY, PG_WAIT_BUFFER, 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 347 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 335 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 161 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_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, fb(), 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_SIZE, WaitEventCustomCounter, WaitEventCustomHashByInfo, and WaitEventCustomHashByName.

Referenced by WaitEventExtensionNew(), and WaitEventInjectionPointNew().

WaitEventCustomShmemInit()

static void WaitEventCustomShmemInit ( void *  arg )

static

Definition at line 135 of file wait_event.c.

{
    /* initialize the allocation counter and its spinlock. */
    WaitEventCustomCounter->nextId = WAIT_EVENT_CUSTOM_INITIAL_ID;
    SpinLockInit(&WaitEventCustomCounter->mutex);
}

References WaitEventCustomCounterData::mutex, WaitEventCustomCounterData::nextId, SpinLockInit(), WAIT_EVENT_CUSTOM_INITIAL_ID, and WaitEventCustomCounter.

WaitEventCustomShmemRequest()

static void WaitEventCustomShmemRequest ( void *  arg )

static

Definition at line 111 of file wait_event.c.

{
    ShmemRequestStruct(.name = "WaitEventCustomCounterData",
                       .size = sizeof(WaitEventCustomCounterData),
                       .ptr = (void **) &WaitEventCustomCounter,
        );
    ShmemRequestHash(.name = "WaitEventCustom hash by wait event information",
                     .ptr = &WaitEventCustomHashByInfo,
                     .nelems = WAIT_EVENT_CUSTOM_HASH_SIZE,
                     .hash_info.keysize = sizeof(uint32),
                     .hash_info.entrysize = sizeof(WaitEventCustomEntryByInfo),
                     .hash_flags = HASH_ELEM | HASH_BLOBS,
        );
    ShmemRequestHash(.name = "WaitEventCustom hash by name",
                     .ptr = &WaitEventCustomHashByName,
                     .nelems = WAIT_EVENT_CUSTOM_HASH_SIZE,
    /* key is a NULL-terminated string */
                     .hash_info.keysize = sizeof(char[NAMEDATALEN]),
                     .hash_info.entrysize = sizeof(WaitEventCustomEntryByName),
                     .hash_flags = HASH_ELEM | HASH_STRINGS,
        );
}

References HASH_BLOBS, HASH_ELEM, HASH_STRINGS, HTAB::keysize, name, NAMEDATALEN, ShmemRequestHash, ShmemRequestStruct, WAIT_EVENT_CUSTOM_HASH_SIZE, WaitEventCustomCounter, WaitEventCustomHashByInfo, and WaitEventCustomHashByName.

WaitEventExtensionNew()

uint32 WaitEventExtensionNew

(

const char *

wait_event_name

)

Definition at line 149 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 155 of file wait_event.c.

{
    return WaitEventCustomNew(PG_WAIT_INJECTIONPOINT, wait_event_name);
}

References PG_WAIT_INJECTIONPOINT, and WaitEventCustomNew().

Referenced by injection_wait(), and test_aio_shmem_init().

Variable Documentation

local_my_wait_event_info

uint32 local_my_wait_event_info

static

Definition at line 41 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 42 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(), WaitEventCustomShmemInit(), and WaitEventCustomShmemRequest().

WaitEventCustomHashByInfo

HTAB* WaitEventCustomHashByInfo

static

Definition at line 64 of file wait_event.c.

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

WaitEventCustomHashByName

HTAB* WaitEventCustomHashByName

static

Definition at line 65 of file wait_event.c.

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

WaitEventCustomShmemCallbacks

const ShmemCallbacks WaitEventCustomShmemCallbacks

Initial value:

= {
    .request_fn = WaitEventCustomShmemRequest,
    .init_fn = WaitEventCustomShmemInit,
}

Definition at line 102 of file wait_event.c.

                                                     {
    .request_fn = WaitEventCustomShmemRequest,
    .init_fn = WaitEventCustomShmemInit,
};