aio.c File Reference

#include "postgres.h"
#include "lib/ilist.h"
#include "miscadmin.h"
#include "port/atomics.h"
#include "storage/aio.h"
#include "storage/aio_internal.h"
#include "storage/aio_subsys.h"
#include "utils/guc.h"
#include "utils/guc_hooks.h"
#include "utils/injection_point.h"
#include "utils/resowner.h"
#include "utils/wait_event_types.h"

Include dependency graph for aio.c:

Go to the source code of this file.

Macros
#define	PGAIO_HS_TOSTR_CASE(sym)   case PGAIO_HS_##sym: return #sym

Functions
static void	pgaio_io_update_state (PgAioHandle *ioh, PgAioHandleState new_state)
static void	pgaio_io_reclaim (PgAioHandle *ioh)
static void	pgaio_io_resowner_register (PgAioHandle *ioh, struct ResourceOwnerData *resowner)
static void	pgaio_io_wait_for_free (void)
static PgAioHandle *	pgaio_io_from_wref (PgAioWaitRef *iow, uint64 *ref_generation)
static const char *	pgaio_io_state_get_name (PgAioHandleState s)
static void	pgaio_io_wait (PgAioHandle *ioh, uint64 ref_generation)
	StaticAssertDecl (lengthof(io_method_options)==lengthof(pgaio_method_ops_table)+1, "io_method_options out of sync with pgaio_method_ops_table")
PgAioHandle *	pgaio_io_acquire (struct ResourceOwnerData *resowner, PgAioReturn *ret)
PgAioHandle *	pgaio_io_acquire_nb (struct ResourceOwnerData *resowner, PgAioReturn *ret)
void	pgaio_io_release (PgAioHandle *ioh)
void	pgaio_io_release_resowner (dlist_node *ioh_node, bool on_error)
void	pgaio_io_set_flag (PgAioHandle *ioh, PgAioHandleFlags flag)
int	pgaio_io_get_id (PgAioHandle *ioh)
ProcNumber	pgaio_io_get_owner (PgAioHandle *ioh)
void	pgaio_io_get_wref (PgAioHandle *ioh, PgAioWaitRef *iow)
void	pgaio_io_stage (PgAioHandle *ioh, PgAioOp op)
bool	pgaio_io_needs_synchronous_execution (PgAioHandle *ioh)
void	pgaio_io_prepare_submit (PgAioHandle *ioh)
void	pgaio_io_process_completion (PgAioHandle *ioh, int result)
bool	pgaio_io_was_recycled (PgAioHandle *ioh, uint64 ref_generation, PgAioHandleState *state)
const char *	pgaio_io_get_state_name (PgAioHandle *ioh)
const char *	pgaio_result_status_string (PgAioResultStatus rs)
void	pgaio_wref_clear (PgAioWaitRef *iow)
bool	pgaio_wref_valid (PgAioWaitRef *iow)
int	pgaio_wref_get_id (PgAioWaitRef *iow)
void	pgaio_wref_wait (PgAioWaitRef *iow)
bool	pgaio_wref_check_done (PgAioWaitRef *iow)
void	pgaio_enter_batchmode (void)
void	pgaio_exit_batchmode (void)
bool	pgaio_have_staged (void)
void	pgaio_submit_staged (void)
void	pgaio_error_cleanup (void)
void	AtEOXact_Aio (bool is_commit)
void	pgaio_closing_fd (int fd)
void	pgaio_shutdown (int code, Datum arg)
void	assign_io_method (int newval, void *extra)
bool	check_io_max_concurrency (int *newval, void **extra, GucSource source)

Variables
const struct config_enum_entry	io_method_options []
int	io_method = DEFAULT_IO_METHOD
int	io_max_concurrency = -1
PgAioCtl *	pgaio_ctl
PgAioBackend *	pgaio_my_backend
static const IoMethodOps *const	pgaio_method_ops_table []
const IoMethodOps *	pgaio_method_ops

Macro Definition Documentation

PGAIO_HS_TOSTR_CASE

#define PGAIO_HS_TOSTR_CASE

(

sym

)

case PGAIO_HS_##sym: return #sym

Function Documentation

assign_io_method()

void assign_io_method	(	int	newval,
		void *	extra
	)

Definition at line 1322 of file aio.c.

{
    Assert(newval < lengthof(pgaio_method_ops_table));
    Assert(pgaio_method_ops_table[newval] != NULL);
 
    pgaio_method_ops = pgaio_method_ops_table[newval];
}

References Assert, fb(), lengthof, newval, pgaio_method_ops, and pgaio_method_ops_table.

AtEOXact_Aio()

void AtEOXact_Aio

(

bool

is_commit

)

Definition at line 1193 of file aio.c.

{
    /*
     * We should never be in batch mode at transactional boundaries. In case
     * an error was thrown while in batch mode, pgaio_error_cleanup() should
     * have exited batchmode.
     *
     * In case we are in batchmode somehow, make sure to submit all staged
     * IOs, other backends may need them to complete to continue.
     */
    if (pgaio_my_backend->in_batchmode)
    {
        pgaio_error_cleanup();
        elog(WARNING, "open AIO batch at end of (sub-)transaction");
    }
 
    /*
     * As we aren't in batchmode, there shouldn't be any unsubmitted IOs.
     */
    Assert(pgaio_my_backend->num_staged_ios == 0);
}

References Assert, elog, PgAioBackend::in_batchmode, PgAioBackend::num_staged_ios, pgaio_error_cleanup(), pgaio_my_backend, and WARNING.

Referenced by AbortSubTransaction(), AbortTransaction(), CommitTransaction(), pgaio_shutdown(), and PrepareTransaction().

check_io_max_concurrency()

bool check_io_max_concurrency	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 1331 of file aio.c.

{
    if (*newval == -1)
    {
        /*
         * Auto-tuning will be applied later during startup, as auto-tuning
         * depends on the value of various GUCs.
         */
        return true;
    }
    else if (*newval == 0)
    {
        GUC_check_errdetail("Only -1 or values bigger than 0 are valid.");
        return false;
    }
 
    return true;
}

References GUC_check_errdetail, and newval.

pgaio_closing_fd()

void pgaio_closing_fd

(

int

fd

)

Definition at line 1220 of file aio.c.

{
    /*
     * Might be called before AIO is initialized or in a subprocess that
     * doesn't use AIO.
     */
    if (!pgaio_my_backend)
        return;
 
    /*
     * For now just submit all staged IOs - we could be more selective, but
     * it's probably not worth it.
     */
    if (pgaio_my_backend->num_staged_ios > 0)
    {
        pgaio_debug(DEBUG2,
                    "submitting %d IOs before FD %d gets closed",
                    pgaio_my_backend->num_staged_ios, fd);
        pgaio_submit_staged();
    }
 
    /*
     * If requested by the IO method, wait for all IOs that use the
     * to-be-closed FD.
     */
    if (pgaio_method_ops->wait_on_fd_before_close)
    {
        /*
         * As waiting for one IO to complete may complete multiple IOs, we
         * can't just use a mutable list iterator. The maximum number of
         * in-flight IOs is fairly small, so just restart the loop after
         * waiting for an IO.
         */
        while (!dclist_is_empty(&pgaio_my_backend->in_flight_ios))
        {
            dlist_iter  iter;
            PgAioHandle *ioh = NULL;
            uint64      generation;
 
            dclist_foreach(iter, &pgaio_my_backend->in_flight_ios)
            {
                ioh = dclist_container(PgAioHandle, node, iter.cur);
 
                generation = ioh->generation;
 
                if (pgaio_io_uses_fd(ioh, fd))
                    break;
                else
                    ioh = NULL;
            }
 
            if (!ioh)
                break;
 
            pgaio_debug_io(DEBUG2, ioh,
                           "waiting for IO before FD %d gets closed, %u in-flight IOs",
                           fd, dclist_count(&pgaio_my_backend->in_flight_ios));
 
            /* see comment in pgaio_io_wait_for_free() about raciness */
            pgaio_io_wait(ioh, generation);
        }
    }
}

References dlist_iter::cur, dclist_container, dclist_count(), dclist_foreach, dclist_is_empty(), DEBUG2, fb(), fd(), PgAioBackend::in_flight_ios, PgAioBackend::num_staged_ios, pgaio_debug, pgaio_debug_io, pgaio_io_uses_fd(), pgaio_io_wait(), pgaio_method_ops, pgaio_my_backend, pgaio_submit_staged(), and IoMethodOps::wait_on_fd_before_close.

Referenced by CloseTransientFile(), FileClose(), FreeDesc(), and LruDelete().

pgaio_enter_batchmode()

void pgaio_enter_batchmode

(

void

)

Definition at line 1081 of file aio.c.

{
    if (pgaio_my_backend->in_batchmode)
        elog(ERROR, "starting batch while batch already in progress");
    pgaio_my_backend->in_batchmode = true;
}

References elog, ERROR, PgAioBackend::in_batchmode, and pgaio_my_backend.

Referenced by batch_start(), read_rel_block_ll(), and read_stream_look_ahead().

pgaio_error_cleanup()

void pgaio_error_cleanup

(

void

)

Definition at line 1165 of file aio.c.

{
    /*
     * It is possible that code errored out after pgaio_enter_batchmode() but
     * before pgaio_exit_batchmode() was called. In that case we need to
     * submit the IO now.
     */
    if (pgaio_my_backend->in_batchmode)
    {
        pgaio_my_backend->in_batchmode = false;
 
        pgaio_submit_staged();
    }
 
    /*
     * As we aren't in batchmode, there shouldn't be any unsubmitted IOs.
     */
    Assert(pgaio_my_backend->num_staged_ios == 0);
}

References Assert, PgAioBackend::in_batchmode, PgAioBackend::num_staged_ios, pgaio_my_backend, and pgaio_submit_staged().

Referenced by AbortSubTransaction(), AbortTransaction(), AtEOXact_Aio(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), pgarch_archiveXlog(), WalSndErrorCleanup(), WalSummarizerMain(), and WalWriterMain().

pgaio_exit_batchmode()

void pgaio_exit_batchmode

(

void

)

Definition at line 1092 of file aio.c.

{
    Assert(pgaio_my_backend->in_batchmode);
 
    pgaio_submit_staged();
    pgaio_my_backend->in_batchmode = false;
}

References Assert, PgAioBackend::in_batchmode, pgaio_my_backend, and pgaio_submit_staged().

Referenced by batch_end(), read_rel_block_ll(), and read_stream_look_ahead().

pgaio_have_staged()

bool pgaio_have_staged

(

void

)

Definition at line 1107 of file aio.c.

{
    Assert(pgaio_my_backend->in_batchmode ||
           pgaio_my_backend->num_staged_ios == 0);
    return pgaio_my_backend->num_staged_ios > 0;
}

References Assert, PgAioBackend::in_batchmode, PgAioBackend::num_staged_ios, and pgaio_my_backend.

Referenced by ReadBuffersCanStartIO().

pgaio_io_acquire()

PgAioHandle * pgaio_io_acquire	(	struct ResourceOwnerData *	resowner,
		PgAioReturn *	ret
	)

Definition at line 162 of file aio.c.

{
    PgAioHandle *h;
 
    while (true)
    {
        h = pgaio_io_acquire_nb(resowner, ret);
 
        if (h != NULL)
            return h;
 
        /*
         * Evidently all handles by this backend are in use. Just wait for
         * some to complete.
         */
        pgaio_io_wait_for_free();
    }
}

References fb(), pgaio_io_acquire_nb(), and pgaio_io_wait_for_free().

Referenced by AsyncReadBuffers(), handle_get(), handle_get_and_error(), handle_get_release(), handle_get_twice(), and read_rel_block_ll().

pgaio_io_acquire_nb()

PgAioHandle * pgaio_io_acquire_nb	(	struct ResourceOwnerData *	resowner,
		PgAioReturn *	ret
	)

Definition at line 188 of file aio.c.

{
    PgAioHandle *ioh = NULL;
 
    if (pgaio_my_backend->num_staged_ios >= PGAIO_SUBMIT_BATCH_SIZE)
    {
        Assert(pgaio_my_backend->num_staged_ios == PGAIO_SUBMIT_BATCH_SIZE);
        pgaio_submit_staged();
    }
 
    if (pgaio_my_backend->handed_out_io)
        elog(ERROR, "API violation: Only one IO can be handed out");
 
    /*
     * Probably not needed today, as interrupts should not process this IO,
     * but...
     */
    HOLD_INTERRUPTS();
 
    if (!dclist_is_empty(&pgaio_my_backend->idle_ios))
    {
        dlist_node *ion = dclist_pop_head_node(&pgaio_my_backend->idle_ios);
 
        ioh = dclist_container(PgAioHandle, node, ion);
 
        Assert(ioh->state == PGAIO_HS_IDLE);
        Assert(ioh->owner_procno == MyProcNumber);
 
        pgaio_io_update_state(ioh, PGAIO_HS_HANDED_OUT);
        pgaio_my_backend->handed_out_io = ioh;
 
        if (resowner)
            pgaio_io_resowner_register(ioh, resowner);
 
        if (ret)
        {
            ioh->report_return = ret;
            ret->result.status = PGAIO_RS_UNKNOWN;
        }
    }
 
    RESUME_INTERRUPTS();
 
    return ioh;
}

References Assert, dclist_container, dclist_is_empty(), dclist_pop_head_node(), elog, ERROR, fb(), PgAioBackend::handed_out_io, HOLD_INTERRUPTS, PgAioBackend::idle_ios, MyProcNumber, PgAioBackend::num_staged_ios, PGAIO_HS_HANDED_OUT, PGAIO_HS_IDLE, pgaio_io_resowner_register(), pgaio_io_update_state(), pgaio_my_backend, PGAIO_RS_UNKNOWN, PGAIO_SUBMIT_BATCH_SIZE, pgaio_submit_staged(), PgAioReturn::result, RESUME_INTERRUPTS, and PgAioResult::status.

Referenced by AsyncReadBuffers(), and pgaio_io_acquire().

pgaio_io_from_wref()

static PgAioHandle * pgaio_io_from_wref ( PgAioWaitRef *  iow, uint64 *  ref_generation  )

static

Definition at line 891 of file aio.c.

{
    PgAioHandle *ioh;
 
    Assert(iow->aio_index < pgaio_ctl->io_handle_count);
 
    ioh = &pgaio_ctl->io_handles[iow->aio_index];
 
    *ref_generation = ((uint64) iow->generation_upper) << 32 |
        iow->generation_lower;
 
    Assert(*ref_generation != 0);
 
    return ioh;
}

References Assert, fb(), PgAioCtl::io_handle_count, PgAioCtl::io_handles, and pgaio_ctl.

Referenced by pgaio_wref_check_done(), and pgaio_wref_wait().

pgaio_io_get_id()

int pgaio_io_get_id

(

PgAioHandle *

ioh

)

Definition at line 342 of file aio.c.

{
    Assert(ioh >= pgaio_ctl->io_handles &&
           ioh < (pgaio_ctl->io_handles + pgaio_ctl->io_handle_count));
    return ioh - pgaio_ctl->io_handles;
}

References Assert, fb(), PgAioCtl::io_handle_count, PgAioCtl::io_handles, and pgaio_ctl.

Referenced by pg_get_aios(), pgaio_io_wait(), pgaio_io_wait_for_free(), and pgaio_worker_submission_queue_insert().

pgaio_io_get_owner()

ProcNumber pgaio_io_get_owner

(

PgAioHandle *

ioh

)

Definition at line 355 of file aio.c.

{
    return ioh->owner_procno;
}

References fb(), and PgAioHandle::owner_procno.

Referenced by buffer_readv_complete(), and smgr_aio_reopen().

pgaio_io_get_state_name()

const char * pgaio_io_get_state_name

(

PgAioHandle *

ioh

)

Definition at line 928 of file aio.c.

{
    return pgaio_io_state_get_name(ioh->state);
}

References fb(), and pgaio_io_state_get_name().

Referenced by pg_get_aios(), and pgaio_io_wait().

pgaio_io_get_wref()

void pgaio_io_get_wref	(	PgAioHandle *	ioh,
		PgAioWaitRef *	iow
	)

Definition at line 366 of file aio.c.

{
    Assert(ioh->state == PGAIO_HS_HANDED_OUT ||
           ioh->state == PGAIO_HS_DEFINED ||
           ioh->state == PGAIO_HS_STAGED);
    Assert(ioh->generation != 0);
 
    iow->aio_index = ioh - pgaio_ctl->io_handles;
    iow->generation_upper = (uint32) (ioh->generation >> 32);
    iow->generation_lower = (uint32) ioh->generation;
}

References Assert, fb(), PgAioHandle::generation, PgAioCtl::io_handles, pgaio_ctl, PGAIO_HS_DEFINED, PGAIO_HS_HANDED_OUT, and PGAIO_HS_STAGED.

Referenced by AsyncReadBuffers(), buffer_stage_common(), and read_rel_block_ll().

pgaio_io_needs_synchronous_execution()

bool pgaio_io_needs_synchronous_execution

(

PgAioHandle *

ioh

)

Definition at line 483 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 fb(), IoMethodOps::needs_synchronous_execution, PGAIO_HF_SYNCHRONOUS, and pgaio_method_ops.

Referenced by pgaio_io_stage().

pgaio_io_prepare_submit()

void pgaio_io_prepare_submit

(

PgAioHandle *

ioh

)

Definition at line 510 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(), fb(), PgAioBackend::in_flight_ios, 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 528 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);
 
    INJECTION_POINT("aio-process-completion-before-shared", ioh);
 
    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, fb(), INJECTION_POINT, MyProcNumber, PGAIO_HS_COMPLETED_IO, PGAIO_HS_COMPLETED_SHARED, PGAIO_HS_SUBMITTED, pgaio_io_call_complete_shared(), pgaio_io_reclaim(), and pgaio_io_update_state().

Referenced by IoWorkerMain(), and pgaio_io_perform_synchronously().

pgaio_io_reclaim()

static void pgaio_io_reclaim ( PgAioHandle *  ioh )

static

Definition at line 675 of file aio.c.

{
    /* This is only ok if it's our IO */
    Assert(ioh->owner_procno == MyProcNumber);
    Assert(ioh->state != PGAIO_HS_IDLE);
 
    /* see comment in function header */
    HOLD_INTERRUPTS();
 
    /*
     * It's a bit ugly, but right now the easiest place to put the execution
     * of local completion callbacks is this function, as we need to execute
     * local callbacks just before reclaiming at multiple callsites.
     */
    if (ioh->state == PGAIO_HS_COMPLETED_SHARED)
    {
        PgAioResult local_result;
 
        local_result = pgaio_io_call_complete_local(ioh);
        pgaio_io_update_state(ioh, PGAIO_HS_COMPLETED_LOCAL);
 
        if (ioh->report_return)
        {
            ioh->report_return->result = local_result;
            ioh->report_return->target_data = ioh->target_data;
        }
    }
 
    pgaio_debug_io(DEBUG4, ioh,
                   "reclaiming: distilled_result: (status %s, id %u, error_data %d), raw_result: %d",
                   pgaio_result_status_string(ioh->distilled_result.status),
                   ioh->distilled_result.id,
                   ioh->distilled_result.error_data,
                   ioh->result);
 
    /* if the IO has been defined, it's on the in-flight list, remove */
    if (ioh->state != PGAIO_HS_HANDED_OUT)
        dclist_delete_from(&pgaio_my_backend->in_flight_ios, &ioh->node);
 
    if (ioh->resowner)
    {
        ResourceOwnerForgetAioHandle(ioh->resowner, &ioh->resowner_node);
        ioh->resowner = NULL;
    }
 
    Assert(!ioh->resowner);
 
    /*
     * Update generation & state first, before resetting the IO's fields,
     * otherwise a concurrent "viewer" could think the fields are valid, even
     * though they are being reset.  Increment the generation first, so that
     * we can assert elsewhere that we never wait for an IDLE IO.  While it's
     * a bit weird for the state to go backwards for a generation, it's OK
     * here, as there cannot be references to the "reborn" IO yet.  Can't
     * update both at once, so something has to give.
     */
    ioh->generation++;
    pgaio_io_update_state(ioh, PGAIO_HS_IDLE);
 
    /* ensure the state update is visible before we reset fields */
    pg_write_barrier();
 
    ioh->op = PGAIO_OP_INVALID;
    ioh->target = PGAIO_TID_INVALID;
    ioh->flags = 0;
    ioh->num_callbacks = 0;
    ioh->handle_data_len = 0;
    ioh->report_return = NULL;
    ioh->result = 0;
    ioh->distilled_result.status = PGAIO_RS_UNKNOWN;
 
    /*
     * We push the IO to the head of the idle IO list, that seems more cache
     * efficient in cases where only a few IOs are used.
     */
    dclist_push_head(&pgaio_my_backend->idle_ios, &ioh->node);
 
    RESUME_INTERRUPTS();
}

References Assert, dclist_delete_from(), dclist_push_head(), DEBUG4, fb(), HOLD_INTERRUPTS, PgAioBackend::idle_ios, PgAioBackend::in_flight_ios, MyProcNumber, pg_write_barrier, pgaio_debug_io, PGAIO_HS_COMPLETED_LOCAL, PGAIO_HS_COMPLETED_SHARED, PGAIO_HS_HANDED_OUT, PGAIO_HS_IDLE, pgaio_io_call_complete_local(), pgaio_io_update_state(), pgaio_my_backend, PGAIO_OP_INVALID, pgaio_result_status_string(), PGAIO_RS_UNKNOWN, PGAIO_TID_INVALID, ResourceOwnerForgetAioHandle(), and RESUME_INTERRUPTS.

Referenced by pgaio_io_process_completion(), pgaio_io_release(), pgaio_io_release_resowner(), pgaio_io_wait(), pgaio_io_wait_for_free(), and pgaio_wref_check_done().

pgaio_io_release()

void pgaio_io_release

(

PgAioHandle *

ioh

)

Definition at line 240 of file aio.c.

{
    if (ioh == pgaio_my_backend->handed_out_io)
    {
        Assert(ioh->state == PGAIO_HS_HANDED_OUT);
        Assert(ioh->resowner);
 
        pgaio_my_backend->handed_out_io = NULL;
 
        /*
         * Note that no interrupts are processed between the handed_out_io
         * check and the call to reclaim - that's important as otherwise an
         * interrupt could have already reclaimed the handle.
         */
        pgaio_io_reclaim(ioh);
    }
    else
    {
        elog(ERROR, "release in unexpected state");
    }
}

References Assert, elog, ERROR, fb(), PgAioBackend::handed_out_io, PGAIO_HS_HANDED_OUT, pgaio_io_reclaim(), and pgaio_my_backend.

Referenced by AsyncReadBuffers(), handle_get_release(), and handle_release_last().

pgaio_io_release_resowner()

void pgaio_io_release_resowner	(	dlist_node *	ioh_node,
		bool	on_error
	)

Definition at line 266 of file aio.c.

{
    PgAioHandle *ioh = dlist_container(PgAioHandle, resowner_node, ioh_node);
 
    Assert(ioh->resowner);
 
    /*
     * Otherwise an interrupt, in the middle of releasing the IO, could end up
     * trying to wait for the IO, leading to state confusion.
     */
    HOLD_INTERRUPTS();
 
    ResourceOwnerForgetAioHandle(ioh->resowner, &ioh->resowner_node);
    ioh->resowner = NULL;
 
    switch ((PgAioHandleState) ioh->state)
    {
        case PGAIO_HS_IDLE:
            elog(ERROR, "unexpected");
            break;
        case PGAIO_HS_HANDED_OUT:
            Assert(ioh == pgaio_my_backend->handed_out_io || pgaio_my_backend->handed_out_io == NULL);
 
            if (ioh == pgaio_my_backend->handed_out_io)
            {
                pgaio_my_backend->handed_out_io = NULL;
                if (!on_error)
                    elog(WARNING, "leaked AIO handle");
            }
 
            pgaio_io_reclaim(ioh);
            break;
        case PGAIO_HS_DEFINED:
        case PGAIO_HS_STAGED:
            if (!on_error)
                elog(WARNING, "AIO handle was not submitted");
            pgaio_submit_staged();
            break;
        case PGAIO_HS_SUBMITTED:
        case PGAIO_HS_COMPLETED_IO:
        case PGAIO_HS_COMPLETED_SHARED:
        case PGAIO_HS_COMPLETED_LOCAL:
            /* this is expected to happen */
            break;
    }
 
    /*
     * Need to unregister the reporting of the IO's result, the memory it's
     * referencing likely has gone away.
     */
    if (ioh->report_return)
        ioh->report_return = NULL;
 
    RESUME_INTERRUPTS();
}

References Assert, dlist_container, elog, ERROR, fb(), PgAioBackend::handed_out_io, HOLD_INTERRUPTS, PGAIO_HS_COMPLETED_IO, PGAIO_HS_COMPLETED_LOCAL, PGAIO_HS_COMPLETED_SHARED, PGAIO_HS_DEFINED, PGAIO_HS_HANDED_OUT, PGAIO_HS_IDLE, PGAIO_HS_STAGED, PGAIO_HS_SUBMITTED, pgaio_io_reclaim(), pgaio_my_backend, pgaio_submit_staged(), ResourceOwnerForgetAioHandle(), RESUME_INTERRUPTS, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

pgaio_io_resowner_register()

static void pgaio_io_resowner_register ( PgAioHandle *  ioh, struct ResourceOwnerData *  resowner  )

static

Definition at line 409 of file aio.c.

{
    Assert(!ioh->resowner);
    Assert(resowner);
 
    ResourceOwnerRememberAioHandle(resowner, &ioh->resowner_node);
    ioh->resowner = resowner;
}

References Assert, fb(), and ResourceOwnerRememberAioHandle().

Referenced by pgaio_io_acquire_nb().

pgaio_io_set_flag()

void pgaio_io_set_flag	(	PgAioHandle *	ioh,
		PgAioHandleFlags	flag
	)

Definition at line 330 of file aio.c.

{
    Assert(ioh->state == PGAIO_HS_HANDED_OUT);
 
    ioh->flags |= flag;
}

References Assert, fb(), flag(), and PGAIO_HS_HANDED_OUT.

Referenced by AsyncReadBuffers(), mdstartreadv(), and read_rel_block_ll().

pgaio_io_stage()

void pgaio_io_stage	(	PgAioHandle *	ioh,
		PgAioOp	op
	)

Definition at line 424 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));
 
    /*
     * Otherwise an interrupt, in the middle of staging and possibly executing
     * the IO, could end up trying to wait for the IO, leading to state
     * confusion.
     */
    HOLD_INTERRUPTS();
 
    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,
                   "staged (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);
    }
 
    RESUME_INTERRUPTS();
}

References Assert, DEBUG3, fb(), PgAioBackend::handed_out_io, HOLD_INTERRUPTS, PgAioBackend::in_batchmode, PgAioBackend::num_staged_ios, 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(), RESUME_INTERRUPTS, and PgAioBackend::staged_ios.

Referenced by pgaio_io_start_readv(), and pgaio_io_start_writev().

pgaio_io_state_get_name()

static const char * pgaio_io_state_get_name ( PgAioHandleState  s )

static

Definition at line 908 of file aio.c.

{
#define PGAIO_HS_TOSTR_CASE(sym) case PGAIO_HS_##sym: return #sym
    switch (s)
    {
            PGAIO_HS_TOSTR_CASE(IDLE);
            PGAIO_HS_TOSTR_CASE(HANDED_OUT);
            PGAIO_HS_TOSTR_CASE(DEFINED);
            PGAIO_HS_TOSTR_CASE(STAGED);
            PGAIO_HS_TOSTR_CASE(SUBMITTED);
            PGAIO_HS_TOSTR_CASE(COMPLETED_IO);
            PGAIO_HS_TOSTR_CASE(COMPLETED_SHARED);
            PGAIO_HS_TOSTR_CASE(COMPLETED_LOCAL);
    }
#undef PGAIO_HS_TOSTR_CASE
 
    return NULL;                /* silence compiler */
}

References fb(), and PGAIO_HS_TOSTR_CASE.

Referenced by pgaio_io_get_state_name(), and pgaio_io_update_state().

pgaio_io_update_state()

static void pgaio_io_update_state ( PgAioHandle *  ioh, PgAioHandleState  new_state  )

inlinestatic

Definition at line 386 of file aio.c.

{
    /*
     * All callers need to have held interrupts in some form, otherwise
     * interrupt processing could wait for the IO to complete, while in an
     * intermediary state.
     */
    Assert(!INTERRUPTS_CAN_BE_PROCESSED());
 
    pgaio_debug_io(DEBUG5, ioh,
                   "updating state to %s",
                   pgaio_io_state_get_name(new_state));
 
    /*
     * Ensure the changes signified by the new state are visible before the
     * new state becomes visible.
     */
    pg_write_barrier();
 
    ioh->state = new_state;
}

References Assert, DEBUG5, fb(), INTERRUPTS_CAN_BE_PROCESSED, pg_write_barrier, pgaio_debug_io, and pgaio_io_state_get_name().

Referenced by pgaio_io_acquire_nb(), pgaio_io_prepare_submit(), pgaio_io_process_completion(), pgaio_io_reclaim(), and pgaio_io_stage().

pgaio_io_wait()

static void pgaio_io_wait ( PgAioHandle *  ioh, uint64  ref_generation  )

static

Definition at line 579 of file aio.c.

{
    PgAioHandleState state;
    bool        am_owner;
 
    am_owner = ioh->owner_procno == MyProcNumber;
 
    if (pgaio_io_was_recycled(ioh, ref_generation, &state))
        return;
 
    if (am_owner)
    {
        if (state != PGAIO_HS_SUBMITTED
            && state != PGAIO_HS_COMPLETED_IO
            && state != PGAIO_HS_COMPLETED_SHARED
            && state != PGAIO_HS_COMPLETED_LOCAL)
        {
            elog(PANIC, "waiting for own IO %d in wrong state: %s",
                 pgaio_io_get_id(ioh), pgaio_io_get_state_name(ioh));
        }
    }
 
    while (true)
    {
        if (pgaio_io_was_recycled(ioh, ref_generation, &state))
            return;
 
        switch (state)
        {
            case PGAIO_HS_IDLE:
            case PGAIO_HS_HANDED_OUT:
                elog(ERROR, "IO in wrong state: %d", state);
                break;
 
            case PGAIO_HS_SUBMITTED:
 
                /*
                 * If we need to wait via the IO method, do so now. Don't
                 * check via the IO method if the issuing backend is executing
                 * the IO synchronously.
                 */
                if (pgaio_method_ops->wait_one && !(ioh->flags & PGAIO_HF_SYNCHRONOUS))
                {
                    pgaio_method_ops->wait_one(ioh, ref_generation);
                    continue;
                }
                /* fallthrough */
 
                /* waiting for owner to submit */
            case PGAIO_HS_DEFINED:
            case PGAIO_HS_STAGED:
                /* waiting for reaper to complete */
                /* fallthrough */
            case PGAIO_HS_COMPLETED_IO:
                /* shouldn't be able to hit this otherwise */
                Assert(IsUnderPostmaster);
                /* ensure we're going to get woken up */
                ConditionVariablePrepareToSleep(&ioh->cv);
 
                while (!pgaio_io_was_recycled(ioh, ref_generation, &state))
                {
                    if (state == PGAIO_HS_COMPLETED_SHARED ||
                        state == PGAIO_HS_COMPLETED_LOCAL)
                        break;
                    ConditionVariableSleep(&ioh->cv, WAIT_EVENT_AIO_IO_COMPLETION);
                }
 
                ConditionVariableCancelSleep();
                break;
 
            case PGAIO_HS_COMPLETED_SHARED:
            case PGAIO_HS_COMPLETED_LOCAL:
 
                /*
                 * Note that no interrupts are processed between
                 * pgaio_io_was_recycled() and this check - that's important
                 * as otherwise an interrupt could have already reclaimed the
                 * handle.
                 */
                if (am_owner)
                    pgaio_io_reclaim(ioh);
                return;
        }
    }
}

References Assert, ConditionVariableCancelSleep(), ConditionVariablePrepareToSleep(), ConditionVariableSleep(), elog, ERROR, fb(), IsUnderPostmaster, MyProcNumber, PANIC, PGAIO_HF_SYNCHRONOUS, PGAIO_HS_COMPLETED_IO, PGAIO_HS_COMPLETED_LOCAL, PGAIO_HS_COMPLETED_SHARED, PGAIO_HS_DEFINED, PGAIO_HS_HANDED_OUT, PGAIO_HS_IDLE, PGAIO_HS_STAGED, PGAIO_HS_SUBMITTED, pgaio_io_get_id(), pgaio_io_get_state_name(), pgaio_io_reclaim(), pgaio_io_was_recycled(), pgaio_method_ops, and IoMethodOps::wait_one.

Referenced by pgaio_closing_fd(), pgaio_io_wait_for_free(), pgaio_shutdown(), and pgaio_wref_wait().

pgaio_io_wait_for_free()

static void pgaio_io_wait_for_free ( void  )

static

Definition at line 761 of file aio.c.

{
    int         reclaimed = 0;
 
    pgaio_debug(DEBUG2, "waiting for free IO with %d pending, %u in-flight, %u idle IOs",
                pgaio_my_backend->num_staged_ios,
                dclist_count(&pgaio_my_backend->in_flight_ios),
                dclist_count(&pgaio_my_backend->idle_ios));
 
    /*
     * First check if any of our IOs actually have completed - when using
     * worker, that'll often be the case. We could do so as part of the loop
     * below, but that'd potentially lead us to wait for some IO submitted
     * before.
     */
    for (int i = 0; i < io_max_concurrency; i++)
    {
        PgAioHandle *ioh = &pgaio_ctl->io_handles[pgaio_my_backend->io_handle_off + i];
 
        if (ioh->state == PGAIO_HS_COMPLETED_SHARED)
        {
            /*
             * Note that no interrupts are processed between the state check
             * and the call to reclaim - that's important as otherwise an
             * interrupt could have already reclaimed the handle.
             *
             * Need to ensure that there's no reordering, in the more common
             * paths, where we wait for IO, that's done by
             * pgaio_io_was_recycled().
             */
            pg_read_barrier();
            pgaio_io_reclaim(ioh);
            reclaimed++;
        }
    }
 
    if (reclaimed > 0)
        return;
 
    /*
     * If we have any unsubmitted IOs, submit them now. We'll start waiting in
     * a second, so it's better they're in flight. This also addresses the
     * edge-case that all IOs are unsubmitted.
     */
    if (pgaio_my_backend->num_staged_ios > 0)
        pgaio_submit_staged();
 
    /* possibly some IOs finished during submission */
    if (!dclist_is_empty(&pgaio_my_backend->idle_ios))
        return;
 
    if (dclist_count(&pgaio_my_backend->in_flight_ios) == 0)
        ereport(ERROR,
                errmsg_internal("no free IOs despite no in-flight IOs"),
                errdetail_internal("%d pending, %u in-flight, %u idle IOs",
                                   pgaio_my_backend->num_staged_ios,
                                   dclist_count(&pgaio_my_backend->in_flight_ios),
                                   dclist_count(&pgaio_my_backend->idle_ios)));
 
    /*
     * Wait for the oldest in-flight IO to complete.
     *
     * XXX: Reusing the general IO wait is suboptimal, we don't need to wait
     * for that specific IO to complete, we just need *any* IO to complete.
     */
    {
        PgAioHandle *ioh = dclist_head_element(PgAioHandle, node,
                                               &pgaio_my_backend->in_flight_ios);
        uint64      generation = ioh->generation;
 
        switch ((PgAioHandleState) ioh->state)
        {
                /* should not be in in-flight list */
            case PGAIO_HS_IDLE:
            case PGAIO_HS_DEFINED:
            case PGAIO_HS_HANDED_OUT:
            case PGAIO_HS_STAGED:
            case PGAIO_HS_COMPLETED_LOCAL:
                elog(ERROR, "shouldn't get here with io:%d in state %d",
                     pgaio_io_get_id(ioh), ioh->state);
                break;
 
            case PGAIO_HS_COMPLETED_IO:
            case PGAIO_HS_SUBMITTED:
                pgaio_debug_io(DEBUG2, ioh,
                               "waiting for free io with %u in flight",
                               dclist_count(&pgaio_my_backend->in_flight_ios));
 
                /*
                 * In a more general case this would be racy, because the
                 * generation could increase after we read ioh->state above.
                 * But we are only looking at IOs by the current backend and
                 * the IO can only be recycled by this backend.  Even this is
                 * only OK because we get the handle's generation before
                 * potentially processing interrupts, e.g. as part of
                 * pgaio_debug_io().
                 */
                pgaio_io_wait(ioh, generation);
                break;
 
            case PGAIO_HS_COMPLETED_SHARED:
 
                /*
                 * It's possible that another backend just finished this IO.
                 *
                 * Note that no interrupts are processed between the state
                 * check and the call to reclaim - that's important as
                 * otherwise an interrupt could have already reclaimed the
                 * handle.
                 *
                 * Need to ensure that there's no reordering, in the more
                 * common paths, where we wait for IO, that's done by
                 * pgaio_io_was_recycled().
                 */
                pg_read_barrier();
                pgaio_io_reclaim(ioh);
                break;
        }
 
        if (dclist_count(&pgaio_my_backend->idle_ios) == 0)
            elog(PANIC, "no idle IO after waiting for IO to terminate");
        return;
    }
}

References dclist_count(), dclist_head_element, dclist_is_empty(), DEBUG2, elog, ereport, errdetail_internal(), errmsg_internal(), ERROR, fb(), i, PgAioBackend::idle_ios, PgAioBackend::in_flight_ios, PgAioBackend::io_handle_off, PgAioCtl::io_handles, io_max_concurrency, PgAioBackend::num_staged_ios, PANIC, pg_read_barrier, pgaio_ctl, pgaio_debug, pgaio_debug_io, PGAIO_HS_COMPLETED_IO, PGAIO_HS_COMPLETED_LOCAL, PGAIO_HS_COMPLETED_SHARED, PGAIO_HS_DEFINED, PGAIO_HS_HANDED_OUT, PGAIO_HS_IDLE, PGAIO_HS_STAGED, PGAIO_HS_SUBMITTED, pgaio_io_get_id(), pgaio_io_reclaim(), pgaio_io_wait(), pgaio_my_backend, and pgaio_submit_staged().

Referenced by pgaio_io_acquire().

pgaio_io_was_recycled()

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

Definition at line 559 of file aio.c.

{
    *state = ioh->state;
 
    /*
     * Ensure that we don't see an earlier state of the handle than ioh->state
     * due to compiler or CPU reordering. This protects both ->generation as
     * directly used here, and other fields in the handle accessed in the
     * caller if the handle was not reused.
     */
    pg_read_barrier();
 
    return ioh->generation != ref_generation;
}

References fb(), and pg_read_barrier.

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 934 of file aio.c.

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

References fb(), PGAIO_RS_ERROR, PGAIO_RS_OK, PGAIO_RS_PARTIAL, PGAIO_RS_UNKNOWN, and PGAIO_RS_WARNING.

Referenced by pg_get_aios(), 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 1288 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);
        uint64      generation = ioh->generation;
 
        pgaio_debug_io(DEBUG2, ioh,
                       "waiting for IO to complete during shutdown, %u in-flight IOs",
                       dclist_count(&pgaio_my_backend->in_flight_ios));
 
        /* see comment in pgaio_io_wait_for_free() about raciness */
        pgaio_io_wait(ioh, generation);
    }
 
    pgaio_my_backend = NULL;
}

References Assert, AtEOXact_Aio(), dclist_count(), dclist_head_element, dclist_is_empty(), DEBUG2, fb(), PgAioBackend::handed_out_io, PgAioBackend::in_flight_ios, pgaio_debug_io, pgaio_io_wait(), and pgaio_my_backend.

Referenced by pgaio_init_backend().

pgaio_submit_staged()

void pgaio_submit_staged

(

void

)

Definition at line 1123 of file aio.c.

{
    int         total_submitted = 0;
    int         did_submit;
 
    if (pgaio_my_backend->num_staged_ios == 0)
        return;
 
 
    START_CRIT_SECTION();
 
    did_submit = pgaio_method_ops->submit(pgaio_my_backend->num_staged_ios,
                                          pgaio_my_backend->staged_ios);
 
    END_CRIT_SECTION();
 
    total_submitted += did_submit;
 
    Assert(total_submitted == did_submit);
 
    pgaio_my_backend->num_staged_ios = 0;
 
    pgaio_debug(DEBUG4,
                "aio: submitted %d IOs",
                total_submitted);
}

References Assert, DEBUG4, END_CRIT_SECTION, fb(), PgAioBackend::num_staged_ios, pgaio_debug, pgaio_method_ops, pgaio_my_backend, PgAioBackend::staged_ios, START_CRIT_SECTION, and IoMethodOps::submit.

Referenced by AsyncReadBuffers(), pgaio_closing_fd(), pgaio_error_cleanup(), pgaio_exit_batchmode(), pgaio_io_acquire_nb(), pgaio_io_release_resowner(), pgaio_io_stage(), pgaio_io_wait_for_free(), and ReadBuffersCanStartIO().

pgaio_wref_check_done()

bool pgaio_wref_check_done

(

PgAioWaitRef *

iow

)

Definition at line 1005 of file aio.c.

{
    uint64      ref_generation;
    PgAioHandleState state;
    bool        am_owner;
    PgAioHandle *ioh;
 
    ioh = pgaio_io_from_wref(iow, &ref_generation);
 
    if (pgaio_io_was_recycled(ioh, ref_generation, &state))
        return true;
 
    if (state == PGAIO_HS_IDLE)
        return true;
 
    am_owner = ioh->owner_procno == MyProcNumber;
 
    if (state == PGAIO_HS_COMPLETED_SHARED ||
        state == PGAIO_HS_COMPLETED_LOCAL)
    {
        /*
         * Note that no interrupts are processed between
         * pgaio_io_was_recycled() and this check - that's important as
         * otherwise an interrupt could have already reclaimed the handle.
         */
        if (am_owner)
            pgaio_io_reclaim(ioh);
        return true;
    }
 
    /*
     * XXX: It likely would be worth checking in with the io method, to give
     * the IO method a chance to check if there are completion events queued.
     */
 
    return false;
}

References fb(), MyProcNumber, PGAIO_HS_COMPLETED_LOCAL, PGAIO_HS_COMPLETED_SHARED, PGAIO_HS_IDLE, pgaio_io_from_wref(), pgaio_io_reclaim(), and pgaio_io_was_recycled().

Referenced by WaitReadBuffers().

pgaio_wref_clear()

void pgaio_wref_clear

(

PgAioWaitRef *

iow

)

Definition at line 964 of file aio.c.

{
    iow->aio_index = PG_UINT32_MAX;
}

References fb(), and PG_UINT32_MAX.

Referenced by AsyncReadBuffers(), BufferManagerShmemInit(), InitLocalBuffers(), StartReadBuffersImpl(), TerminateBufferIO(), and TerminateLocalBufferIO().

pgaio_wref_get_id()

int pgaio_wref_get_id

(

PgAioWaitRef *

iow

)

Definition at line 980 of file aio.c.

{
    Assert(pgaio_wref_valid(iow));
    return iow->aio_index;
}

References Assert, fb(), and pgaio_wref_valid().

pgaio_wref_valid()

bool pgaio_wref_valid

(

PgAioWaitRef *

iow

)

Definition at line 971 of file aio.c.

{
    return iow->aio_index != PG_UINT32_MAX;
}

References fb(), and PG_UINT32_MAX.

Referenced by InvalidateLocalBuffer(), pgaio_wref_get_id(), ProcessReadBuffersResult(), StartLocalBufferIO(), WaitIO(), and WaitReadBuffers().

pgaio_wref_wait()

void pgaio_wref_wait

(

PgAioWaitRef *

iow

)

Definition at line 991 of file aio.c.

{
    uint64      ref_generation;
    PgAioHandle *ioh;
 
    ioh = pgaio_io_from_wref(iow, &ref_generation);
 
    pgaio_io_wait(ioh, ref_generation);
}

References fb(), pgaio_io_from_wref(), and pgaio_io_wait().

Referenced by InvalidateLocalBuffer(), read_rel_block_ll(), StartLocalBufferIO(), WaitIO(), and WaitReadBuffers().

StaticAssertDecl()

StaticAssertDecl	(	lengthof(io_method_options)	= =lengthof(pgaio_method_ops_table)+1,
		"io_method_options out of sync with pgaio_method_ops_table"
	)

Variable Documentation

io_max_concurrency

int io_max_concurrency = -1

Definition at line 75 of file aio.c.

Referenced by AioHandleDataShmemSize(), AioHandleIOVShmemSize(), AioHandleShmemSize(), AioShmemInit(), AioShmemSize(), and pgaio_io_wait_for_free().

io_method

int io_method = DEFAULT_IO_METHOD

Definition at line 74 of file aio.c.

Referenced by pgaio_workers_enabled(), read_stream_begin_impl(), StartReadBuffersImpl(), and WaitReadBuffers().

io_method_options

const struct config_enum_entry io_method_options[]

Initial value:

= {
    {"sync", IOMETHOD_SYNC, false},
    {"worker", IOMETHOD_WORKER, false},
 
 
 
    {NULL, 0, false}
}

Definition at line 64 of file aio.c.

                                                     {
    {"sync", IOMETHOD_SYNC, false},
    {"worker", IOMETHOD_WORKER, false},
#ifdef IOMETHOD_IO_URING_ENABLED
    {"io_uring", IOMETHOD_IO_URING, false},
#endif
    {NULL, 0, false}
};

pgaio_ctl

PgAioCtl* pgaio_ctl

Definition at line 78 of file aio.c.

Referenced by AioShmemInit(), IoWorkerMain(), pg_get_aios(), pgaio_init_backend(), pgaio_io_from_wref(), pgaio_io_get_handle_data(), pgaio_io_get_id(), pgaio_io_get_iovec(), pgaio_io_get_iovec_length(), 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

const IoMethodOps* pgaio_method_ops

Definition at line 96 of file aio.c.

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

pgaio_method_ops_table

const IoMethodOps* const pgaio_method_ops_table[]

static

Initial value:

= {
    [IOMETHOD_SYNC] = &pgaio_sync_ops,
    [IOMETHOD_WORKER] = &pgaio_worker_ops,
 
 
 
}

Definition at line 84 of file aio.c.

                                                           {
    [IOMETHOD_SYNC] = &pgaio_sync_ops,
    [IOMETHOD_WORKER] = &pgaio_worker_ops,
#ifdef IOMETHOD_IO_URING_ENABLED
    [IOMETHOD_IO_URING] = &pgaio_uring_ops,
#endif
};

Referenced by assign_io_method().

pgaio_my_backend

PgAioBackend* pgaio_my_backend

Definition at line 81 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_start(), 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().