[ViewVC] Diff of: cvs/libev/ev

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.15 by root, Mon Jun 24 00:04:26 2019 UTC vs.
Revision 1.24 by root, Mon Jun 24 22:27:29 2019 UTC

…		…
53	* therefore the calculation below will use "exactly" 4kB for the ring buffer	53	* therefore the calculation below will use "exactly" 4kB for the ring buffer
54	*/	54	*/
55	#define EV_LINUXAIO_DEPTH (128 / 2 - 2 - 1) /* max. number of io events per batch */	55	#define EV_LINUXAIO_DEPTH (128 / 2 - 2 - 1) /* max. number of io events per batch */
56		56
57	/*****************************************************************************/	57	/*****************************************************************************/
58	/* syscall wrapdadoop */	58	/* syscall wrapdadoop - this section has the raw syscall definitions */
59		59
60	#include <sys/syscall.h> /* no glibc wrappers */	60	#include <sys/syscall.h> /* no glibc wrappers */
61		61
62	/* aio_abi.h is not versioned in any way, so we cannot test for its existance */	62	/* aio_abi.h is not versioned in any way, so we cannot test for its existance */
63	#define IOCB_CMD_POLL 5	63	#define IOCB_CMD_POLL 5
…		…
80	struct io_event io_events[0];	80	struct io_event io_events[0];
81	};	81	};
82		82
83	inline_size	83	inline_size
84	int	84	int
85	ev_io_setup (unsigned nr_events, aio_context_t *ctx_idp)	85	evsys_io_setup (unsigned nr_events, aio_context_t *ctx_idp)
86	{	86	{
87	return syscall (SYS_io_setup, nr_events, ctx_idp);	87	return syscall (SYS_io_setup, nr_events, ctx_idp);
88	}	88	}
89		89
90	inline_size	90	inline_size
91	int	91	int
92	ev_io_destroy (aio_context_t ctx_id)	92	evsys_io_destroy (aio_context_t ctx_id)
93	{	93	{
94	return syscall (SYS_io_destroy, ctx_id);	94	return syscall (SYS_io_destroy, ctx_id);
95	}	95	}
96		96
97	inline_size	97	inline_size
98	int	98	int
99	ev_io_submit (aio_context_t ctx_id, long nr, struct iocb *cbp[])	99	evsys_io_submit (aio_context_t ctx_id, long nr, struct iocb *cbp[])
100	{	100	{
101	return syscall (SYS_io_submit, ctx_id, nr, cbp);	101	return syscall (SYS_io_submit, ctx_id, nr, cbp);
102	}	102	}
103		103
104	inline_size	104	inline_size
105	int	105	int
106	ev_io_cancel (aio_context_t ctx_id, struct iocb cbp, struct io_event result)	106	evsys_io_cancel (aio_context_t ctx_id, struct iocb cbp, struct io_event result)
107	{	107	{
108	return syscall (SYS_io_cancel, ctx_id, cbp, result);	108	return syscall (SYS_io_cancel, ctx_id, cbp, result);
109	}	109	}
110		110
111	inline_size	111	inline_size
112	int	112	int
113	ev_io_getevents (aio_context_t ctx_id, long min_nr, long nr, struct io_event events, struct timespec timeout)	113	evsys_io_getevents (aio_context_t ctx_id, long min_nr, long nr, struct io_event events, struct timespec timeout)
114	{	114	{
115	return syscall (SYS_io_getevents, ctx_id, min_nr, nr, events, timeout);	115	return syscall (SYS_io_getevents, ctx_id, min_nr, nr, events, timeout);
116	}	116	}
117		117
118	/*****************************************************************************/	118	/*****************************************************************************/
…		…
125	/int inuse;/	125	/int inuse;/
126	} *ANIOCBP;	126	} *ANIOCBP;
127		127
128	inline_size	128	inline_size
129	void	129	void
130	linuxaio_array_needsize_iocbp (ANIOCBP *base, int count)	130	linuxaio_array_needsize_iocbp (ANIOCBP *base, int offset, int count)
131	{	131	{
132	/* TODO: quite the overhead to allocate every iocb separately, maybe use our own alocator? */
133	while (count--)	132	while (count--)
134	{	133	{
		134	/* TODO: quite the overhead to allocate every iocb separately, maybe use our own alocator? */
135	base = (ANIOCBP)ev_malloc (sizeof (*base));	135	ANIOCBP iocb = (ANIOCBP)ev_malloc (sizeof (*iocb));
136	/* TODO: full zero initialize required? */	136
		137	/* full zero initialise is probably not required at the moment, but
		138	* this is not well documented, so we better do it.
		139	*/
137	memset (base, 0, sizeof (*base));	140	memset (iocb, 0, sizeof (*iocb));
138	/* would be nice to initialize fd/data as well, but array_needsize API doesn't support that */	141
139	(*base)->io.aio_lio_opcode = IOCB_CMD_POLL;	142	iocb->io.aio_lio_opcode = IOCB_CMD_POLL;
140	++base;	143	iocb->io.aio_data = offset;
		144	iocb->io.aio_fildes = offset;
		145
		146	base [offset++] = iocb;
141	}	147	}
142	}	148	}
143		149
144	ecb_cold	150	ecb_cold
145	static void	151	static void
…		…
153		159
154	static void	160	static void
155	linuxaio_modify (EV_P_ int fd, int oev, int nev)	161	linuxaio_modify (EV_P_ int fd, int oev, int nev)
156	{	162	{
157	array_needsize (ANIOCBP, linuxaio_iocbps, linuxaio_iocbpmax, fd + 1, linuxaio_array_needsize_iocbp);	163	array_needsize (ANIOCBP, linuxaio_iocbps, linuxaio_iocbpmax, fd + 1, linuxaio_array_needsize_iocbp);
158	struct aniocb *iocb = linuxaio_iocbps [fd];	164	ANIOCBP iocb = linuxaio_iocbps [fd];
159		165
160	#if EPOLL_FALLBACK	166	#if EPOLL_FALLBACK
161	if (iocb->io.aio_reqprio < 0)	167	if (iocb->io.aio_reqprio < 0)
162	{	168	{
163	epoll_ctl (backend_fd, EPOLL_CTL_DEL, fd, 0);	169	epoll_ctl (backend_fd, EPOLL_CTL_DEL, fd, 0);
164	iocb->io.aio_reqprio = 0;	170	iocb->io.aio_reqprio = 0;
165	}	171	}
166	#endif	172	#endif
167		173
168	if (iocb->io.aio_buf)	174	if (iocb->io.aio_buf)
169	ev_io_cancel (linuxaio_ctx, &iocb->io, (struct io_event )0); / always returns an error relevant kernels */	175	evsys_io_cancel (linuxaio_ctx, &iocb->io, (struct io_event )0); / always returns an error relevant kernels */
170		176
171	if (nev)	177	if (nev)
172	{	178	{
173	iocb->io.aio_data = fd;
174	iocb->io.aio_fildes = fd;
175	iocb->io.aio_buf =	179	iocb->io.aio_buf =
176	(nev & EV_READ ? POLLIN : 0)	180	(nev & EV_READ ? POLLIN : 0)
177	\| (nev & EV_WRITE ? POLLOUT : 0);	181	\| (nev & EV_WRITE ? POLLOUT : 0);
178		182
179	/* queue iocb up for io_submit */	183	/* queue iocb up for io_submit */
180	/* this assumes we only ever get one call per fd per loop iteration */	184	/* this assumes we only ever get one call per fd per loop iteration */
…		…
182	array_needsize (struct iocb *, linuxaio_submits, linuxaio_submitmax, linuxaio_submitcnt, array_needsize_noinit);	186	array_needsize (struct iocb *, linuxaio_submits, linuxaio_submitmax, linuxaio_submitcnt, array_needsize_noinit);
183	linuxaio_submits [linuxaio_submitcnt - 1] = &iocb->io;	187	linuxaio_submits [linuxaio_submitcnt - 1] = &iocb->io;
184	}	188	}
185	}	189	}
186		190
		191	#if EPOLL_FALLBACK
		192
		193	static void
		194	linuxaio_rearm_epoll (EV_P_ struct iocb *iocb, int op)
		195	{
		196	struct epoll_event eev;
		197
		198	eev.events = EPOLLONESHOT;
		199	if (iocb->aio_buf & POLLIN ) eev.events \|= EPOLLIN ;
		200	if (iocb->aio_buf & POLLOUT) eev.events \|= EPOLLOUT;
		201	eev.data.fd = iocb->aio_fildes;
		202
		203	if (epoll_ctl (backend_fd, op, iocb->aio_fildes, &eev) < 0)
		204	ev_syserr ("(libeio) linuxaio epoll_ctl");
		205	}
		206
		207	static void
		208	linuxaio_epoll_cb (EV_P_ struct ev_io *w, int revents)
		209	{
		210	struct epoll_event events[16];
		211
		212	for (;;)
		213	{
		214	int idx;
		215	int res = epoll_wait (backend_fd, events, sizeof (events) / sizeof (events [0]), 0);
		216
		217	if (expect_false (res < 0))
		218	ev_syserr ("(libev) linuxaio epoll_wait");
		219	else if (!res)
		220	break;
		221
		222	for (idx = res; idx--; )
		223	{
		224	int fd = events [idx].data.fd;
		225	uint32_t ev = events [idx].events;
		226
		227	assert (("libev: iocb fd must be in-bounds", fd >= 0 && fd < anfdmax));
		228
		229	linuxaio_rearm_epoll (EV_A_ &linuxaio_iocbps [fd]->io, EPOLL_CTL_MOD);
		230
		231	fd_event (EV_A_ fd,
		232	(ev & (EPOLLOUT \| EPOLLERR \| EPOLLHUP) ? EV_WRITE : 0)
		233	\| (ev & (EPOLLIN \| EPOLLERR \| EPOLLHUP) ? EV_READ : 0));
		234	}
		235
		236	if (res < sizeof (events) / sizeof (events [0]))
		237	break;
		238	}
		239	}
		240
		241	#endif
		242
187	static void	243	static void
188	linuxaio_parse_events (EV_P_ struct io_event *ev, int nr)	244	linuxaio_parse_events (EV_P_ struct io_event *ev, int nr)
189	{	245	{
190	while (nr)	246	while (nr)
191	{	247	{
192	int fd = ev->data;	248	int fd = ev->data;
193	int res = ev->res;	249	int res = ev->res;
194		250
195	assert (("libev: iocb fd must be in-bounds", fd >= 0 && fd < anfdmax));	251	assert (("libev: iocb fd must be in-bounds", fd >= 0 && fd < anfdmax));
196		252
197	/* linux aio is oneshot: rearm fd */	253	/* linux aio is oneshot: rearm fd. TODO: this does more work than needed */
198	linuxaio_iocbps [fd]->io.aio_buf = 0;	254	linuxaio_iocbps [fd]->io.aio_buf = 0;
199	anfds [fd].events = 0;	255	anfds [fd].events = 0;
200	fd_change (EV_A_ fd, 0);	256	fd_change (EV_A_ fd, 0);
201		257
202	/* feed events, we do not expect or handle POLLNVAL */	258	/* feed events, we do not expect or handle POLLNVAL */
203	if (ecb_expect_false (res & POLLNVAL))
204	fd_kill (EV_A_ fd);
205	else
206	fd_event (	259	fd_event (
207	EV_A_	260	EV_A_
208	fd,	261	fd,
209	(res & (POLLOUT \| POLLERR \| POLLHUP) ? EV_WRITE : 0)	262	(res & (POLLOUT \| POLLERR \| POLLHUP) ? EV_WRITE : 0)
210	\| (res & (POLLIN \| POLLERR \| POLLHUP) ? EV_READ : 0)	263	\| (res & (POLLIN \| POLLERR \| POLLHUP) ? EV_READ : 0)
211	);	264	);
212		265
213	--nr;	266	--nr;
214	++ev;	267	++ev;
215	}	268	}
216	}	269	}
…		…
229		282
230	if (head == tail)	283	if (head == tail)
231	return 0;	284	return 0;
232		285
233	/* bail out if the ring buffer doesn't match the expected layout */	286	/* bail out if the ring buffer doesn't match the expected layout */
234	if (ecb_expect_false (ring->magic != AIO_RING_MAGIC)	287	if (expect_false (ring->magic != AIO_RING_MAGIC)
235	\|\| ring->incompat_features != AIO_RING_INCOMPAT_FEATURES	288	\|\| ring->incompat_features != AIO_RING_INCOMPAT_FEATURES
236	\|\| ring->header_length != sizeof (struct aio_ring)) /* TODO: or use it to find io_event[0]? */	289	\|\| ring->header_length != sizeof (struct aio_ring)) /* TODO: or use it to find io_event[0]? */
237	return 0;	290	return 0;
238		291
239	/* make sure the events up to tail are visible */	292	/* make sure the events up to tail are visible */
240	ECB_MEMORY_FENCE_ACQUIRE;	293	ECB_MEMORY_FENCE_ACQUIRE;
241		294
…		…
246	{	299	{
247	linuxaio_parse_events (EV_A_ ring->io_events + head, ring->nr - head);	300	linuxaio_parse_events (EV_A_ ring->io_events + head, ring->nr - head);
248	linuxaio_parse_events (EV_A_ ring->io_events, tail);	301	linuxaio_parse_events (EV_A_ ring->io_events, tail);
249	}	302	}
250		303
		304	ECB_MEMORY_FENCE_RELAXED;
251	/* as an extension to C, we hope that the volatile will makethis atomic and once-only */	305	/* as an extension to C, we hope that the volatile will make this atomic and once-only */
252	(volatile unsigned )&ring->head = tail;	306	(volatile unsigned )&ring->head = tail;
253	/* make sure kernel can see our new head value - probably not required */	307	/* make sure kernel can see our new head value - probably not required */
254	ECB_MEMORY_FENCE_RELEASE;	308	ECB_MEMORY_FENCE_RELEASE;
255		309
256	return 1;	310	return 1;
…		…
260	inline_size	314	inline_size
261	void	315	void
262	linuxaio_get_events (EV_P_ ev_tstamp timeout)	316	linuxaio_get_events (EV_P_ ev_tstamp timeout)
263	{	317	{
264	struct timespec ts;	318	struct timespec ts;
265	struct io_event ioev;	319	struct io_event ioev[1];
266	int res;	320	int res;
267		321
268	if (linuxaio_get_events_from_ring (EV_A))	322	if (linuxaio_get_events_from_ring (EV_A))
269	return;	323	return;
270		324
271	/* no events, so wait for at least one, then poll ring buffer again */	325	/* no events, so wait for at least one, then poll ring buffer again */
272	/* this degrades to one event per loop iteration */	326	/* this degrades to one event per loop iteration */
273	/* if the ring buffer changes layout, but so be it */	327	/* if the ring buffer changes layout, but so be it */
274		328
		329	EV_RELEASE_CB;
		330
275	ts.tv_sec = (long)timeout;	331	ts.tv_sec = (long)timeout;
276	ts.tv_nsec = (long)((timeout - ts.tv_sec) * 1e9);	332	ts.tv_nsec = (long)((timeout - ts.tv_sec) * 1e9);
277		333
278	res = ev_io_getevents (linuxaio_ctx, 1, 1, &ioev, &ts);	334	res = evsys_io_getevents (linuxaio_ctx, 1, sizeof (ioev) / sizeof (ioev [0]), ioev, &ts);
		335
		336	EV_ACQUIRE_CB;
279		337
280	if (res < 0)	338	if (res < 0)
281	if (errno == EINTR)	339	if (errno == EINTR)
282	/* ignored */;	340	/* ignored */;
283	else	341	else
284	ev_syserr ("(libev) linuxaio io_getevents");	342	ev_syserr ("(libev) linuxaio io_getevents");
285	else if (res)	343	else if (res)
286	{	344	{
287	/* at least one event received, handle it and any remaining ones in the ring buffer */	345	/* at least one event received, handle it and any remaining ones in the ring buffer */
288	linuxaio_parse_events (EV_A_ &ioev, 1);	346	linuxaio_parse_events (EV_A_ ioev, res);
289	linuxaio_get_events_from_ring (EV_A);	347	linuxaio_get_events_from_ring (EV_A);
290	}	348	}
291	}	349	}
292
293	#if EPOLL_FALLBACK
294	static void
295	linuxaio_rearm_epoll (EV_P_ struct iocb *iocb, int op)
296	{
297	struct epoll_event eev;
298
299	eev.events = EPOLLONESHOT;
300	if (iocb->aio_buf & POLLIN ) eev.events \|= EPOLLIN ;
301	if (iocb->aio_buf & POLLOUT) eev.events \|= EPOLLOUT;
302	eev.data.fd = iocb->aio_fildes;
303
304	if (epoll_ctl (backend_fd, op, iocb->aio_fildes, &eev) < 0)
305	ev_syserr ("(libeio) linuxaio epoll_ctl");
306	}
307	#endif
308		350
309	static void	351	static void
310	linuxaio_poll (EV_P_ ev_tstamp timeout)	352	linuxaio_poll (EV_P_ ev_tstamp timeout)
311	{	353	{
312	int submitted;	354	int submitted;
…		…
316	/* io_submit might return less than the requested number of iocbs */	358	/* io_submit might return less than the requested number of iocbs */
317	/* this is, afaics, only because of errors, but we go by the book and use a loop, */	359	/* this is, afaics, only because of errors, but we go by the book and use a loop, */
318	/* which allows us to pinpoint the errornous iocb */	360	/* which allows us to pinpoint the errornous iocb */
319	for (submitted = 0; submitted < linuxaio_submitcnt; )	361	for (submitted = 0; submitted < linuxaio_submitcnt; )
320	{	362	{
		363	#if 0
		364	int res;
		365	if (linuxaio_submits[submitted]->aio_fildes == backend_fd)
		366	res = evsys_io_submit (linuxaio_ctx, 1, linuxaio_submits + submitted);
		367	else
		368	{ res = -1; errno = EINVAL; };
		369	#else
321	int res = ev_io_submit (linuxaio_ctx, linuxaio_submitcnt - submitted, linuxaio_submits + submitted);	370	int res = evsys_io_submit (linuxaio_ctx, linuxaio_submitcnt - submitted, linuxaio_submits + submitted);
		371	#endif
322		372
323	if (ecb_expect_false (res < 0))	373	if (expect_false (res < 0))
324	if (errno == EAGAIN)	374	if (errno == EAGAIN)
325	{	375	{
326	/* This happens when the ring buffer is full, at least. I assume this means	376	/* This happens when the ring buffer is full, at least. I assume this means
327	* that the event was queued synchronously during io_submit, and thus	377	* that the event was queued synchronously during io_submit, and thus
328	* the buffer overflowed.	378	* the buffer overflowed.
329	* In this case, we just try in next loop iteration.	379	* In this case, we just try in next loop iteration.
330	* This should not result in a few fds taking priority, as the interface	380	* This should not result in a few fds taking priority, as the interface
331	* is one-shot, and we submit iocb's in a round-robin fashion.	381	* is one-shot, and we submit iocb's in a round-robin fashion.
		382	* TODO: maybe make "submitted" persistent, so we don't have to memmove?
332	*/	383	*/
		384	if (ecb_expect_false (submitted))
		385	{
333	memmove (linuxaio_submits, linuxaio_submits + submitted, (linuxaio_submitcnt - submitted) * sizeof (*linuxaio_submits));	386	memmove (linuxaio_submits, linuxaio_submits + submitted, (linuxaio_submitcnt - submitted) * sizeof (*linuxaio_submits));
334	linuxaio_submitcnt -= submitted;	387	linuxaio_submitcnt -= submitted;
		388	}
		389
335	timeout = 0;	390	timeout = 0;
336	break;	391	break;
337	}	392	}
338	#if EPOLL_FALLBACK	393	#if EPOLL_FALLBACK
339	else if (errno == EINVAL)	394	else if (errno == EINVAL)
340	{	395	{
341	/* This happens for unsupported fds, officially, but in my testing,	396	/* This happens for unsupported fds, officially, but in my testing,
342	* also randomly happens for supported fds. We fall back to good old	397	* also randomly happens for supported fds. We fall back to good old
343	* poll() here, under the assumption that this is a very rare case.	398	* poll() here, under the assumption that this is a very rare case.
344	* See https://lore.kernel.org/patchwork/patch/1047453/ for evidence	399	* See https://lore.kernel.org/patchwork/patch/1047453/ to see
345	* that the problem is known, but ignored.	400	* discussion about such a case (ttys) where polling for POLLIN
		401	* fails but POLLIN\|POLLOUT works.
346	*/	402	*/
347	struct iocb *iocb = linuxaio_submits [submitted];	403	struct iocb *iocb = linuxaio_submits [submitted];
		404
		405	linuxaio_rearm_epoll (EV_A_ linuxaio_submits [submitted], EPOLL_CTL_ADD);
		406	iocb->aio_reqprio = -1; /* mark iocb as epoll */
		407
348	res = 1; /* skip this iocb */	408	res = 1; /* skip this iocb */
349
350	linuxaio_rearm_epoll (EV_A_ iocb, EPOLL_CTL_ADD);
351	iocb->aio_reqprio = -1; /* mark iocb as epoll */
352	}	409	}
353	#endif	410	#endif
		411	else if (errno == EBADF)
		412	{
		413	fd_kill (EV_A_ linuxaio_submits [submitted]->aio_fildes);
		414
		415	res = 1; /* skip this iocb */
		416	}
354	else	417	else
355	ev_syserr ("(libev) linuxaio io_submit");	418	ev_syserr ("(libev) linuxaio io_submit");
356		419
357	submitted += res;	420	submitted += res;
358	}	421	}
…		…
361		424
362	/* second phase: fetch and parse events */	425	/* second phase: fetch and parse events */
363		426
364	linuxaio_get_events (EV_A_ timeout);	427	linuxaio_get_events (EV_A_ timeout);
365	}	428	}
366
367	#if EPOLL_FALLBACK
368
369	static void
370	linuxaio_epoll_cb (EV_P_ struct ev_io *w, int revents)
371	{
372	struct epoll_event events[16];
373
374	for (;;)
375	{
376	int idx;
377	int res = epoll_wait (backend_fd, events, sizeof (events) / sizeof (events [0]), 0);
378
379	if (ecb_expect_false (res < 0))
380	ev_syserr ("(libev) linuxaio epoll_wait");
381	else if (!res)
382	break;
383
384	for (idx = res; idx--; )
385	{
386	int fd = events [idx].data.fd;
387	uint32_t ev = events [idx].events;
388
389	assert (("libev: iocb fd must be in-bounds", fd >= 0 && fd < anfdmax));
390
391	linuxaio_rearm_epoll (EV_A_ &linuxaio_iocbps [fd]->io, EPOLL_CTL_MOD);
392
393	fd_event (EV_A_ fd,
394	(ev & (EPOLLOUT \| EPOLLERR \| EPOLLHUP) ? EV_WRITE : 0)
395	\| (ev & (EPOLLIN \| EPOLLERR \| EPOLLHUP) ? EV_READ : 0));
396	}
397
398	if (res < sizeof (events) / sizeof (events [0]))
399	break;
400	}
401	}
402
403	#endif
404		429
405	inline_size	430	inline_size
406	int	431	int
407	linuxaio_init (EV_P_ int flags)	432	linuxaio_init (EV_P_ int flags)
408	{	433	{
…		…
417	if (ev_linux_version () < 0x041200)	442	if (ev_linux_version () < 0x041200)
418	return 0;	443	return 0;
419	#endif	444	#endif
420		445
421	linuxaio_ctx = 0;	446	linuxaio_ctx = 0;
422	if (ev_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)	447	if (evsys_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)
423	return 0;	448	return 0;
424		449
425	#if EPOLL_FALLBACK	450	#if EPOLL_FALLBACK
426	backend_fd = ev_epoll_create ();	451	backend_fd = ev_epoll_create ();
427	if (backend_fd < 0)	452	if (backend_fd < 0)
428	{	453	{
429	ev_io_destroy (linuxaio_ctx);	454	evsys_io_destroy (linuxaio_ctx);
430	return 0;	455	return 0;
431	}	456	}
432		457
433	ev_io_init (EV_A_ &linuxaio_epoll_w, linuxaio_epoll_cb, backend_fd, EV_READ);	458	ev_io_init (EV_A_ &linuxaio_epoll_w, linuxaio_epoll_cb, backend_fd, EV_READ);
		459	ev_set_priority (&linuxaio_epoll_w, EV_MAXPRI);
434	ev_io_start (EV_A_ &linuxaio_epoll_w);	460	ev_io_start (EV_A_ &linuxaio_epoll_w);
435	ev_unref (EV_A); /* watcher should not keep loop alive */	461	ev_unref (EV_A); /* watcher should not keep loop alive */
436	#endif	462	#endif
437		463
438	backend_modify = linuxaio_modify;	464	backend_modify = linuxaio_modify;
…		…
454	{	480	{
455	#if EPOLL_FALLBACK	481	#if EPOLL_FALLBACK
456	close (backend_fd);	482	close (backend_fd);
457	#endif	483	#endif
458	linuxaio_free_iocbp (EV_A);	484	linuxaio_free_iocbp (EV_A);
459	ev_io_destroy (linuxaio_ctx);	485	evsys_io_destroy (linuxaio_ctx);
460	}	486	}
461		487
462	inline_size	488	inline_size
463	void	489	void
464	linuxaio_fork (EV_P)	490	linuxaio_fork (EV_P)
…		…
466	/* this frees all iocbs, which is very heavy-handed */	492	/* this frees all iocbs, which is very heavy-handed */
467	linuxaio_destroy (EV_A);	493	linuxaio_destroy (EV_A);
468	linuxaio_submitcnt = 0; /* all pointers were invalidated */	494	linuxaio_submitcnt = 0; /* all pointers were invalidated */
469		495
470	linuxaio_ctx = 0;	496	linuxaio_ctx = 0;
471	while (ev_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)	497	while (evsys_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)
472	ev_syserr ("(libev) linuxaio io_setup");	498	ev_syserr ("(libev) linuxaio io_setup");
473		499
474	#if EPOLL_FALLBACK	500	#if EPOLL_FALLBACK
475	while ((backend_fd = ev_epoll_create ()) < 0)	501	while ((backend_fd = ev_epoll_create ()) < 0)
476	ev_syserr ("(libev) linuxaio epoll_create");	502	ev_syserr ("(libev) linuxaio epoll_create");

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/ev_linuxaio.c (file contents): Revision 1.15 by root, Mon Jun 24 00:04:26 2019 UTC vs. Revision 1.24 by root, Mon Jun 24 22:27:29 2019 UTC

Diff Legend

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.15 by root, Mon Jun 24 00:04:26 2019 UTC vs.
Revision 1.24 by root, Mon Jun 24 22:27:29 2019 UTC