waitfuncs.c File Reference

#include "postgres.h"
#include "catalog/pg_type.h"
#include "storage/predicate_internals.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/wait_event.h"

Include dependency graph for waitfuncs.c:

Go to the source code of this file.

Macros
#define	UINT32_ACCESS_ONCE(var)   ((uint32)(*((volatile uint32 *)&(var))))

Functions
Datum	pg_isolation_test_session_is_blocked (PG_FUNCTION_ARGS)

Macro Definition Documentation

UINT32_ACCESS_ONCE

#define UINT32_ACCESS_ONCE

(

var

)

((uint32)(*((volatile uint32 *)&(var))))

Definition at line 23 of file waitfuncs.c.

Function Documentation

pg_isolation_test_session_is_blocked()

Datum pg_isolation_test_session_is_blocked

(

PG_FUNCTION_ARGS

)

Definition at line 39 of file waitfuncs.c.

{
    int         blocked_pid = PG_GETARG_INT32(0);
    ArrayType  *interesting_pids_a = PG_GETARG_ARRAYTYPE_P(1);
    PGPROC     *proc;
    const char *wait_event_type;
    ArrayType  *blocking_pids_a;
    int32      *interesting_pids;
    int32      *blocking_pids;
    int         num_interesting_pids;
    int         num_blocking_pids;
    int         dummy;
    int         i,
                j;
 
    /* Check if blocked_pid is in an injection point. */
    proc = BackendPidGetProc(blocked_pid);
    if (proc == NULL)
        PG_RETURN_BOOL(false);  /* session gone: definitely unblocked */
    wait_event_type =
        pgstat_get_wait_event_type(UINT32_ACCESS_ONCE(proc->wait_event_info));
    if (wait_event_type && strcmp("InjectionPoint", wait_event_type) == 0)
        PG_RETURN_BOOL(true);
 
    /* Validate the passed-in array */
    Assert(ARR_ELEMTYPE(interesting_pids_a) == INT4OID);
    if (array_contains_nulls(interesting_pids_a))
        elog(ERROR, "array must not contain nulls");
    interesting_pids = (int32 *) ARR_DATA_PTR(interesting_pids_a);
    num_interesting_pids = ArrayGetNItems(ARR_NDIM(interesting_pids_a),
                                          ARR_DIMS(interesting_pids_a));
 
    /*
     * Get the PIDs of all sessions blocking the given session's attempt to
     * acquire heavyweight locks.
     */
    blocking_pids_a =
        DatumGetArrayTypeP(DirectFunctionCall1(pg_blocking_pids, blocked_pid));
 
    Assert(ARR_ELEMTYPE(blocking_pids_a) == INT4OID);
    Assert(!array_contains_nulls(blocking_pids_a));
    blocking_pids = (int32 *) ARR_DATA_PTR(blocking_pids_a);
    num_blocking_pids = ArrayGetNItems(ARR_NDIM(blocking_pids_a),
                                       ARR_DIMS(blocking_pids_a));
 
    /*
     * Check if any of these are in the list of interesting PIDs, that being
     * the sessions that the isolation tester is running.  We don't use
     * "arrayoverlaps" here, because it would lead to cache lookups and one of
     * our goals is to run quickly with debug_discard_caches > 0.  We expect
     * blocking_pids to be usually empty and otherwise a very small number in
     * isolation tester cases, so make that the outer loop of a naive search
     * for a match.
     */
    for (i = 0; i < num_blocking_pids; i++)
        for (j = 0; j < num_interesting_pids; j++)
        {
            if (blocking_pids[i] == interesting_pids[j])
                PG_RETURN_BOOL(true);
        }
 
    /*
     * Check if blocked_pid is waiting for a safe snapshot.  We could in
     * theory check the resulting array of blocker PIDs against the
     * interesting PIDs list, but since there is no danger of autovacuum
     * blocking GetSafeSnapshot there seems to be no point in expending cycles
     * on allocating a buffer and searching for overlap; so it's presently
     * sufficient for the isolation tester's purposes to use a single element
     * buffer and check if the number of safe snapshot blockers is non-zero.
     */
    if (GetSafeSnapshotBlockingPids(blocked_pid, &dummy, 1) > 0)
        PG_RETURN_BOOL(true);
 
    PG_RETURN_BOOL(false);
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, array_contains_nulls(), ArrayGetNItems(), Assert, BackendPidGetProc(), DatumGetArrayTypeP, DirectFunctionCall1, elog, ERROR, GetSafeSnapshotBlockingPids(), i, j, pg_blocking_pids(), PG_GETARG_ARRAYTYPE_P, PG_GETARG_INT32, PG_RETURN_BOOL, pgstat_get_wait_event_type(), UINT32_ACCESS_ONCE, and PGPROC::wait_event_info.