#include "lib/ilist.h"
#include "port/pg_iovec.h"
#include "storage/aio.h"
#include "storage/condition_variable.h"

Include dependency graph for aio_internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PgAioHandle

struct	PgAioBackend

struct	PgAioCtl

struct	IoMethodOps

Macros
#define	PGAIO_SUBMIT_BATCH_SIZE 32

#define	PGAIO_VERBOSE 1

#define	pgaio_debug(elevel, msg, ...)

#define	pgaio_debug_io(elevel, ioh, msg, ...)

#define	pgaio_io_call_inj(ioh, injection_point) (void) 0

Typedefs
typedef enum PgAioHandleState	PgAioHandleState

typedef struct PgAioBackend	PgAioBackend

typedef struct PgAioCtl	PgAioCtl

typedef struct IoMethodOps	IoMethodOps

Enumerations
enum	PgAioHandleState { PGAIO_HS_IDLE = 0 , PGAIO_HS_HANDED_OUT , PGAIO_HS_DEFINED , PGAIO_HS_STAGED , PGAIO_HS_SUBMITTED , PGAIO_HS_COMPLETED_IO , PGAIO_HS_COMPLETED_SHARED , PGAIO_HS_COMPLETED_LOCAL }

Functions
bool	pgaio_io_was_recycled (PgAioHandle ioh, uint64 ref_generation, PgAioHandleState state)

void	pgaio_io_stage (PgAioHandle *ioh, PgAioOp op)

void	pgaio_io_process_completion (PgAioHandle *ioh, int result)

void	pgaio_io_prepare_submit (PgAioHandle *ioh)

bool	pgaio_io_needs_synchronous_execution (PgAioHandle *ioh)

const char *	pgaio_io_get_state_name (PgAioHandle *ioh)

const char *	pgaio_result_status_string (PgAioResultStatus rs)

void	pgaio_shutdown (int code, Datum arg)

void	pgaio_io_call_stage (PgAioHandle *ioh)

void	pgaio_io_call_complete_shared (PgAioHandle *ioh)

void	pgaio_io_call_complete_local (PgAioHandle *ioh)

void	pgaio_io_perform_synchronously (PgAioHandle *ioh)

const char *	pgaio_io_get_op_name (PgAioHandle *ioh)

bool	pgaio_io_can_reopen (PgAioHandle *ioh)

void	pgaio_io_reopen (PgAioHandle *ioh)

const char *	pgaio_io_get_target_name (PgAioHandle *ioh)

Variables
PGDLLIMPORT const IoMethodOps	pgaio_sync_ops

PGDLLIMPORT const IoMethodOps	pgaio_worker_ops

PGDLLIMPORT const IoMethodOps *	pgaio_method_ops

PGDLLIMPORT PgAioCtl *	pgaio_ctl

PGDLLIMPORT PgAioBackend *	pgaio_my_backend

Macro Definition Documentation

◆ pgaio_debug

#define pgaio_debug	(	elevel,
		msg,
		...
	)

Value:

    do { \
        if (PGAIO_VERBOSE) \
            ereport(elevel, \
                    errhidestmt(true), errhidecontext(true), \
                    errmsg_internal(msg, \
                                    __VA_ARGS__)); \
    } while(0)

Definition at line 345 of file aio_internal.h.

◆ pgaio_debug_io

#define pgaio_debug_io	(	elevel,
		ioh,
		msg,
		...
	)

Value:

    pgaio_debug(elevel, "io %-10d|op %-5s|target %-4s|state %-16s: " msg, \
                pgaio_io_get_id(ioh), \
                pgaio_io_get_op_name(ioh), \
                pgaio_io_get_target_name(ioh), \
                pgaio_io_get_state_name(ioh), \
                __VA_ARGS__)

Definition at line 358 of file aio_internal.h.

◆ pgaio_io_call_inj

#define pgaio_io_call_inj	(	ioh,
		injection_point
	)	(void) 0

Definition at line 376 of file aio_internal.h.

◆ PGAIO_SUBMIT_BATCH_SIZE

#define PGAIO_SUBMIT_BATCH_SIZE 32

Definition at line 28 of file aio_internal.h.

◆ PGAIO_VERBOSE

#define PGAIO_VERBOSE 1

Definition at line 334 of file aio_internal.h.

Typedef Documentation

◆ IoMethodOps

typedef struct IoMethodOps IoMethodOps

◆ PgAioBackend

typedef struct PgAioBackend PgAioBackend

◆ PgAioCtl

typedef struct PgAioCtl PgAioCtl

◆ PgAioHandleState

typedef enum PgAioHandleState PgAioHandleState

Enumeration Type Documentation

◆ PgAioHandleState

enum PgAioHandleState

Enumerator
PGAIO_HS_IDLE
PGAIO_HS_HANDED_OUT
PGAIO_HS_DEFINED
PGAIO_HS_STAGED
PGAIO_HS_SUBMITTED
PGAIO_HS_COMPLETED_IO
PGAIO_HS_COMPLETED_SHARED
PGAIO_HS_COMPLETED_LOCAL

Definition at line 38 of file aio_internal.h.

{
    /* not in use */
    PGAIO_HS_IDLE = 0,
 
    /*
     * Returned by pgaio_io_acquire(). The next state is either DEFINED (if
     * pgaio_io_prep_*() is called), or IDLE (if pgaio_io_release() is
     * called).
     */
    PGAIO_HS_HANDED_OUT,
 
    /*
     * pgaio_io_prep_*() has been called, but IO is not yet staged. At this
     * point the handle has all the information for the IO to be executed.
     */
    PGAIO_HS_DEFINED,
 
    /*
     * stage() callbacks have been called, handle ready to be submitted for
     * execution. Unless in batchmode (see c.f. pgaio_enter_batchmode()), the
     * IO will be submitted immediately after.
     */
    PGAIO_HS_STAGED,
 
    /* IO has been submitted to the IO method for execution */
    PGAIO_HS_SUBMITTED,
 
    /* IO finished, but result has not yet been processed */
    PGAIO_HS_COMPLETED_IO,
 
    /*
     * IO completed, shared completion has been called.
     *
     * If the IO completion occurs in the issuing backend, local callbacks
     * will immediately be called. Otherwise the handle stays in
     * COMPLETED_SHARED until the issuing backend waits for the completion of
     * the IO.
     */
    PGAIO_HS_COMPLETED_SHARED,
 
    /*
     * IO completed, local completion has been called.
     *
     * After this the handle will be made reusable and go into IDLE state.
     */
    PGAIO_HS_COMPLETED_LOCAL,
} PgAioHandleState;

Function Documentation

◆ pgaio_io_call_complete_local()

void pgaio_io_call_complete_local ( PgAioHandle * ioh )

Definition at line 268 of file aio_callback.c.

{
    PgAioResult result;
 
    START_CRIT_SECTION();
 
    Assert(ioh->target > PGAIO_TID_INVALID && ioh->target < PGAIO_TID_COUNT);
    Assert(ioh->op > PGAIO_OP_INVALID && ioh->op < PGAIO_OP_COUNT);
 
    /* start with distilled result from shared callback */
    result = ioh->distilled_result;
 
    for (int i = ioh->num_callbacks; i > 0; i--)
    {
        PgAioHandleCallbackID cb_id = ioh->callbacks[i - 1];
        uint8       cb_data = ioh->callbacks_data[i - 1];
        const PgAioHandleCallbacksEntry *ce = &aio_handle_cbs[cb_id];
 
        if (!ce->cb->complete_local)
            continue;
 
        pgaio_debug_io(DEBUG4, ioh,
                       "calling cb #%d, id %d/%s->complete_local(%u) with distilled result: status %s, id %u, error_data %d, result %d",
                       i, cb_id, ce->name, cb_data,
                       pgaio_result_status_string(result.status),
                       result.id, result.error_data, result.result);
        result = ce->cb->complete_local(ioh, result, cb_data);
    }
 
    /*
     * Note that we don't save the result in ioh->distilled_result, the local
     * callback's result should not ever matter to other waiters.
     */
    pgaio_debug_io(DEBUG3, ioh,
                   "after local completion: distilled result: (status %s, id %u, error_data %d, result %d), raw_result: %d",
                   pgaio_result_status_string(result.status),
                   result.id, result.error_data, result.result,
                   ioh->result);
 
    END_CRIT_SECTION();
}

References aio_handle_cbs, Assert(), PgAioHandle::callbacks, PgAioHandle::callbacks_data, PgAioHandleCallbacksEntry::cb, PgAioHandleCallbacks::complete_local, DEBUG3, DEBUG4, PgAioHandle::distilled_result, END_CRIT_SECTION, PgAioResult::error_data, i, PgAioResult::id, PgAioHandleCallbacksEntry::name, PgAioHandle::num_callbacks, PgAioHandle::op, pgaio_debug_io, PGAIO_OP_COUNT, PGAIO_OP_INVALID, pgaio_result_status_string(), PGAIO_TID_COUNT, PGAIO_TID_INVALID, PgAioHandle::result, PgAioResult::result, START_CRIT_SECTION, PgAioResult::status, and PgAioHandle::target.

Referenced by pgaio_io_reclaim().

◆ pgaio_io_call_complete_shared()

void pgaio_io_call_complete_shared ( PgAioHandle * ioh )

Definition at line 214 of file aio_callback.c.

{
    PgAioResult result;
 
    START_CRIT_SECTION();
 
    Assert(ioh->target > PGAIO_TID_INVALID && ioh->target < PGAIO_TID_COUNT);
    Assert(ioh->op > PGAIO_OP_INVALID && ioh->op < PGAIO_OP_COUNT);
 
    result.status = PGAIO_RS_OK;    /* low level IO is always considered OK */
    result.result = ioh->result;
    result.id = PGAIO_HCB_INVALID;
    result.error_data = 0;
 
    /*
     * Call callbacks with the last registered (innermost) callback first.
     * Each callback can modify the result forwarded to the next callback.
     */
    for (int i = ioh->num_callbacks; i > 0; i--)
    {
        PgAioHandleCallbackID cb_id = ioh->callbacks[i - 1];
        uint8       cb_data = ioh->callbacks_data[i - 1];
        const PgAioHandleCallbacksEntry *ce = &aio_handle_cbs[cb_id];
 
        if (!ce->cb->complete_shared)
            continue;
 
        pgaio_debug_io(DEBUG4, ioh,
                       "calling cb #%d, id %d/%s->complete_shared(%u) with distilled result: (status %s, id %u, error_data %d, result %d)",
                       i, cb_id, ce->name,
                       cb_data,
                       pgaio_result_status_string(result.status),
                       result.id, result.error_data, result.result);
        result = ce->cb->complete_shared(ioh, result, cb_data);
    }
 
    ioh->distilled_result = result;
 
    pgaio_debug_io(DEBUG3, ioh,
                   "after shared completion: distilled result: (status %s, id %u, error_data: %d, result %d), raw_result: %d",
                   pgaio_result_status_string(result.status),
                   result.id, result.error_data, result.result,
                   ioh->result);
 
    END_CRIT_SECTION();
}

References aio_handle_cbs, Assert(), PgAioHandle::callbacks, PgAioHandle::callbacks_data, PgAioHandleCallbacksEntry::cb, PgAioHandleCallbacks::complete_shared, DEBUG3, DEBUG4, PgAioHandle::distilled_result, END_CRIT_SECTION, PgAioResult::error_data, i, PgAioResult::id, PgAioHandleCallbacksEntry::name, PgAioHandle::num_callbacks, PgAioHandle::op, pgaio_debug_io, PGAIO_HCB_INVALID, PGAIO_OP_COUNT, PGAIO_OP_INVALID, pgaio_result_status_string(), PGAIO_RS_OK, PGAIO_TID_COUNT, PGAIO_TID_INVALID, PgAioHandle::result, PgAioResult::result, START_CRIT_SECTION, PgAioResult::status, and PgAioHandle::target.

Referenced by pgaio_io_process_completion().

◆ pgaio_io_call_stage()

void pgaio_io_call_stage ( PgAioHandle * ioh )

Definition at line 188 of file aio_callback.c.

{
    Assert(ioh->target > PGAIO_TID_INVALID && ioh->target < PGAIO_TID_COUNT);
    Assert(ioh->op > PGAIO_OP_INVALID && ioh->op < PGAIO_OP_COUNT);
 
    for (int i = ioh->num_callbacks; i > 0; i--)
    {
        PgAioHandleCallbackID cb_id = ioh->callbacks[i - 1];
        uint8       cb_data = ioh->callbacks_data[i - 1];
        const PgAioHandleCallbacksEntry *ce = &aio_handle_cbs[cb_id];
 
        if (!ce->cb->stage)
            continue;
 
        pgaio_debug_io(DEBUG3, ioh,
                       "calling cb #%d %d/%s->stage(%u)",
                       i, cb_id, ce->name, cb_data);
        ce->cb->stage(ioh, cb_data);
    }
}

References aio_handle_cbs, Assert(), PgAioHandle::callbacks, PgAioHandle::callbacks_data, PgAioHandleCallbacksEntry::cb, DEBUG3, i, PgAioHandleCallbacksEntry::name, PgAioHandle::num_callbacks, PgAioHandle::op, pgaio_debug_io, PGAIO_OP_COUNT, PGAIO_OP_INVALID, PGAIO_TID_COUNT, PGAIO_TID_INVALID, PgAioHandleCallbacks::stage, and PgAioHandle::target.

Referenced by pgaio_io_stage().

◆ pgaio_io_can_reopen()

bool pgaio_io_can_reopen ( PgAioHandle * ioh )

Definition at line 97 of file aio_target.c.

{
    return pgaio_target_info[ioh->target]->reopen != NULL;
}

References pgaio_target_info, PgAioTargetInfo::reopen, and PgAioHandle::target.

Referenced by pgaio_worker_needs_synchronous_execution().

◆ pgaio_io_get_op_name()

const char * pgaio_io_get_op_name ( PgAioHandle * ioh )

Definition at line 169 of file aio_io.c.

{
    Assert(ioh->op >= 0 && ioh->op < PGAIO_OP_COUNT);
 
    switch (ioh->op)
    {
        case PGAIO_OP_INVALID:
            return "invalid";
        case PGAIO_OP_READV:
            return "read";
        case PGAIO_OP_WRITEV:
            return "write";
    }
 
    return NULL;                /* silence compiler */
}

References Assert(), PgAioHandle::op, PGAIO_OP_COUNT, PGAIO_OP_INVALID, PGAIO_OP_READV, and PGAIO_OP_WRITEV.

◆ pgaio_io_get_state_name()

const char * pgaio_io_get_state_name ( PgAioHandle * ioh )

Definition at line 822 of file aio.c.

{
    return pgaio_io_state_get_name(ioh->state);
}

References pgaio_io_state_get_name(), and PgAioHandle::state.

◆ pgaio_io_get_target_name()

const char * pgaio_io_get_target_name ( PgAioHandle * ioh )

Definition at line 48 of file aio_target.c.

{
    Assert(ioh->target >= 0 && ioh->target < PGAIO_TID_COUNT);
 
    return pgaio_target_info[ioh->target]->name;
}

References Assert(), PgAioTargetInfo::name, pgaio_target_info, PGAIO_TID_COUNT, and PgAioHandle::target.

◆ pgaio_io_needs_synchronous_execution()

bool pgaio_io_needs_synchronous_execution ( PgAioHandle * ioh )

Definition at line 447 of file aio.c.

{
    /*
     * If the caller said to execute the IO synchronously, do so.
     *
     * XXX: We could optimize the logic when to execute synchronously by first
     * checking if there are other IOs in flight and only synchronously
     * executing if not. Unclear whether that'll be sufficiently common to be
     * worth worrying about.
     */
    if (ioh->flags & PGAIO_HF_SYNCHRONOUS)
        return true;
 
    /* Check if the IO method requires synchronous execution of IO */
    if (pgaio_method_ops->needs_synchronous_execution)
        return pgaio_method_ops->needs_synchronous_execution(ioh);
 
    return false;
}

References PgAioHandle::flags, IoMethodOps::needs_synchronous_execution, PGAIO_HF_SYNCHRONOUS, and pgaio_method_ops.

Referenced by pgaio_io_stage().

◆ pgaio_io_perform_synchronously()

void pgaio_io_perform_synchronously ( PgAioHandle * ioh )

Definition at line 116 of file aio_io.c.

{
    ssize_t     result = 0;
    struct iovec *iov = &pgaio_ctl->iovecs[ioh->iovec_off];
 
    START_CRIT_SECTION();
 
    /* Perform IO. */
    switch (ioh->op)
    {
        case PGAIO_OP_READV:
            pgstat_report_wait_start(WAIT_EVENT_DATA_FILE_READ);
            result = pg_preadv(ioh->op_data.read.fd, iov,
                               ioh->op_data.read.iov_length,
                               ioh->op_data.read.offset);
            pgstat_report_wait_end();
            break;
        case PGAIO_OP_WRITEV:
            pgstat_report_wait_start(WAIT_EVENT_DATA_FILE_WRITE);
            result = pg_pwritev(ioh->op_data.write.fd, iov,
                                ioh->op_data.write.iov_length,
                                ioh->op_data.write.offset);
            pgstat_report_wait_end();
            break;
        case PGAIO_OP_INVALID:
            elog(ERROR, "trying to execute invalid IO operation");
    }
 
    ioh->result = result < 0 ? -errno : result;
 
    pgaio_io_process_completion(ioh, ioh->result);
 
    END_CRIT_SECTION();
}

References elog, END_CRIT_SECTION, ERROR, PgAioOpData::fd, PgAioOpData::iov_length, PgAioHandle::iovec_off, PgAioCtl::iovecs, PgAioOpData::offset, PgAioHandle::op, PgAioHandle::op_data, pg_preadv(), pg_pwritev(), pgaio_ctl, pgaio_io_process_completion(), PGAIO_OP_INVALID, PGAIO_OP_READV, PGAIO_OP_WRITEV, pgstat_report_wait_end(), pgstat_report_wait_start(), PgAioOpData::read, PgAioHandle::result, START_CRIT_SECTION, and PgAioOpData::write.

Referenced by IoWorkerMain(), pgaio_io_stage(), and pgaio_worker_submit_internal().

◆ pgaio_io_prepare_submit()

void pgaio_io_prepare_submit ( PgAioHandle * ioh )

Definition at line 474 of file aio.c.

{
    pgaio_io_update_state(ioh, PGAIO_HS_SUBMITTED);
 
    dclist_push_tail(&pgaio_my_backend->in_flight_ios, &ioh->node);
}

References dclist_push_tail(), PgAioBackend::in_flight_ios, PgAioHandle::node, PGAIO_HS_SUBMITTED, pgaio_io_update_state(), and pgaio_my_backend.

Referenced by pgaio_io_stage(), and pgaio_worker_submit().

◆ pgaio_io_process_completion()

void pgaio_io_process_completion	(	PgAioHandle *	ioh,
		int	result
	)

Definition at line 492 of file aio.c.

{
    Assert(ioh->state == PGAIO_HS_SUBMITTED);
 
    Assert(CritSectionCount > 0);
 
    ioh->result = result;
 
    pgaio_io_update_state(ioh, PGAIO_HS_COMPLETED_IO);
 
    pgaio_io_call_inj(ioh, "AIO_PROCESS_COMPLETION_BEFORE_SHARED");
 
    pgaio_io_call_complete_shared(ioh);
 
    pgaio_io_update_state(ioh, PGAIO_HS_COMPLETED_SHARED);
 
    /* condition variable broadcast ensures state is visible before wakeup */
    ConditionVariableBroadcast(&ioh->cv);
 
    /* contains call to pgaio_io_call_complete_local() */
    if (ioh->owner_procno == MyProcNumber)
        pgaio_io_reclaim(ioh);
}

References Assert(), ConditionVariableBroadcast(), CritSectionCount, PgAioHandle::cv, MyProcNumber, PgAioHandle::owner_procno, PGAIO_HS_COMPLETED_IO, PGAIO_HS_COMPLETED_SHARED, PGAIO_HS_SUBMITTED, pgaio_io_call_complete_shared(), pgaio_io_call_inj, pgaio_io_reclaim(), pgaio_io_update_state(), PgAioHandle::result, and PgAioHandle::state.

Referenced by IoWorkerMain(), and pgaio_io_perform_synchronously().

◆ pgaio_io_reopen()

void pgaio_io_reopen ( PgAioHandle * ioh )

Definition at line 108 of file aio_target.c.

{
    Assert(ioh->target >= 0 && ioh->target < PGAIO_TID_COUNT);
    Assert(ioh->op >= 0 && ioh->op < PGAIO_OP_COUNT);
 
    pgaio_target_info[ioh->target]->reopen(ioh);
}

References Assert(), PgAioHandle::op, PGAIO_OP_COUNT, pgaio_target_info, PGAIO_TID_COUNT, PgAioTargetInfo::reopen, and PgAioHandle::target.

Referenced by IoWorkerMain().

◆ pgaio_io_stage()

void pgaio_io_stage	(	PgAioHandle *	ioh,
		PgAioOp	op
	)

Definition at line 397 of file aio.c.

{
    bool        needs_synchronous;
 
    Assert(ioh->state == PGAIO_HS_HANDED_OUT);
    Assert(pgaio_my_backend->handed_out_io == ioh);
    Assert(pgaio_io_has_target(ioh));
 
    ioh->op = op;
    ioh->result = 0;
 
    pgaio_io_update_state(ioh, PGAIO_HS_DEFINED);
 
    /* allow a new IO to be staged */
    pgaio_my_backend->handed_out_io = NULL;
 
    pgaio_io_call_stage(ioh);
 
    pgaio_io_update_state(ioh, PGAIO_HS_STAGED);
 
    /*
     * Synchronous execution has to be executed, well, synchronously, so check
     * that first.
     */
    needs_synchronous = pgaio_io_needs_synchronous_execution(ioh);
 
    pgaio_debug_io(DEBUG3, ioh,
                   "prepared (synchronous: %d, in_batch: %d)",
                   needs_synchronous, pgaio_my_backend->in_batchmode);
 
    if (!needs_synchronous)
    {
        pgaio_my_backend->staged_ios[pgaio_my_backend->num_staged_ios++] = ioh;
        Assert(pgaio_my_backend->num_staged_ios <= PGAIO_SUBMIT_BATCH_SIZE);
 
        /*
         * Unless code explicitly opted into batching IOs, submit the IO
         * immediately.
         */
        if (!pgaio_my_backend->in_batchmode)
            pgaio_submit_staged();
    }
    else
    {
        pgaio_io_prepare_submit(ioh);
        pgaio_io_perform_synchronously(ioh);
    }
}

References Assert(), DEBUG3, PgAioBackend::handed_out_io, PgAioBackend::in_batchmode, PgAioBackend::num_staged_ios, PgAioHandle::op, pgaio_debug_io, PGAIO_HS_DEFINED, PGAIO_HS_HANDED_OUT, PGAIO_HS_STAGED, pgaio_io_call_stage(), pgaio_io_has_target(), pgaio_io_needs_synchronous_execution(), pgaio_io_perform_synchronously(), pgaio_io_prepare_submit(), pgaio_io_update_state(), pgaio_my_backend, PGAIO_SUBMIT_BATCH_SIZE, pgaio_submit_staged(), PgAioHandle::result, PgAioBackend::staged_ios, and PgAioHandle::state.

Referenced by pgaio_io_prep_readv(), and pgaio_io_prep_writev().

◆ pgaio_io_was_recycled()

bool pgaio_io_was_recycled	(	PgAioHandle *	ioh,
		uint64	ref_generation,
		PgAioHandleState *	state
	)

Definition at line 523 of file aio.c.

{
    *state = ioh->state;
    pg_read_barrier();
 
    return ioh->generation != ref_generation;
}

References PgAioHandle::generation, pg_read_barrier, and PgAioHandle::state.

Referenced by pgaio_io_wait(), and pgaio_wref_check_done().

◆ pgaio_result_status_string()

const char * pgaio_result_status_string ( PgAioResultStatus rs )

Definition at line 828 of file aio.c.

{
    switch (rs)
    {
        case PGAIO_RS_UNKNOWN:
            return "UNKNOWN";
        case PGAIO_RS_OK:
            return "OK";
        case PGAIO_RS_PARTIAL:
            return "PARTIAL";
        case PGAIO_RS_ERROR:
            return "ERROR";
    }
 
    return NULL;                /* silence compiler */
}

References PGAIO_RS_ERROR, PGAIO_RS_OK, PGAIO_RS_PARTIAL, and PGAIO_RS_UNKNOWN.

Referenced by pgaio_io_call_complete_local(), pgaio_io_call_complete_shared(), and pgaio_io_reclaim().

◆ pgaio_shutdown()

void pgaio_shutdown	(	int	code,
		Datum	arg
	)

Definition at line 1127 of file aio.c.

{
    Assert(pgaio_my_backend);
    Assert(!pgaio_my_backend->handed_out_io);
 
    /* first clean up resources as we would at a transaction boundary */
    AtEOXact_Aio(code == 0);
 
    /*
     * Before exiting, make sure that all IOs are finished. That has two main
     * purposes:
     *
     * - Some kernel-level AIO mechanisms don't deal well with the issuer of
     * an AIO exiting before IO completed
     *
     * - It'd be confusing to see partially finished IOs in stats views etc
     */
    while (!dclist_is_empty(&pgaio_my_backend->in_flight_ios))
    {
        PgAioHandle *ioh = dclist_head_element(PgAioHandle, node, &pgaio_my_backend->in_flight_ios);
 
        /* see comment in pgaio_io_wait_for_free() about raciness */
        pgaio_io_wait(ioh, ioh->generation);
    }
 
    pgaio_my_backend = NULL;
}

References Assert(), AtEOXact_Aio(), dclist_head_element, dclist_is_empty(), PgAioHandle::generation, PgAioBackend::handed_out_io, PgAioBackend::in_flight_ios, pgaio_io_wait(), and pgaio_my_backend.

Referenced by pgaio_init_backend().

Variable Documentation

◆ pgaio_ctl

PGDLLIMPORT PgAioCtl* pgaio_ctl

extern

Definition at line 76 of file aio.c.

Referenced by AioShmemInit(), IoWorkerMain(), pgaio_init_backend(), pgaio_io_from_wref(), pgaio_io_get_handle_data(), pgaio_io_get_id(), pgaio_io_get_iovec(), pgaio_io_get_wref(), pgaio_io_perform_synchronously(), pgaio_io_set_handle_data_32(), pgaio_io_set_handle_data_64(), and pgaio_io_wait_for_free().

◆ pgaio_method_ops

PGDLLIMPORT const IoMethodOps* pgaio_method_ops

extern

Definition at line 88 of file aio.c.

Referenced by AioShmemInit(), AioShmemSize(), assign_io_method(), pgaio_init_backend(), pgaio_io_needs_synchronous_execution(), pgaio_io_wait(), and pgaio_submit_staged().

◆ pgaio_my_backend

PGDLLIMPORT PgAioBackend* pgaio_my_backend

extern

Definition at line 79 of file aio.c.

Referenced by AtEOXact_Aio(), pgaio_closing_fd(), pgaio_enter_batchmode(), pgaio_error_cleanup(), pgaio_exit_batchmode(), pgaio_have_staged(), pgaio_init_backend(), pgaio_io_acquire_nb(), pgaio_io_before_prep(), pgaio_io_prepare_submit(), pgaio_io_reclaim(), pgaio_io_release(), pgaio_io_release_resowner(), pgaio_io_stage(), pgaio_io_wait_for_free(), pgaio_shutdown(), and pgaio_submit_staged().

◆ pgaio_sync_ops

PGDLLIMPORT const IoMethodOps pgaio_sync_ops

extern

Definition at line 28 of file method_sync.c.

◆ pgaio_worker_ops

PGDLLIMPORT const IoMethodOps pgaio_worker_ops

extern

Definition at line 82 of file method_worker.c.

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ pgaio_debug

◆ pgaio_debug_io

◆ pgaio_io_call_inj

◆ PGAIO_SUBMIT_BATCH_SIZE

◆ PGAIO_VERBOSE

Typedef Documentation

◆ IoMethodOps

◆ PgAioBackend

◆ PgAioCtl

◆ PgAioHandleState

Enumeration Type Documentation

◆ PgAioHandleState

Function Documentation

◆ pgaio_io_call_complete_local()

◆ pgaio_io_call_complete_shared()

◆ pgaio_io_call_stage()

◆ pgaio_io_can_reopen()

◆ pgaio_io_get_op_name()

◆ pgaio_io_get_state_name()

◆ pgaio_io_get_target_name()

◆ pgaio_io_needs_synchronous_execution()

◆ pgaio_io_perform_synchronously()

◆ pgaio_io_prepare_submit()

◆ pgaio_io_process_completion()

◆ pgaio_io_reopen()

◆ pgaio_io_stage()

◆ pgaio_io_was_recycled()

◆ pgaio_result_status_string()

◆ pgaio_shutdown()

Variable Documentation

◆ pgaio_ctl

◆ pgaio_method_ops

◆ pgaio_my_backend

◆ pgaio_sync_ops

◆ pgaio_worker_ops