Debian Codegraph @

src/backend/storage/aio/aio_io.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * aio_io.c
4 * AIO - Low Level IO Handling
5 *
6 * Functions related to associating IO operations to IO Handles and IO-method
7 * independent support functions for actually performing IO.
8 *
9 *
10 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
11 * Portions Copyright (c) 1994, Regents of the University of California
12 *
13 * IDENTIFICATION
14 * src/backend/storage/aio/aio_io.c
15 *
16 *-------------------------------------------------------------------------
17 */
18
19 #include "postgres.h"
20
21 #include "miscadmin.h"
22 #include "storage/aio.h"
23 #include "storage/aio_internal.h"
24 #include "storage/fd.h"
25 #include "utils/wait_event.h"
26
27
28 static void pgaio_io_before_start(PgAioHandle *ioh);
29
30
31
32 /* --------------------------------------------------------------------------------
33 * Public IO related functions operating on IO Handles
34 * --------------------------------------------------------------------------------
35 */
36
37 /*
38 * Scatter/gather IO needs to associate an iovec with the Handle. To support
39 * worker mode this data needs to be in shared memory.
40 */
41 int
42 pgaio_io_get_iovec(PgAioHandle *ioh, struct iovec **iov)
43 {
44 Assert(ioh->state == PGAIO_HS_HANDED_OUT);
45
46 *iov = &pgaio_ctl->iovecs[ioh->iovec_off];
47
48 return PG_IOV_MAX;
49 }
50
51 PgAioOp
52 pgaio_io_get_op(PgAioHandle *ioh)
53 {
54 return ioh->op;
55 }
56
57 PgAioOpData *
58 pgaio_io_get_op_data(PgAioHandle *ioh)
59 {
60 return &ioh->op_data;
61 }
62
63
64
65 /* --------------------------------------------------------------------------------
66 * "Start" routines for individual IO operations
67 *
68 * These are called by the code actually initiating an IO, to associate the IO
69 * specific data with an AIO handle.
70 *
71 * Each of the "start" routines first needs to call pgaio_io_before_start(),
72 * then fill IO specific fields in the handle and then finally call
73 * pgaio_io_stage().
74 * --------------------------------------------------------------------------------
75 */
76
77 void
78 pgaio_io_start_readv(PgAioHandle *ioh,
79 int fd, int iovcnt, uint64 offset)
80 {
81 pgaio_io_before_start(ioh);
82
83 ioh->op_data.read.fd = fd;
84 ioh->op_data.read.offset = offset;
85 ioh->op_data.read.iov_length = iovcnt;
86
87 pgaio_io_stage(ioh, PGAIO_OP_READV);
88 }
89
90 void
91 pgaio_io_start_writev(PgAioHandle *ioh,
92 int fd, int iovcnt, uint64 offset)
93 {
94 pgaio_io_before_start(ioh);
95
96 ioh->op_data.write.fd = fd;
97 ioh->op_data.write.offset = offset;
98 ioh->op_data.write.iov_length = iovcnt;
99
100 pgaio_io_stage(ioh, PGAIO_OP_WRITEV);
101 }
102
103
104
105 /* --------------------------------------------------------------------------------
106 * Internal IO related functions operating on IO Handles
107 * --------------------------------------------------------------------------------
108 */
109
110 /*
111 * Execute IO operation synchronously. This is implemented here, not in
112 * method_sync.c, because other IO methods also might use it / fall back to
113 * it.
114 */
115 void
116 pgaio_io_perform_synchronously(PgAioHandle *ioh)
117 {
118 ssize_t result = 0;
119 struct iovec *iov = &pgaio_ctl->iovecs[ioh->iovec_off];
120
121 START_CRIT_SECTION();
122
123 /* Perform IO. */
124 switch ((PgAioOp) ioh->op)
125 {
126 case PGAIO_OP_READV:
127 pgstat_report_wait_start(WAIT_EVENT_DATA_FILE_READ);
128 result = pg_preadv(ioh->op_data.read.fd, iov,
129 ioh->op_data.read.iov_length,
130 ioh->op_data.read.offset);
131 pgstat_report_wait_end();
132 break;
133 case PGAIO_OP_WRITEV:
134 pgstat_report_wait_start(WAIT_EVENT_DATA_FILE_WRITE);
135 result = pg_pwritev(ioh->op_data.write.fd, iov,
136 ioh->op_data.write.iov_length,
137 ioh->op_data.write.offset);
138 pgstat_report_wait_end();
139 break;
140 case PGAIO_OP_INVALID:
141 elog(ERROR, "trying to execute invalid IO operation");
142 }
143
144 ioh->result = result < 0 ? -errno : result;
145
146 pgaio_io_process_completion(ioh, ioh->result);
147
148 END_CRIT_SECTION();
149 }
150
151 /*
152 * Helper function to be called by IO operation preparation functions, before
153 * any data in the handle is set. Mostly to centralize assertions.
154 */
155 static void
156 pgaio_io_before_start(PgAioHandle *ioh)
157 {
158 Assert(ioh->state == PGAIO_HS_HANDED_OUT);
159 Assert(pgaio_my_backend->handed_out_io == ioh);
160 Assert(pgaio_io_has_target(ioh));
161 Assert(ioh->op == PGAIO_OP_INVALID);
162
163 /*
164 * Otherwise the FDs referenced by the IO could be closed due to interrupt
165 * processing.
166 */
167 Assert(!INTERRUPTS_CAN_BE_PROCESSED());
168 }
169
170 /*
171 * Could be made part of the public interface, but it's not clear there's
172 * really a use case for that.
173 */
174 const char *
175 pgaio_io_get_op_name(PgAioHandle *ioh)
176 {
177 Assert(ioh->op >= 0 && ioh->op < PGAIO_OP_COUNT);
178
179 switch ((PgAioOp) ioh->op)
180 {
181 case PGAIO_OP_INVALID:
182 return "invalid";
183 case PGAIO_OP_READV:
184 return "readv";
185 case PGAIO_OP_WRITEV:
186 return "writev";
187 }
188
189 return NULL; /* silence compiler */
190 }
191
192 /*
193 * Used to determine if an IO needs to be waited upon before the file
194 * descriptor can be closed.
195 */
196 bool
197 pgaio_io_uses_fd(PgAioHandle *ioh, int fd)
198 {
199 Assert(ioh->state >= PGAIO_HS_DEFINED);
200
201 switch ((PgAioOp) ioh->op)
202 {
203 case PGAIO_OP_READV:
204 return ioh->op_data.read.fd == fd;
205 case PGAIO_OP_WRITEV:
206 return ioh->op_data.write.fd == fd;
207 case PGAIO_OP_INVALID:
208 return false;
209 }
210
211 return false; /* silence compiler */
212 }
213
214 /*
215 * Return the iovec and its length. Currently only expected to be used by
216 * debugging infrastructure
217 */
218 int
219 pgaio_io_get_iovec_length(PgAioHandle *ioh, struct iovec **iov)
220 {
221 Assert(ioh->state >= PGAIO_HS_DEFINED);
222
223 *iov = &pgaio_ctl->iovecs[ioh->iovec_off];
224
225 switch ((PgAioOp) ioh->op)
226 {
227 case PGAIO_OP_READV:
228 return ioh->op_data.read.iov_length;
229 case PGAIO_OP_WRITEV:
230 return ioh->op_data.write.iov_length;
231 default:
232 pg_unreachable();
233 return 0;
234 }
235 }