PostgreSQL Source Code git master
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
aio.h File Reference
#include "storage/aio_types.h"
#include "storage/procnumber.h"
Include dependency graph for aio.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

union   PgAioOpData
 
struct   PgAioTargetInfo
 
struct   PgAioHandleCallbacks
 

Macros

#define  DEFAULT_IO_METHOD   IOMETHOD_WORKER
 
#define  PGAIO_OP_COUNT   (PGAIO_OP_WRITEV + 1)
 
#define  PGAIO_TID_COUNT   (PGAIO_TID_SMGR + 1)
 
#define  PGAIO_HCB_MAX   PGAIO_HCB_LOCAL_BUFFER_READV
 
#define  PGAIO_HANDLE_MAX_CALLBACKS   4
 

Typedefs

typedef enum IoMethod  IoMethod
 
typedef enum PgAioHandleFlags  PgAioHandleFlags
 
typedef enum PgAioOp  PgAioOp
 
typedef enum PgAioTargetID  PgAioTargetID
 
typedef enum PgAioHandleCallbackID  PgAioHandleCallbackID
 
typedef void(*  PgAioHandleCallbackStage) (PgAioHandle *ioh, uint8 cb_flags)
 
typedef PgAioResult(*  PgAioHandleCallbackComplete) (PgAioHandle *ioh, PgAioResult prior_result, uint8 cb_flags)
 
typedef void(*  PgAioHandleCallbackReport) (PgAioResult result, const PgAioTargetData *target_data, int elevel)
 

Enumerations

enum   IoMethod { IOMETHOD_SYNC = 0 , IOMETHOD_WORKER }
 
enum   PgAioHandleFlags { PGAIO_HF_REFERENCES_LOCAL = 1 << 1 , PGAIO_HF_SYNCHRONOUS = 1 << 0 , PGAIO_HF_BUFFERED = 1 << 2 }
 
enum   PgAioOp { PGAIO_OP_INVALID = 0 , PGAIO_OP_READV , PGAIO_OP_WRITEV }
 
enum   PgAioTargetID { PGAIO_TID_INVALID = 0 , PGAIO_TID_SMGR }
 
enum   PgAioHandleCallbackID { PGAIO_HCB_INVALID = 0 , PGAIO_HCB_MD_READV , PGAIO_HCB_SHARED_BUFFER_READV , PGAIO_HCB_LOCAL_BUFFER_READV }
 

Functions

  StaticAssertDecl (PGAIO_HCB_MAX<(1<< PGAIO_RESULT_ID_BITS), "PGAIO_HCB_MAX is too big for PGAIO_RESULT_ID_BITS")
 
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 (struct 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)
 
int  pgaio_io_get_iovec (PgAioHandle *ioh, struct iovec **iov)
 
PgAioOp  pgaio_io_get_op (PgAioHandle *ioh)
 
PgAioOpData *  pgaio_io_get_op_data (PgAioHandle *ioh)
 
void  pgaio_io_start_readv (PgAioHandle *ioh, int fd, int iovcnt, uint64 offset)
 
void  pgaio_io_start_writev (PgAioHandle *ioh, int fd, int iovcnt, uint64 offset)
 
void  pgaio_io_set_target (PgAioHandle *ioh, PgAioTargetID targetid)
 
bool  pgaio_io_has_target (PgAioHandle *ioh)
 
PgAioTargetData *  pgaio_io_get_target_data (PgAioHandle *ioh)
 
char *  pgaio_io_get_target_description (PgAioHandle *ioh)
 
void  pgaio_io_register_callbacks (PgAioHandle *ioh, PgAioHandleCallbackID cb_id, uint8 cb_data)
 
void  pgaio_io_set_handle_data_64 (PgAioHandle *ioh, uint64 *data, uint8 len)
 
void  pgaio_io_set_handle_data_32 (PgAioHandle *ioh, uint32 *data, uint8 len)
 
uint64 *  pgaio_io_get_handle_data (PgAioHandle *ioh, uint8 *len)
 
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_result_report (PgAioResult result, const PgAioTargetData *target_data, int elevel)
 
void  pgaio_enter_batchmode (void)
 
void  pgaio_exit_batchmode (void)
 
void  pgaio_submit_staged (void)
 
bool  pgaio_have_staged (void)
 
void  pgaio_closing_fd (int fd)
 

Variables

PGDLLIMPORT int  io_method
 
PGDLLIMPORT int  io_max_concurrency
 

Macro Definition Documentation

◆ DEFAULT_IO_METHOD

#define DEFAULT_IO_METHOD   IOMETHOD_WORKER

Definition at line 42 of file aio.h.

◆ PGAIO_HANDLE_MAX_CALLBACKS

#define PGAIO_HANDLE_MAX_CALLBACKS   4

Definition at line 267 of file aio.h.

◆ PGAIO_HCB_MAX

#define PGAIO_HCB_MAX   PGAIO_HCB_LOCAL_BUFFER_READV

Definition at line 203 of file aio.h.

◆ PGAIO_OP_COUNT

#define PGAIO_OP_COUNT   (PGAIO_OP_WRITEV + 1)

Definition at line 107 of file aio.h.

◆ PGAIO_TID_COUNT

#define PGAIO_TID_COUNT   (PGAIO_TID_SMGR + 1)

Definition at line 123 of file aio.h.

Typedef Documentation

◆ IoMethod

typedef enum IoMethod IoMethod

◆ PgAioHandleCallbackComplete

typedef PgAioResult(* PgAioHandleCallbackComplete) (PgAioHandle *ioh, PgAioResult prior_result, uint8 cb_flags)

Definition at line 209 of file aio.h.

◆ PgAioHandleCallbackID

typedef enum PgAioHandleCallbackID PgAioHandleCallbackID

◆ PgAioHandleCallbackReport

typedef void(* PgAioHandleCallbackReport) (PgAioResult result, const PgAioTargetData *target_data, int elevel)

Definition at line 210 of file aio.h.

◆ PgAioHandleCallbackStage

typedef void(* PgAioHandleCallbackStage) (PgAioHandle *ioh, uint8 cb_flags)

Definition at line 208 of file aio.h.

◆ PgAioHandleFlags

typedef enum PgAioHandleFlags PgAioHandleFlags

◆ PgAioOp

typedef enum PgAioOp PgAioOp

◆ PgAioTargetID

typedef enum PgAioTargetID PgAioTargetID

Enumeration Type Documentation

◆ IoMethod

enum IoMethod
Enumerator
IOMETHOD_SYNC 
IOMETHOD_WORKER 

Definition at line 32 of file aio.h.

33{
34 IOMETHOD_SYNC = 0,
36#ifdef IOMETHOD_IO_URING_ENABLED
37 IOMETHOD_IO_URING,
38#endif
39} IoMethod;
IoMethod
Definition: aio.h:33
@ IOMETHOD_WORKER
Definition: aio.h:35
@ IOMETHOD_SYNC
Definition: aio.h:34

◆ PgAioHandleCallbackID

enum PgAioHandleCallbackID
Enumerator
PGAIO_HCB_INVALID 
PGAIO_HCB_MD_READV 
PGAIO_HCB_SHARED_BUFFER_READV 
PGAIO_HCB_LOCAL_BUFFER_READV 

Definition at line 192 of file aio.h.

193{
195
197
199
PgAioHandleCallbackID
Definition: aio.h:193
@ PGAIO_HCB_MD_READV
Definition: aio.h:196
@ PGAIO_HCB_LOCAL_BUFFER_READV
Definition: aio.h:200
@ PGAIO_HCB_SHARED_BUFFER_READV
Definition: aio.h:198
@ PGAIO_HCB_INVALID
Definition: aio.h:194

◆ PgAioHandleFlags

enum PgAioHandleFlags
Enumerator
PGAIO_HF_REFERENCES_LOCAL 
PGAIO_HF_SYNCHRONOUS 
PGAIO_HF_BUFFERED 

Definition at line 48 of file aio.h.

49{
50 /*
51 * The IO references backend local memory.
52 *
53 * This needs to be set on an IO whenever the IO references process-local
54 * memory. Some IO methods do not support executing IO that references
55 * process local memory and thus need to fall back to executing IO
56 * synchronously for IOs with this flag set.
57 *
58 * Required for correctness.
59 */
61
62 /*
63 * Hint that IO will be executed synchronously.
64 *
65 * This can make it a bit cheaper to execute synchronous IO via the AIO
66 * interface, to avoid needing an AIO and non-AIO version of code.
67 *
68 * Advantageous to set, if applicable, but not required for correctness.
69 */
70 PGAIO_HF_SYNCHRONOUS = 1 << 0,
71
72 /*
73 * IO is using buffered IO, used to control heuristic in some IO methods.
74 *
75 * Advantageous to set, if applicable, but not required for correctness.
76 */
77 PGAIO_HF_BUFFERED = 1 << 2,
PgAioHandleFlags
Definition: aio.h:49
@ PGAIO_HF_SYNCHRONOUS
Definition: aio.h:70
@ PGAIO_HF_REFERENCES_LOCAL
Definition: aio.h:60
@ PGAIO_HF_BUFFERED
Definition: aio.h:77

◆ PgAioOp

enum PgAioOp
Enumerator
PGAIO_OP_INVALID 
PGAIO_OP_READV 
PGAIO_OP_WRITEV 

Definition at line 87 of file aio.h.

88{
89 /* intentionally the zero value, to help catch zeroed memory etc */
91
94
105} PgAioOp;
PgAioOp
Definition: aio.h:88
@ PGAIO_OP_WRITEV
Definition: aio.h:93
@ PGAIO_OP_INVALID
Definition: aio.h:90
@ PGAIO_OP_READV
Definition: aio.h:92

◆ PgAioTargetID

enum PgAioTargetID
Enumerator
PGAIO_TID_INVALID 
PGAIO_TID_SMGR 

Definition at line 116 of file aio.h.

117{
118 /* intentionally the zero value, to help catch zeroed memory etc */
PgAioTargetID
Definition: aio.h:117
@ PGAIO_TID_SMGR
Definition: aio.h:120
@ PGAIO_TID_INVALID
Definition: aio.h:119

Function Documentation

◆ pgaio_closing_fd()

void pgaio_closing_fd ( int  fd )

Definition at line 1217 of file aio.c.

1218{
1219 /*
1220 * Might be called before AIO is initialized or in a subprocess that
1221 * doesn't use AIO.
1222 */
1223 if (!pgaio_my_backend)
1224 return;
1225
1226 /*
1227 * For now just submit all staged IOs - we could be more selective, but
1228 * it's probably not worth it.
1229 */
1231 {
1233 "submitting %d IOs before FD %d gets closed",
1236 }
1237
1238 /*
1239 * If requested by the IO method, wait for all IOs that use the
1240 * to-be-closed FD.
1241 */
1243 {
1244 /*
1245 * As waiting for one IO to complete may complete multiple IOs, we
1246 * can't just use a mutable list iterator. The maximum number of
1247 * in-flight IOs is fairly small, so just restart the loop after
1248 * waiting for an IO.
1249 */
1251 {
1252 dlist_iter iter;
1253 PgAioHandle *ioh = NULL;
1254 uint64 generation;
1255
1257 {
1258 ioh = dclist_container(PgAioHandle, node, iter.cur);
1259
1260 generation = ioh->generation;
1261
1262 if (pgaio_io_uses_fd(ioh, fd))
1263 break;
1264 else
1265 ioh = NULL;
1266 }
1267
1268 if (!ioh)
1269 break;
1270
1272 "waiting for IO before FD %d gets closed, %u in-flight IOs",
1274
1275 /* see comment in pgaio_io_wait_for_free() about raciness */
1276 pgaio_io_wait(ioh, generation);
1277 }
1278 }
1279}
PgAioBackend * pgaio_my_backend
Definition: aio.c:81
const IoMethodOps * pgaio_method_ops
Definition: aio.c:93
void pgaio_submit_staged(void)
Definition: aio.c:1120
static void pgaio_io_wait(PgAioHandle *ioh, uint64 ref_generation)
Definition: aio.c:576
#define pgaio_debug(elevel, msg,...)
Definition: aio_internal.h:382
#define pgaio_debug_io(elevel, ioh, msg,...)
Definition: aio_internal.h:395
bool pgaio_io_uses_fd(PgAioHandle *ioh, int fd)
Definition: aio_io.c:197
uint64_t uint64
Definition: c.h:539
#define DEBUG2
Definition: elog.h:29
#define dclist_container(type, membername, ptr)
Definition: ilist.h:947
static uint32 dclist_count(const dclist_head *head)
Definition: ilist.h:932
static bool dclist_is_empty(const dclist_head *head)
Definition: ilist.h:682
#define dclist_foreach(iter, lhead)
Definition: ilist.h:970
static int fd(const char *x, int i)
Definition: preproc-init.c:105
bool wait_on_fd_before_close
Definition: aio_internal.h:268
dclist_head in_flight_ios
Definition: aio_internal.h:225
uint16 num_staged_ios
Definition: aio_internal.h:214
uint64 generation
Definition: aio_internal.h:152
Definition: ilist.h:178
dlist_node * cur
Definition: ilist.h:179

References dlist_iter::cur, dclist_container, dclist_count(), dclist_foreach, dclist_is_empty(), DEBUG2, fd(), PgAioHandle::generation, 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 1078 of file aio.c.

1079{
1081 elog(ERROR, "starting batch while batch already in progress");
1083}
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
bool in_batchmode
Definition: aio_internal.h:209

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

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

◆ pgaio_exit_batchmode()

void pgaio_exit_batchmode ( void  )

Definition at line 1089 of file aio.c.

1090{
1092
1095}
Assert(PointerIsAligned(start, uint64))

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

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

160{
161 PgAioHandle *h;
162
163 while (true)
164 {
165 h = pgaio_io_acquire_nb(resowner, ret);
166
167 if (h != NULL)
168 return h;
169
170 /*
171 * Evidently all handles by this backend are in use. Just wait for
172 * some to complete.
173 */
175 }
176}
static void pgaio_io_wait_for_free(void)
Definition: aio.c:758
PgAioHandle * pgaio_io_acquire_nb(struct ResourceOwnerData *resowner, PgAioReturn *ret)
Definition: aio.c:185

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

186{
187 PgAioHandle *ioh = NULL;
188
190 {
193 }
194
196 elog(ERROR, "API violation: Only one IO can be handed out");
197
198 /*
199 * Probably not needed today, as interrupts should not process this IO,
200 * but...
201 */
203
205 {
207
208 ioh = dclist_container(PgAioHandle, node, ion);
209
210 Assert(ioh->state == PGAIO_HS_IDLE);
212
215
216 if (resowner)
218
219 if (ret)
220 {
221 ioh->report_return = ret;
223 }
224 }
225
227
228 return ioh;
229}
static void pgaio_io_update_state(PgAioHandle *ioh, PgAioHandleState new_state)
Definition: aio.c:383
static void pgaio_io_resowner_register(PgAioHandle *ioh)
Definition: aio.c:406
@ PGAIO_HS_IDLE
Definition: aio_internal.h:46
@ PGAIO_HS_HANDED_OUT
Definition: aio_internal.h:53
#define PGAIO_SUBMIT_BATCH_SIZE
Definition: aio_internal.h:28
@ PGAIO_RS_UNKNOWN
Definition: aio_types.h:80
ProcNumber MyProcNumber
Definition: globals.c:90
static dlist_node * dclist_pop_head_node(dclist_head *head)
Definition: ilist.h:789
#define RESUME_INTERRUPTS()
Definition: miscadmin.h:135
#define HOLD_INTERRUPTS()
Definition: miscadmin.h:133
dclist_head idle_ios
Definition: aio_internal.h:197
PgAioHandle * handed_out_io
Definition: aio_internal.h:206
int32 owner_procno
Definition: aio_internal.h:131
PgAioReturn * report_return
Definition: aio_internal.h:177
uint8 state
Definition: aio_internal.h:105
uint32 status
Definition: aio_types.h:108
PgAioResult result
Definition: aio_types.h:132
Definition: ilist.h:138

References Assert(), dclist_container, dclist_is_empty(), dclist_pop_head_node(), elog, ERROR, PgAioBackend::handed_out_io, HOLD_INTERRUPTS, PgAioBackend::idle_ios, MyProcNumber, PgAioBackend::num_staged_ios, PgAioHandle::owner_procno, 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(), PgAioHandle::report_return, PgAioReturn::result, RESUME_INTERRUPTS, PgAioHandle::state, and PgAioResult::status.

Referenced by AsyncReadBuffers(), and pgaio_io_acquire().

◆ pgaio_io_get_handle_data()

uint64 * pgaio_io_get_handle_data ( PgAioHandle *  ioh,
uint8 *  len 
)

Definition at line 156 of file aio_callback.c.

157{
158 Assert(ioh->handle_data_len > 0);
159
160 *len = ioh->handle_data_len;
161
162 return &pgaio_ctl->handle_data[ioh->iovec_off];
163}
PgAioCtl * pgaio_ctl
Definition: aio.c:78
const void size_t len
uint64 * handle_data
Definition: aio_internal.h:249
uint8 handle_data_len
Definition: aio_internal.h:128
uint32 iovec_off
Definition: aio_internal.h:170

References Assert(), PgAioCtl::handle_data, PgAioHandle::handle_data_len, PgAioHandle::iovec_off, len, and pgaio_ctl.

Referenced by buffer_readv_complete(), and buffer_stage_common().

◆ pgaio_io_get_id()

int pgaio_io_get_id ( PgAioHandle *  ioh )

Definition at line 339 of file aio.c.

340{
341 Assert(ioh >= pgaio_ctl->io_handles &&
343 return ioh - pgaio_ctl->io_handles;
344}
PgAioHandle * io_handles
Definition: aio_internal.h:252
uint32 io_handle_count
Definition: aio_internal.h:251

References Assert(), 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_iovec()

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

Definition at line 42 of file aio_io.c.

43{
45
46 *iov = &pgaio_ctl->iovecs[ioh->iovec_off];
47
48 return PG_IOV_MAX;
49}
#define PG_IOV_MAX
Definition: pg_iovec.h:47
struct iovec * iovecs
Definition: aio_internal.h:240

References Assert(), PgAioHandle::iovec_off, PgAioCtl::iovecs, PG_IOV_MAX, pgaio_ctl, PGAIO_HS_HANDED_OUT, and PgAioHandle::state.

Referenced by mdstartreadv().

◆ pgaio_io_get_op()

PgAioOp pgaio_io_get_op ( PgAioHandle *  ioh )

Definition at line 52 of file aio_io.c.

53{
54 return ioh->op;
55}
uint8 op
Definition: aio_internal.h:111

References PgAioHandle::op.

Referenced by smgr_aio_reopen().

◆ pgaio_io_get_op_data()

PgAioOpData * pgaio_io_get_op_data ( PgAioHandle *  ioh )

Definition at line 58 of file aio_io.c.

59{
60 return &ioh->op_data;
61}
PgAioOpData op_data
Definition: aio_internal.h:180

References PgAioHandle::op_data.

Referenced by smgr_aio_reopen().

◆ pgaio_io_get_owner()

ProcNumber pgaio_io_get_owner ( PgAioHandle *  ioh )

Definition at line 352 of file aio.c.

353{
354 return ioh->owner_procno;
355}

References PgAioHandle::owner_procno.

Referenced by buffer_readv_complete(), and smgr_aio_reopen().

◆ pgaio_io_get_target_data()

PgAioTargetData * pgaio_io_get_target_data ( PgAioHandle *  ioh )

Definition at line 73 of file aio_target.c.

74{
75 return &ioh->target_data;
76}
PgAioTargetData target_data
Definition: aio_internal.h:187

References PgAioHandle::target_data.

Referenced by buffer_readv_complete(), md_readv_complete(), pgaio_io_set_target_smgr(), shared_buffer_readv_complete_local(), and smgr_aio_reopen().

◆ pgaio_io_get_target_description()

char * pgaio_io_get_target_description ( PgAioHandle *  ioh )

Definition at line 84 of file aio_target.c.

85{
86 /* disallow INVALID, there wouldn't be a description */
88
90}
#define PGAIO_TID_COUNT
Definition: aio.h:123
static const PgAioTargetInfo * pgaio_target_info[]
Definition: aio_target.c:25
uint8 target
Definition: aio_internal.h:108
char *(* describe_identity)(const PgAioTargetData *sd)
Definition: aio.h:167

References Assert(), PgAioTargetInfo::describe_identity, pgaio_target_info, PGAIO_TID_COUNT, PGAIO_TID_INVALID, PgAioHandle::target, and PgAioHandle::target_data.

Referenced by pg_get_aios().

◆ pgaio_io_get_wref()

void pgaio_io_get_wref ( PgAioHandle *  ioh,
PgAioWaitRef *  iow 
)

Definition at line 363 of file aio.c.

364{
366 ioh->state == PGAIO_HS_DEFINED ||
367 ioh->state == PGAIO_HS_STAGED);
368 Assert(ioh->generation != 0);
369
370 iow->aio_index = ioh - pgaio_ctl->io_handles;
371 iow->generation_upper = (uint32) (ioh->generation >> 32);
372 iow->generation_lower = (uint32) ioh->generation;
373}
@ PGAIO_HS_STAGED
Definition: aio_internal.h:66
@ PGAIO_HS_DEFINED
Definition: aio_internal.h:59
uint32_t uint32
Definition: c.h:538
uint32 generation_upper
Definition: aio_types.h:45
uint32 aio_index
Definition: aio_types.h:35
uint32 generation_lower
Definition: aio_types.h:46

References PgAioWaitRef::aio_index, Assert(), PgAioHandle::generation, PgAioWaitRef::generation_lower, PgAioWaitRef::generation_upper, PgAioCtl::io_handles, pgaio_ctl, PGAIO_HS_DEFINED, PGAIO_HS_HANDED_OUT, PGAIO_HS_STAGED, and PgAioHandle::state.

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

◆ pgaio_io_has_target()

bool pgaio_io_has_target ( PgAioHandle *  ioh )

Definition at line 40 of file aio_target.c.

41{
42 return ioh->target != PGAIO_TID_INVALID;
43}

References PGAIO_TID_INVALID, and PgAioHandle::target.

Referenced by pgaio_io_before_start(), and pgaio_io_stage().

◆ pgaio_io_register_callbacks()

void pgaio_io_register_callbacks ( PgAioHandle *  ioh,
PgAioHandleCallbackID  cb_id,
uint8  cb_data 
)

Definition at line 86 of file aio_callback.c.

88{
89 const PgAioHandleCallbacksEntry *ce = &aio_handle_cbs[cb_id];
90
91 Assert(cb_id <= PGAIO_HCB_MAX);
92 if (cb_id >= lengthof(aio_handle_cbs))
93 elog(ERROR, "callback %d is out of range", cb_id);
94 if (aio_handle_cbs[cb_id].cb->complete_shared == NULL &&
95 aio_handle_cbs[cb_id].cb->complete_local == NULL)
96 elog(ERROR, "callback %d does not have a completion callback", cb_id);
98 elog(PANIC, "too many callbacks, the max is %d",
100 ioh->callbacks[ioh->num_callbacks] = cb_id;
101 ioh->callbacks_data[ioh->num_callbacks] = cb_data;
102
104 "adding cb #%d, id %d/%s",
105 ioh->num_callbacks + 1,
106 cb_id, ce->name);
107
108 ioh->num_callbacks++;
109}
#define PGAIO_HANDLE_MAX_CALLBACKS
Definition: aio.h:267
#define PGAIO_HCB_MAX
Definition: aio.h:203
static const PgAioHandleCallbacksEntry aio_handle_cbs[]
Definition: aio_callback.c:39
#define lengthof(array)
Definition: c.h:787
#define DEBUG3
Definition: elog.h:28
#define PANIC
Definition: elog.h:42
const PgAioHandleCallbacks *const cb
Definition: aio_callback.c:30
const char *const name
Definition: aio_callback.c:31
PgAioHandleCallbackComplete complete_local
Definition: aio.h:251
uint8 callbacks[PGAIO_HANDLE_MAX_CALLBACKS]
Definition: aio_internal.h:119
uint8 callbacks_data[PGAIO_HANDLE_MAX_CALLBACKS]
Definition: aio_internal.h:122
uint8 num_callbacks
Definition: aio_internal.h:116

References aio_handle_cbs, Assert(), PgAioHandle::callbacks, PgAioHandle::callbacks_data, PgAioHandleCallbacksEntry::cb, PgAioHandleCallbacks::complete_local, DEBUG3, elog, ERROR, lengthof, PgAioHandleCallbacksEntry::name, PgAioHandle::num_callbacks, PANIC, pgaio_debug_io, PGAIO_HANDLE_MAX_CALLBACKS, and PGAIO_HCB_MAX.

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

◆ pgaio_io_release()

void pgaio_io_release ( PgAioHandle *  ioh )

Definition at line 237 of file aio.c.

238{
240 {
242 Assert(ioh->resowner);
243
245
246 /*
247 * Note that no interrupts are processed between the handed_out_io
248 * check and the call to reclaim - that's important as otherwise an
249 * interrupt could have already reclaimed the handle.
250 */
251 pgaio_io_reclaim(ioh);
252 }
253 else
254 {
255 elog(ERROR, "release in unexpected state");
256 }
257}
static void pgaio_io_reclaim(PgAioHandle *ioh)
Definition: aio.c:672
struct ResourceOwnerData * resowner
Definition: aio_internal.h:148

References Assert(), elog, ERROR, PgAioBackend::handed_out_io, PGAIO_HS_HANDED_OUT, pgaio_io_reclaim(), pgaio_my_backend, PgAioHandle::resowner, and PgAioHandle::state.

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

◆ pgaio_io_release_resowner()

void pgaio_io_release_resowner ( struct dlist_node *  ioh_node,
bool  on_error 
)

Definition at line 263 of file aio.c.

264{
265 PgAioHandle *ioh = dlist_container(PgAioHandle, resowner_node, ioh_node);
266
267 Assert(ioh->resowner);
268
269 /*
270 * Otherwise an interrupt, in the middle of releasing the IO, could end up
271 * trying to wait for the IO, leading to state confusion.
272 */
274
276 ioh->resowner = NULL;
277
278 switch ((PgAioHandleState) ioh->state)
279 {
280 case PGAIO_HS_IDLE:
281 elog(ERROR, "unexpected");
282 break;
285
287 {
289 if (!on_error)
290 elog(WARNING, "leaked AIO handle");
291 }
292
293 pgaio_io_reclaim(ioh);
294 break;
295 case PGAIO_HS_DEFINED:
296 case PGAIO_HS_STAGED:
297 if (!on_error)
298 elog(WARNING, "AIO handle was not submitted");
300 break;
305 /* this is expected to happen */
306 break;
307 }
308
309 /*
310 * Need to unregister the reporting of the IO's result, the memory it's
311 * referencing likely has gone away.
312 */
313 if (ioh->report_return)
314 ioh->report_return = NULL;
315
317}
PgAioHandleState
Definition: aio_internal.h:44
@ PGAIO_HS_COMPLETED_SHARED
Definition: aio_internal.h:82
@ PGAIO_HS_SUBMITTED
Definition: aio_internal.h:69
@ PGAIO_HS_COMPLETED_IO
Definition: aio_internal.h:72
@ PGAIO_HS_COMPLETED_LOCAL
Definition: aio_internal.h:89
#define WARNING
Definition: elog.h:36
#define dlist_container(type, membername, ptr)
Definition: ilist.h:593
void ResourceOwnerForgetAioHandle(ResourceOwner owner, struct dlist_node *ioh_node)
Definition: resowner.c:1107
dlist_node resowner_node
Definition: aio_internal.h:149

References Assert(), dlist_container, elog, ERROR, 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(), PgAioHandle::report_return, ResourceOwnerForgetAioHandle(), PgAioHandle::resowner, PgAioHandle::resowner_node, RESUME_INTERRUPTS, PgAioHandle::state, and WARNING.

Referenced by ResourceOwnerReleaseInternal().

◆ pgaio_io_set_flag()

void pgaio_io_set_flag ( PgAioHandle *  ioh,
PgAioHandleFlags  flag 
)

Definition at line 327 of file aio.c.

328{
330
331 ioh->flags |= flag;
332}
uint8 flags
Definition: aio_internal.h:114
char * flag(int b)
Definition: test-ctype.c:33

References Assert(), flag(), PgAioHandle::flags, PGAIO_HS_HANDED_OUT, and PgAioHandle::state.

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

◆ pgaio_io_set_handle_data_32()

void pgaio_io_set_handle_data_32 ( PgAioHandle *  ioh,
uint32 *  data,
uint8  len 
)

Definition at line 140 of file aio_callback.c.

141{
143 Assert(ioh->handle_data_len == 0);
146
147 for (int i = 0; i < len; i++)
149 ioh->handle_data_len = len;
150}
int io_max_combine_limit
Definition: bufmgr.c:172
i
int i
Definition: isn.c:77
const void * data

References Assert(), data, PgAioCtl::handle_data, PgAioHandle::handle_data_len, i, io_max_combine_limit, PgAioHandle::iovec_off, len, PG_IOV_MAX, pgaio_ctl, PGAIO_HS_HANDED_OUT, and PgAioHandle::state.

Referenced by AsyncReadBuffers(), and read_rel_block_ll().

◆ pgaio_io_set_handle_data_64()

void pgaio_io_set_handle_data_64 ( PgAioHandle *  ioh,
uint64 *  data,
uint8  len 
)

Definition at line 122 of file aio_callback.c.

123{
125 Assert(ioh->handle_data_len == 0);
128
129 for (int i = 0; i < len; i++)
131 ioh->handle_data_len = len;
132}

References Assert(), data, PgAioCtl::handle_data, PgAioHandle::handle_data_len, i, io_max_combine_limit, PgAioHandle::iovec_off, len, PG_IOV_MAX, pgaio_ctl, PGAIO_HS_HANDED_OUT, and PgAioHandle::state.

◆ pgaio_io_set_target()

void pgaio_io_set_target ( PgAioHandle *  ioh,
PgAioTargetID  targetid 
)

Definition at line 64 of file aio_target.c.

65{
68
69 ioh->target = targetid;
70}

References Assert(), PGAIO_HS_HANDED_OUT, PGAIO_TID_INVALID, PgAioHandle::state, and PgAioHandle::target.

Referenced by pgaio_io_set_target_smgr().

◆ pgaio_io_start_readv()

void pgaio_io_start_readv ( PgAioHandle *  ioh,
int  fd,
int  iovcnt,
uint64  offset 
)

Definition at line 78 of file aio_io.c.

80{
82
83 ioh->op_data.read.fd = fd;
84 ioh->op_data.read.offset = offset;
85 ioh->op_data.read.iov_length = iovcnt;
86
88}
void pgaio_io_stage(PgAioHandle *ioh, PgAioOp op)
Definition: aio.c:421
static void pgaio_io_before_start(PgAioHandle *ioh)
Definition: aio_io.c:156
uint64 offset
Definition: aio.h:140
int fd
Definition: aio.h:138
uint16 iov_length
Definition: aio.h:139
struct PgAioOpData::@126 read

References PgAioOpData::fd, fd(), PgAioOpData::iov_length, PgAioOpData::offset, PgAioHandle::op_data, pgaio_io_before_start(), pgaio_io_stage(), PGAIO_OP_READV, and PgAioOpData::read.

Referenced by FileStartReadV().

◆ pgaio_io_start_writev()

void pgaio_io_start_writev ( PgAioHandle *  ioh,
int  fd,
int  iovcnt,
uint64  offset 
)

Definition at line 91 of file aio_io.c.

93{
95
96 ioh->op_data.write.fd = fd;
97 ioh->op_data.write.offset = offset;
98 ioh->op_data.write.iov_length = iovcnt;
99
101}
struct PgAioOpData::@127 write

References PgAioOpData::fd, fd(), PgAioOpData::iov_length, PgAioOpData::offset, PgAioHandle::op_data, pgaio_io_before_start(), pgaio_io_stage(), PGAIO_OP_WRITEV, and PgAioOpData::write.

◆ pgaio_result_report()

void pgaio_result_report ( PgAioResult  result,
const PgAioTargetData *  target_data,
int  elevel 
)

Definition at line 173 of file aio_callback.c.

174{
175 PgAioHandleCallbackID cb_id = result.id;
176 const PgAioHandleCallbacksEntry *ce = &aio_handle_cbs[cb_id];
177
178 Assert(result.status != PGAIO_RS_UNKNOWN);
179 Assert(result.status != PGAIO_RS_OK);
180
181 if (ce->cb->report == NULL)
182 elog(ERROR, "callback %d/%s does not have report callback",
183 result.id, ce->name);
184
185 ce->cb->report(result, target_data, elevel);
186}
@ PGAIO_RS_OK
Definition: aio_types.h:81
PgAioHandleCallbackReport report
Definition: aio.h:258
uint32 id
Definition: aio_types.h:105

References aio_handle_cbs, Assert(), PgAioHandleCallbacksEntry::cb, elog, ERROR, PgAioResult::id, PgAioHandleCallbacksEntry::name, PGAIO_RS_OK, PGAIO_RS_UNKNOWN, PgAioHandleCallbacks::report, and PgAioResult::status.

Referenced by buffer_readv_complete(), buffer_readv_complete_one(), md_readv_complete(), ProcessReadBuffersResult(), and read_rel_block_ll().

◆ pgaio_submit_staged()

void pgaio_submit_staged ( void  )

Definition at line 1120 of file aio.c.

1121{
1122 int total_submitted = 0;
1123 int did_submit;
1124
1126 return;
1127
1128
1130
1133
1135
1136 total_submitted += did_submit;
1137
1138 Assert(total_submitted == did_submit);
1139
1141
1143 "aio: submitted %d IOs",
1144 total_submitted);
1145}
#define DEBUG4
Definition: elog.h:27
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
int(* submit)(uint16 num_staged_ios, PgAioHandle **staged_ios)
Definition: aio_internal.h:308
PgAioHandle * staged_ios[PGAIO_SUBMIT_BATCH_SIZE]
Definition: aio_internal.h:215

References Assert(), DEBUG4, END_CRIT_SECTION, 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 1002 of file aio.c.

1003{
1004 uint64 ref_generation;
1006 bool am_owner;
1007 PgAioHandle *ioh;
1008
1009 ioh = pgaio_io_from_wref(iow, &ref_generation);
1010
1011 if (pgaio_io_was_recycled(ioh, ref_generation, &state))
1012 return true;
1013
1014 if (state == PGAIO_HS_IDLE)
1015 return true;
1016
1017 am_owner = ioh->owner_procno == MyProcNumber;
1018
1021 {
1022 /*
1023 * Note that no interrupts are processed between
1024 * pgaio_io_was_recycled() and this check - that's important as
1025 * otherwise an interrupt could have already reclaimed the handle.
1026 */
1027 if (am_owner)
1028 pgaio_io_reclaim(ioh);
1029 return true;
1030 }
1031
1032 /*
1033 * XXX: It likely would be worth checking in with the io method, to give
1034 * the IO method a chance to check if there are completion events queued.
1035 */
1036
1037 return false;
1038}
static PgAioHandle * pgaio_io_from_wref(PgAioWaitRef *iow, uint64 *ref_generation)
Definition: aio.c:888
bool pgaio_io_was_recycled(PgAioHandle *ioh, uint64 ref_generation, PgAioHandleState *state)
Definition: aio.c:556
Definition: regguts.h:323

References MyProcNumber, PgAioHandle::owner_procno, 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 961 of file aio.c.

962{
964}
#define PG_UINT32_MAX
Definition: c.h:595

References PgAioWaitRef::aio_index, 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 977 of file aio.c.

978{
980 return iow->aio_index;
981}
bool pgaio_wref_valid(PgAioWaitRef *iow)
Definition: aio.c:968

References PgAioWaitRef::aio_index, Assert(), and pgaio_wref_valid().

◆ pgaio_wref_valid()

bool pgaio_wref_valid ( PgAioWaitRef *  iow )

Definition at line 968 of file aio.c.

969{
970 return iow->aio_index != PG_UINT32_MAX;
971}

References PgAioWaitRef::aio_index, 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 988 of file aio.c.

989{
990 uint64 ref_generation;
991 PgAioHandle *ioh;
992
993 ioh = pgaio_io_from_wref(iow, &ref_generation);
994
995 pgaio_io_wait(ioh, ref_generation);
996}

References pgaio_io_from_wref(), and pgaio_io_wait().

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

◆ StaticAssertDecl()

StaticAssertDecl ( )

Variable Documentation

◆ io_max_concurrency

PGDLLIMPORT int io_max_concurrency
extern

◆ io_method

PGDLLIMPORT int io_method
extern

AltStyle によって変換されたページ (->オリジナル) /