aio_internal.h File Reference

#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, ...)

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)
PgAioResult	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_uses_fd (PgAioHandle *ioh, int fd)
int	pgaio_io_get_iovec_length (PgAioHandle *ioh, struct iovec **iov)
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 382 of file aio_internal.h.

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

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 395 of file aio_internal.h.

                                                                 : " 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__)

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 371 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 43 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_start_*() is called), or IDLE (if pgaio_io_release() is
     * called).
     */
    PGAIO_HS_HANDED_OUT,
 
    /*
     * pgaio_io_start_*() 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()

PgAioResult pgaio_io_call_complete_local ( PgAioHandle *  ioh )

extern

Definition at line 285 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;
    Assert(result.status != PGAIO_RS_UNKNOWN);
 
    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);
 
        /* the callback should never transition to unknown */
        Assert(result.status != PGAIO_RS_UNKNOWN);
    }
 
    /*
     * Note that we don't save the result in ioh->distilled_result, the local
     * callback's result should not ever matter to other waiters. However, the
     * local backend does care, so we return the result as modified by local
     * callbacks, which then can be passed to ioh->report_return->result.
     */
    pgaio_debug_io(DEBUG3, ioh,
                   "after local completion: 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();
 
    return result;
}

References aio_handle_cbs, Assert, DEBUG3, DEBUG4, END_CRIT_SECTION, PgAioResult::error_data, fb(), i, PgAioResult::id, pgaio_debug_io, PGAIO_OP_COUNT, PGAIO_OP_INVALID, pgaio_result_status_string(), PGAIO_RS_UNKNOWN, PGAIO_TID_COUNT, PGAIO_TID_INVALID, PgAioResult::result, START_CRIT_SECTION, and PgAioResult::status.

Referenced by pgaio_io_reclaim().

pgaio_io_call_complete_shared()

void pgaio_io_call_complete_shared ( PgAioHandle *  ioh )

extern

Definition at line 225 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);
 
        /* the callback should never transition to unknown */
        Assert(result.status != PGAIO_RS_UNKNOWN);
    }
 
    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, DEBUG3, DEBUG4, END_CRIT_SECTION, PgAioResult::error_data, fb(), i, PgAioResult::id, pgaio_debug_io, PGAIO_HCB_INVALID, PGAIO_OP_COUNT, PGAIO_OP_INVALID, pgaio_result_status_string(), PGAIO_RS_OK, PGAIO_RS_UNKNOWN, PGAIO_TID_COUNT, PGAIO_TID_INVALID, PgAioResult::result, START_CRIT_SECTION, and PgAioResult::status.

Referenced by pgaio_io_process_completion().

pgaio_io_call_stage()

void pgaio_io_call_stage ( PgAioHandle *  ioh )

extern

Definition at line 199 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, DEBUG3, fb(), i, pgaio_debug_io, PGAIO_OP_COUNT, PGAIO_OP_INVALID, PGAIO_TID_COUNT, and PGAIO_TID_INVALID.

Referenced by pgaio_io_stage().

pgaio_io_can_reopen()

bool pgaio_io_can_reopen ( PgAioHandle *  ioh )

extern

Definition at line 103 of file aio_target.c.

{
    Assert(ioh->target > PGAIO_TID_INVALID && ioh->target < PGAIO_TID_COUNT);
 
    return pgaio_target_info[ioh->target]->reopen != NULL;
}

References Assert, fb(), pgaio_target_info, PGAIO_TID_COUNT, PGAIO_TID_INVALID, and PgAioTargetInfo::reopen.

Referenced by pgaio_worker_needs_synchronous_execution().

pgaio_io_get_iovec_length()

int pgaio_io_get_iovec_length ( PgAioHandle *  ioh, struct iovec **  iov  )

extern

Definition at line 219 of file aio_io.c.

{
    Assert(ioh->state >= PGAIO_HS_DEFINED);
 
    *iov = &pgaio_ctl->iovecs[ioh->iovec_off];
 
    switch ((PgAioOp) ioh->op)
    {
        case PGAIO_OP_READV:
            return ioh->op_data.read.iov_length;
        case PGAIO_OP_WRITEV:
            return ioh->op_data.write.iov_length;
        default:
            pg_unreachable();
            return 0;
    }
}

References Assert, fb(), PgAioCtl::iovecs, pg_unreachable, pgaio_ctl, PGAIO_HS_DEFINED, PGAIO_OP_READV, and PGAIO_OP_WRITEV.

Referenced by IoWorkerMain().

pgaio_io_get_op_name()

const char * pgaio_io_get_op_name ( PgAioHandle *  ioh )

extern

Definition at line 175 of file aio_io.c.

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

References Assert, fb(), PGAIO_OP_COUNT, PGAIO_OP_INVALID, PGAIO_OP_READV, and PGAIO_OP_WRITEV.

Referenced by pg_get_aios().

pgaio_io_get_state_name()

const char * pgaio_io_get_state_name ( PgAioHandle *  ioh )

extern

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_target_name()

const char * pgaio_io_get_target_name ( PgAioHandle *  ioh )

extern

Definition at line 50 of file aio_target.c.

{
    /* explicitly allow INVALID here, function used by debug messages */
    Assert(ioh->target >= PGAIO_TID_INVALID && ioh->target < PGAIO_TID_COUNT);
 
    return pgaio_target_info[ioh->target]->name;
}

References Assert, fb(), PgAioTargetInfo::name, pgaio_target_info, PGAIO_TID_COUNT, and PGAIO_TID_INVALID.

Referenced by pg_get_aios().

pgaio_io_needs_synchronous_execution()

bool pgaio_io_needs_synchronous_execution ( PgAioHandle *  ioh )

extern

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_perform_synchronously()

void pgaio_io_perform_synchronously ( PgAioHandle *  ioh )

extern

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 ((PgAioOp) 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, fb(), PgAioCtl::iovecs, 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(), and START_CRIT_SECTION.

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

pgaio_io_prepare_submit()

void pgaio_io_prepare_submit ( PgAioHandle *  ioh )

extern

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  )

extern

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_reopen()

void pgaio_io_reopen ( PgAioHandle *  ioh )

extern

Definition at line 116 of file aio_target.c.

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

References Assert, fb(), PGAIO_OP_COUNT, PGAIO_OP_INVALID, pgaio_target_info, PGAIO_TID_COUNT, PGAIO_TID_INVALID, and PgAioTargetInfo::reopen.

Referenced by IoWorkerMain().

pgaio_io_stage()

void pgaio_io_stage ( PgAioHandle *  ioh, PgAioOp  op  )

extern

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_uses_fd()

bool pgaio_io_uses_fd ( PgAioHandle *  ioh, int  fd  )

extern

Definition at line 197 of file aio_io.c.

{
    Assert(ioh->state >= PGAIO_HS_DEFINED);
 
    switch ((PgAioOp) ioh->op)
    {
        case PGAIO_OP_READV:
            return ioh->op_data.read.fd == fd;
        case PGAIO_OP_WRITEV:
            return ioh->op_data.write.fd == fd;
        case PGAIO_OP_INVALID:
            return false;
    }
 
    return false;               /* silence compiler */
}

References Assert, fb(), fd(), PGAIO_HS_DEFINED, PGAIO_OP_INVALID, PGAIO_OP_READV, and PGAIO_OP_WRITEV.

Referenced by pgaio_closing_fd().

pgaio_io_was_recycled()

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

extern

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  )

extern

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().

Variable Documentation

pgaio_ctl

PGDLLIMPORT PgAioCtl* pgaio_ctl

extern

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

PGDLLIMPORT const IoMethodOps* pgaio_method_ops

extern

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_my_backend

PGDLLIMPORT PgAioBackend* pgaio_my_backend

extern

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().

pgaio_sync_ops

PGDLLIMPORT const IoMethodOps pgaio_sync_ops

extern

Definition at line 28 of file method_sync.c.

                                   {
    .needs_synchronous_execution = pgaio_sync_needs_synchronous_execution,
    .submit = pgaio_sync_submit,
};

pgaio_worker_ops

PGDLLIMPORT const IoMethodOps pgaio_worker_ops

extern

Definition at line 83 of file method_worker.c.

                                     {
    .shmem_size = pgaio_worker_shmem_size,
    .shmem_init = pgaio_worker_shmem_init,
 
    .needs_synchronous_execution = pgaio_worker_needs_synchronous_execution,
    .submit = pgaio_worker_submit,
};