[ViewVC] Diff of: cvs/libev/ev

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.17 by root, Mon Jun 24 02:02:35 2019 UTC vs.
Revision 1.23 by root, Mon Jun 24 21:34:47 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 (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	}
…		…
262	inline_size	315	inline_size
263	void	316	void
264	linuxaio_get_events (EV_P_ ev_tstamp timeout)	317	linuxaio_get_events (EV_P_ ev_tstamp timeout)
265	{	318	{
266	struct timespec ts;	319	struct timespec ts;
267	struct io_event ioev;	320	struct io_event ioev[1];
268	int res;	321	int res;
269		322
270	if (linuxaio_get_events_from_ring (EV_A))	323	if (linuxaio_get_events_from_ring (EV_A))
271	return;	324	return;
272		325
273	/* no events, so wait for at least one, then poll ring buffer again */	326	/* no events, so wait for at least one, then poll ring buffer again */
274	/* this degrades to one event per loop iteration */	327	/* this degrades to one event per loop iteration */
275	/* if the ring buffer changes layout, but so be it */	328	/* if the ring buffer changes layout, but so be it */
276		329
		330	EV_RELEASE_CB;
		331
277	ts.tv_sec = (long)timeout;	332	ts.tv_sec = (long)timeout;
278	ts.tv_nsec = (long)((timeout - ts.tv_sec) * 1e9);	333	ts.tv_nsec = (long)((timeout - ts.tv_sec) * 1e9);
279		334
280	res = ev_io_getevents (linuxaio_ctx, 1, 1, &ioev, &ts);	335	res = evsys_io_getevents (linuxaio_ctx, 1, sizeof (ioev) / sizeof (ioev [0]), ioev, &ts);
		336
		337	EV_ACQUIRE_CB;
281		338
282	if (res < 0)	339	if (res < 0)
283	if (errno == EINTR)	340	if (errno == EINTR)
284	/* ignored */;	341	/* ignored */;
285	else	342	else
286	ev_syserr ("(libev) linuxaio io_getevents");	343	ev_syserr ("(libev) linuxaio io_getevents");
287	else if (res)	344	else if (res)
288	{	345	{
289	/* at least one event received, handle it and any remaining ones in the ring buffer */	346	/* at least one event received, handle it and any remaining ones in the ring buffer */
290	linuxaio_parse_events (EV_A_ &ioev, 1);	347	linuxaio_parse_events (EV_A_ ioev, res);
291	linuxaio_get_events_from_ring (EV_A);	348	linuxaio_get_events_from_ring (EV_A);
292	}	349	}
293	}	350	}
294
295	#if EPOLL_FALLBACK
296	static void
297	linuxaio_rearm_epoll (EV_P_ struct iocb *iocb, int op)
298	{
299	struct epoll_event eev;
300
301	eev.events = EPOLLONESHOT;
302	if (iocb->aio_buf & POLLIN ) eev.events \|= EPOLLIN ;
303	if (iocb->aio_buf & POLLOUT) eev.events \|= EPOLLOUT;
304	eev.data.fd = iocb->aio_fildes;
305
306	if (epoll_ctl (backend_fd, op, iocb->aio_fildes, &eev) < 0)
307	ev_syserr ("(libeio) linuxaio epoll_ctl");
308	}
309	#endif
310		351
311	static void	352	static void
312	linuxaio_poll (EV_P_ ev_tstamp timeout)	353	linuxaio_poll (EV_P_ ev_tstamp timeout)
313	{	354	{
314	int submitted;	355	int submitted;
…		…
318	/* io_submit might return less than the requested number of iocbs */	359	/* io_submit might return less than the requested number of iocbs */
319	/* this is, afaics, only because of errors, but we go by the book and use a loop, */	360	/* this is, afaics, only because of errors, but we go by the book and use a loop, */
320	/* which allows us to pinpoint the errornous iocb */	361	/* which allows us to pinpoint the errornous iocb */
321	for (submitted = 0; submitted < linuxaio_submitcnt; )	362	for (submitted = 0; submitted < linuxaio_submitcnt; )
322	{	363	{
		364	#if 0
		365	int res;
		366	if (linuxaio_submits[submitted]->aio_fildes == backend_fd)
		367	res = evsys_io_submit (linuxaio_ctx, 1, linuxaio_submits + submitted);
		368	else
		369	{ res = -1; errno = EINVAL; };
		370	#else
323	int res = ev_io_submit (linuxaio_ctx, linuxaio_submitcnt - submitted, linuxaio_submits + submitted);	371	int res = evsys_io_submit (linuxaio_ctx, linuxaio_submitcnt - submitted, linuxaio_submits + submitted);
		372	#endif
324		373
325	if (expect_false (res < 0))	374	if (expect_false (res < 0))
326	if (errno == EAGAIN)	375	if (errno == EAGAIN)
327	{	376	{
328	/* This happens when the ring buffer is full, at least. I assume this means	377	/* This happens when the ring buffer is full, at least. I assume this means
329	* that the event was queued synchronously during io_submit, and thus	378	* that the event was queued synchronously during io_submit, and thus
330	* the buffer overflowed.	379	* the buffer overflowed.
331	* In this case, we just try in next loop iteration.	380	* In this case, we just try in next loop iteration.
332	* This should not result in a few fds taking priority, as the interface	381	* This should not result in a few fds taking priority, as the interface
333	* is one-shot, and we submit iocb's in a round-robin fashion.	382	* is one-shot, and we submit iocb's in a round-robin fashion.
		383	* TODO: maybe make "submitted" persistent, so we don't have to memmove?
334	*/	384	*/
		385	if (ecb_expect_false (submitted))
		386	{
335	memmove (linuxaio_submits, linuxaio_submits + submitted, (linuxaio_submitcnt - submitted) * sizeof (*linuxaio_submits));	387	memmove (linuxaio_submits, linuxaio_submits + submitted, (linuxaio_submitcnt - submitted) * sizeof (*linuxaio_submits));
336	linuxaio_submitcnt -= submitted;	388	linuxaio_submitcnt -= submitted;
		389	}
		390
337	timeout = 0;	391	timeout = 0;
338	break;	392	break;
339	}	393	}
340	#if EPOLL_FALLBACK	394	#if EPOLL_FALLBACK
341	else if (errno == EINVAL)	395	else if (errno == EINVAL)
342	{	396	{
343	/* This happens for unsupported fds, officially, but in my testing,	397	/* This happens for unsupported fds, officially, but in my testing,
344	* also randomly happens for supported fds. We fall back to good old	398	* also randomly happens for supported fds. We fall back to good old
345	* poll() here, under the assumption that this is a very rare case.	399	* poll() here, under the assumption that this is a very rare case.
346	* See https://lore.kernel.org/patchwork/patch/1047453/ for evidence	400	* See https://lore.kernel.org/patchwork/patch/1047453/ to see
347	* that the problem is known, but ignored.	401	* discussion about such a case (ttys) where polling for POLLIN
		402	* fails but POLLIN\|POLLOUT works.
348	*/	403	*/
349	struct iocb *iocb = linuxaio_submits [submitted];	404	struct iocb *iocb = linuxaio_submits [submitted];
		405
		406	linuxaio_rearm_epoll (EV_A_ linuxaio_submits [submitted], EPOLL_CTL_ADD);
		407	iocb->aio_reqprio = -1; /* mark iocb as epoll */
		408
350	res = 1; /* skip this iocb */	409	res = 1; /* skip this iocb */
351
352	linuxaio_rearm_epoll (EV_A_ iocb, EPOLL_CTL_ADD);
353	iocb->aio_reqprio = -1; /* mark iocb as epoll */
354	}	410	}
355	#endif	411	#endif
		412	else if (errno == EBADF)
		413	{
		414	fd_kill (EV_A_ linuxaio_submits [submitted]->aio_fildes);
		415
		416	res = 1; /* skip this iocb */
		417	}
356	else	418	else
357	ev_syserr ("(libev) linuxaio io_submit");	419	ev_syserr ("(libev) linuxaio io_submit");
358		420
359	submitted += res;	421	submitted += res;
360	}	422	}
…		…
363		425
364	/* second phase: fetch and parse events */	426	/* second phase: fetch and parse events */
365		427
366	linuxaio_get_events (EV_A_ timeout);	428	linuxaio_get_events (EV_A_ timeout);
367	}	429	}
368
369	#if EPOLL_FALLBACK
370
371	static void
372	linuxaio_epoll_cb (EV_P_ struct ev_io *w, int revents)
373	{
374	struct epoll_event events[16];
375
376	for (;;)
377	{
378	int idx;
379	int res = epoll_wait (backend_fd, events, sizeof (events) / sizeof (events [0]), 0);
380
381	if (expect_false (res < 0))
382	ev_syserr ("(libev) linuxaio epoll_wait");
383	else if (!res)
384	break;
385
386	for (idx = res; idx--; )
387	{
388	int fd = events [idx].data.fd;
389	uint32_t ev = events [idx].events;
390
391	assert (("libev: iocb fd must be in-bounds", fd >= 0 && fd < anfdmax));
392
393	linuxaio_rearm_epoll (EV_A_ &linuxaio_iocbps [fd]->io, EPOLL_CTL_MOD);
394
395	fd_event (EV_A_ fd,
396	(ev & (EPOLLOUT \| EPOLLERR \| EPOLLHUP) ? EV_WRITE : 0)
397	\| (ev & (EPOLLIN \| EPOLLERR \| EPOLLHUP) ? EV_READ : 0));
398	}
399
400	if (res < sizeof (events) / sizeof (events [0]))
401	break;
402	}
403	}
404
405	#endif
406		430
407	inline_size	431	inline_size
408	int	432	int
409	linuxaio_init (EV_P_ int flags)	433	linuxaio_init (EV_P_ int flags)
410	{	434	{
…		…
419	if (ev_linux_version () < 0x041200)	443	if (ev_linux_version () < 0x041200)
420	return 0;	444	return 0;
421	#endif	445	#endif
422		446
423	linuxaio_ctx = 0;	447	linuxaio_ctx = 0;
424	if (ev_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)	448	if (evsys_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)
425	return 0;	449	return 0;
426		450
427	#if EPOLL_FALLBACK	451	#if EPOLL_FALLBACK
428	backend_fd = ev_epoll_create ();	452	backend_fd = ev_epoll_create ();
429	if (backend_fd < 0)	453	if (backend_fd < 0)
430	{	454	{
431	ev_io_destroy (linuxaio_ctx);	455	evsys_io_destroy (linuxaio_ctx);
432	return 0;	456	return 0;
433	}	457	}
434		458
435	ev_io_init (EV_A_ &linuxaio_epoll_w, linuxaio_epoll_cb, backend_fd, EV_READ);	459	ev_io_init (EV_A_ &linuxaio_epoll_w, linuxaio_epoll_cb, backend_fd, EV_READ);
		460	ev_set_priority (&linuxaio_epoll_w, EV_MAXPRI);
436	ev_io_start (EV_A_ &linuxaio_epoll_w);	461	ev_io_start (EV_A_ &linuxaio_epoll_w);
437	ev_unref (EV_A); /* watcher should not keep loop alive */	462	ev_unref (EV_A); /* watcher should not keep loop alive */
438	#endif	463	#endif
439		464
440	backend_modify = linuxaio_modify;	465	backend_modify = linuxaio_modify;
…		…
456	{	481	{
457	#if EPOLL_FALLBACK	482	#if EPOLL_FALLBACK
458	close (backend_fd);	483	close (backend_fd);
459	#endif	484	#endif
460	linuxaio_free_iocbp (EV_A);	485	linuxaio_free_iocbp (EV_A);
461	ev_io_destroy (linuxaio_ctx);	486	evsys_io_destroy (linuxaio_ctx);
462	}	487	}
463		488
464	inline_size	489	inline_size
465	void	490	void
466	linuxaio_fork (EV_P)	491	linuxaio_fork (EV_P)
…		…
468	/* this frees all iocbs, which is very heavy-handed */	493	/* this frees all iocbs, which is very heavy-handed */
469	linuxaio_destroy (EV_A);	494	linuxaio_destroy (EV_A);
470	linuxaio_submitcnt = 0; /* all pointers were invalidated */	495	linuxaio_submitcnt = 0; /* all pointers were invalidated */
471		496
472	linuxaio_ctx = 0;	497	linuxaio_ctx = 0;
473	while (ev_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)	498	while (evsys_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)
474	ev_syserr ("(libev) linuxaio io_setup");	499	ev_syserr ("(libev) linuxaio io_setup");
475		500
476	#if EPOLL_FALLBACK	501	#if EPOLL_FALLBACK
477	while ((backend_fd = ev_epoll_create ()) < 0)	502	while ((backend_fd = ev_epoll_create ()) < 0)
478	ev_syserr ("(libev) linuxaio epoll_create");	503	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.17 by root, Mon Jun 24 02:02:35 2019 UTC vs. Revision 1.23 by root, Mon Jun 24 21:34:47 2019 UTC

Diff Legend

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.17 by root, Mon Jun 24 02:02:35 2019 UTC vs.
Revision 1.23 by root, Mon Jun 24 21:34:47 2019 UTC