[ViewVC] Diff of: cvs/libeio/eio.c

Comparing libeio/eio.c (file contents):
Revision 1.125 by root, Thu Dec 6 12:21:41 2012 UTC vs.
Revision 1.144 by root, Tue Dec 27 09:58:44 2016 UTC

…		…
1	/*	1	/*
2	* libeio implementation	2	* libeio implementation
3	*	3	*
4	* Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libeio@schmorp.de>	4	* Copyright (c) 2007,2008,2009,2010,2011,2012,2013,2016 Marc Alexander Lehmann <libeio@schmorp.de>
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* Redistribution and use in source and binary forms, with or without modifica-	7	* Redistribution and use in source and binary forms, with or without modifica-
8	* tion, are permitted provided that the following conditions are met:	8	* tion, are permitted provided that the following conditions are met:
9	*	9	*
42	#endif	42	#endif
43		43
44	#include "eio.h"	44	#include "eio.h"
45	#include "ecb.h"	45	#include "ecb.h"
46		46
47	#ifdef EIO_STACKSIZE
48	# define X_STACKSIZE EIO_STACKSIZE
49	#endif
50	#include "xthread.h"
51
52	#include <errno.h>	47	#include <errno.h>
53	#include <stddef.h>	48	#include <stddef.h>
54	#include <stdlib.h>	49	#include <stdlib.h>
55	#include <string.h>	50	#include <string.h>
56	#include <errno.h>	51	#include <errno.h>
…		…
120	#define link(old,neu) (CreateHardLink (neu, old, 0) ? 0 : EIO_ERRNO (ENOENT, -1))	115	#define link(old,neu) (CreateHardLink (neu, old, 0) ? 0 : EIO_ERRNO (ENOENT, -1))
121		116
122	#define chmod(path,mode) _chmod (path, mode)	117	#define chmod(path,mode) _chmod (path, mode)
123	#define dup(fd) _dup (fd)	118	#define dup(fd) _dup (fd)
124	#define dup2(fd1,fd2) _dup2 (fd1, fd2)	119	#define dup2(fd1,fd2) _dup2 (fd1, fd2)
		120	#define pipe(fds) _pipe (fds, 4096, O_BINARY)
125		121
		122	#define fcntl(fd,cmd,arg) EIO_ENOSYS ()
		123	#define ioctl(fd,cmd,arg) EIO_ENOSYS ()
126	#define fchmod(fd,mode) EIO_ENOSYS ()	124	#define fchmod(fd,mode) EIO_ENOSYS ()
127	#define chown(path,uid,gid) EIO_ENOSYS ()	125	#define chown(path,uid,gid) EIO_ENOSYS ()
128	#define fchown(fd,uid,gid) EIO_ENOSYS ()	126	#define fchown(fd,uid,gid) EIO_ENOSYS ()
129	#define truncate(path,offs) EIO_ENOSYS () /* far-miss: SetEndOfFile */	127	#define truncate(path,offs) EIO_ENOSYS () /* far-miss: SetEndOfFile */
130	#define ftruncate(fd,offs) EIO_ENOSYS () /* near-miss: SetEndOfFile */	128	#define ftruncate(fd,offs) EIO_ENOSYS () /* near-miss: SetEndOfFile */
…		…
203	/* we could even stat and see if it exists */	201	/* we could even stat and see if it exists */
204	static int	202	static int
205	symlink (const char old, const char neu)	203	symlink (const char old, const char neu)
206	{	204	{
207	#if WINVER >= 0x0600	205	#if WINVER >= 0x0600
		206	int flags;
		207
		208	/* This tries out all combinations of SYMBOLIC_LINK_FLAG_DIRECTORY
		209	* and SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE,
		210	* with directory first.
		211	*/
		212	for (flags = 3; flags >= 0; --flags)
208	if (CreateSymbolicLink (neu, old, 1))	213	if (CreateSymbolicLink (neu, old, flags))
209	return 0;	214	return 0;
210
211	if (CreateSymbolicLink (neu, old, 0))
212	return 0;
213	#endif	215	#endif
214		216
215	return EIO_ERRNO (ENOENT, -1);	217	return EIO_ERRNO (ENOENT, -1);
216	}	218	}
217		219
218	/* POSIX API only */	220	/* POSIX API only, causing trouble for win32 apps */
219	#define CreateHardLink(neu,old,flags) 0	221	#define CreateHardLink(neu,old,flags) 0 /* not really creating hardlink, still using relative paths? */
220	#define CreateSymbolicLink(neu,old,flags) 0	222	#define CreateSymbolicLink(neu,old,flags) 0 /* vista+ only */
221		223
222	struct statvfs	224	struct statvfs
223	{	225	{
224	int dummy;	226	int dummy;
225	};	227	};
…		…
231		233
232	#else	234	#else
233		235
234	#include <sys/time.h>	236	#include <sys/time.h>
235	#include <sys/select.h>	237	#include <sys/select.h>
236	#include <sys/statvfs.h>
237	#include <unistd.h>	238	#include <unistd.h>
238	#include <signal.h>	239	#include <signal.h>
239	#include <dirent.h>	240	#include <dirent.h>
		241
		242	#ifdef ANDROID
		243	#include <sys/vfs.h>
		244	#define statvfs statfs
		245	#define fstatvfs fstatfs
		246	#include <asm/page.h> /* supposedly limits.h does #define PAGESIZE PAGESIZE */
		247	#else
		248	#include <sys/statvfs.h>
		249	#endif
240		250
241	#if _POSIX_MEMLOCK \|\| _POSIX_MEMLOCK_RANGE \|\| _POSIX_MAPPED_FILES	251	#if _POSIX_MEMLOCK \|\| _POSIX_MEMLOCK_RANGE \|\| _POSIX_MAPPED_FILES
242	#include <sys/mman.h>	252	#include <sys/mman.h>
243	#endif	253	#endif
244		254
…		…
272	# include <utime.h>	282	# include <utime.h>
273	#endif	283	#endif
274		284
275	#if HAVE_SYS_SYSCALL_H	285	#if HAVE_SYS_SYSCALL_H
276	# include <sys/syscall.h>	286	# include <sys/syscall.h>
277	#endif
278
279	#if HAVE_SYS_PRCTL_H
280	# include <sys/prctl.h>
281	#endif	287	#endif
282		288
283	#if HAVE_SENDFILE	289	#if HAVE_SENDFILE
284	# if __linux	290	# if __linux
285	# include <sys/sendfile.h>	291	# include <sys/sendfile.h>
…		…
310	# define NAME_MAX 4096	316	# define NAME_MAX 4096
311	#endif	317	#endif
312		318
313	/* used for readlink etc. */	319	/* used for readlink etc. */
314	#ifndef PATH_MAX	320	#ifndef PATH_MAX
315	# define PATH_MAX 4096	321	# define PATH_MAX 0
316	#endif	322	#endif
		323
		324	#ifndef EIO_PATH_MIN
		325	# define EIO_PATH_MIN 8160
		326	#endif
		327
		328	#define EIO_PATH_MAX (PATH_MAX <= EIO_PATH_MIN ? EIO_PATH_MIN : PATH_MAX)
317		329
318	/* buffer size for various temporary buffers */	330	/* buffer size for various temporary buffers */
319	#define EIO_BUFSIZE 65536	331	#define EIO_BUFSIZE 65536
320		332
321	#define dBUF \	333	#define dBUF \
322	char *eio_buf = malloc (EIO_BUFSIZE); \	334	char *eio_buf = malloc (EIO_BUFSIZE); \
323	errno = ENOMEM; \	335	errno = ENOMEM; \
324	if (!eio_buf) \	336	if (!eio_buf) \
325	return -1	337	return -1
326		338
327	#define FUBd \	339	#define FUBd \
328	free (eio_buf)	340	free (eio_buf)
329		341
330	#define EIO_TICKS ((1000000 + 1023) >> 10)
331
332	/*****************************************************************************/	342	/*****************************************************************************/
333		343
334	struct tmpbuf
335	{
336	void *ptr;
337	int len;
338	};
339
340	static void *
341	tmpbuf_get (struct tmpbuf *buf, int len)
342	{
343	if (buf->len < len)
344	{
345	free (buf->ptr);
346	buf->ptr = malloc (buf->len = len);
347	}
348
349	return buf->ptr;
350	}
351
352	struct tmpbuf;	344	struct etp_tmpbuf;
353		345
354	#if _POSIX_VERSION >= 200809L	346	#if _POSIX_VERSION >= 200809L
355	#define HAVE_AT 1	347	#define HAVE_AT 1
356	#define WD2FD(wd) ((wd) ? (wd)->fd : AT_FDCWD)	348	#define WD2FD(wd) ((wd) ? (wd)->fd : AT_FDCWD)
357	#ifndef O_SEARCH	349	#ifndef O_SEARCH
358	#define O_SEARCH O_RDONLY	350	#define O_SEARCH O_RDONLY
359	#endif	351	#endif
360	#else	352	#else
361	#define HAVE_AT 0	353	#define HAVE_AT 0
362	static const char wd_expand (struct tmpbuf tmpbuf, eio_wd wd, const char *path);	354	static const char wd_expand (struct etp_tmpbuf tmpbuf, eio_wd wd, const char *path);
363	#endif	355	#endif
364		356
365	struct eio_pwd	357	struct eio_pwd
366	{	358	{
367	#if HAVE_AT	359	#if HAVE_AT
…		…
374	/*****************************************************************************/	366	/*****************************************************************************/
375		367
376	#define ETP_PRI_MIN EIO_PRI_MIN	368	#define ETP_PRI_MIN EIO_PRI_MIN
377	#define ETP_PRI_MAX EIO_PRI_MAX	369	#define ETP_PRI_MAX EIO_PRI_MAX
378		370
		371	#define ETP_TYPE_QUIT -1
		372	#define ETP_TYPE_GROUP EIO_GROUP
		373
		374	static void eio_nop_callback (void) { }
		375	static void (*eio_want_poll_cb)(void) = eio_nop_callback;
		376	static void (*eio_done_poll_cb)(void) = eio_nop_callback;
		377
		378	#define ETP_WANT_POLL(pool) eio_want_poll_cb ()
		379	#define ETP_DONE_POLL(pool) eio_done_poll_cb ()
		380
379	struct etp_worker;	381	struct etp_worker;
380
381	#define ETP_REQ eio_req	382	#define ETP_REQ eio_req
382	#define ETP_DESTROY(req) eio_destroy (req)	383	#define ETP_DESTROY(req) eio_destroy (req)
383	static int eio_finish (eio_req *req);	384	static int eio_finish (eio_req *req);
384	#define ETP_FINISH(req) eio_finish (req)	385	#define ETP_FINISH(req) eio_finish (req)
385	static void eio_execute (struct etp_worker self, eio_req req);	386	static void eio_execute (struct etp_worker self, eio_req req);
386	#define ETP_EXECUTE(wrk,req) eio_execute (wrk,req)	387	#define ETP_EXECUTE(wrk,req) eio_execute (wrk, req)
387		388
388	/*****************************************************************************/	389	#include "etp.c"
389		390
390	#define ETP_NUM_PRI (ETP_PRI_MAX - ETP_PRI_MIN + 1)	391	static struct etp_pool eio_pool;
391		392	#define EIO_POOL (&eio_pool)
392	/* calculate time difference in ~1/EIO_TICKS of a second */
393	ecb_inline int
394	tvdiff (struct timeval tv1, struct timeval tv2)
395	{
396	return (tv2->tv_sec - tv1->tv_sec ) * EIO_TICKS
397	+ ((tv2->tv_usec - tv1->tv_usec) >> 10);
398	}
399
400	static unsigned int started, idle, wanted = 4;
401
402	static void (*want_poll_cb) (void);
403	static void (*done_poll_cb) (void);
404
405	static unsigned int max_poll_time; /* reslock */
406	static unsigned int max_poll_reqs; /* reslock */
407
408	static unsigned int nreqs; /* reqlock */
409	static unsigned int nready; /* reqlock */
410	static unsigned int npending; /* reqlock */
411	static unsigned int max_idle = 4; /* maximum number of threads that can idle indefinitely */
412	static unsigned int idle_timeout = 10; /* number of seconds after which an idle threads exit */
413
414	static xmutex_t wrklock;
415	static xmutex_t reslock;
416	static xmutex_t reqlock;
417	static xcond_t reqwait;
418
419	typedef struct etp_worker
420	{
421	struct tmpbuf tmpbuf;
422
423	/* locked by wrklock */
424	struct etp_worker prev, next;
425
426	xthread_t tid;
427
428	#ifdef ETP_WORKER_COMMON
429	ETP_WORKER_COMMON
430	#endif
431	} etp_worker;
432
433	static etp_worker wrk_first; /* NOT etp */
434
435	#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock)
436	#define ETP_WORKER_UNLOCK(wrk) X_UNLOCK (wrklock)
437
438	/* worker threads management */
439
440	static void
441	etp_worker_clear (etp_worker *wrk)
442	{
443	}
444
445	static void ecb_cold
446	etp_worker_free (etp_worker *wrk)
447	{
448	free (wrk->tmpbuf.ptr);
449
450	wrk->next->prev = wrk->prev;
451	wrk->prev->next = wrk->next;
452
453	free (wrk);
454	}
455
456	static unsigned int
457	etp_nreqs (void)
458	{
459	int retval;
460	if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
461	retval = nreqs;
462	if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
463	return retval;
464	}
465
466	static unsigned int
467	etp_nready (void)
468	{
469	unsigned int retval;
470
471	if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
472	retval = nready;
473	if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
474
475	return retval;
476	}
477
478	static unsigned int
479	etp_npending (void)
480	{
481	unsigned int retval;
482
483	if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
484	retval = npending;
485	if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
486
487	return retval;
488	}
489
490	static unsigned int
491	etp_nthreads (void)
492	{
493	unsigned int retval;
494
495	if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
496	retval = started;
497	if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
498
499	return retval;
500	}
501
502	/*
503	* a somewhat faster data structure might be nice, but
504	* with 8 priorities this actually needs <20 insns
505	* per shift, the most expensive operation.
506	*/
507	typedef struct {
508	ETP_REQ qs[ETP_NUM_PRI], qe[ETP_NUM_PRI]; /* qstart, qend */
509	int size;
510	} etp_reqq;
511
512	static etp_reqq req_queue;
513	static etp_reqq res_queue;
514
515	static void ecb_noinline ecb_cold
516	reqq_init (etp_reqq *q)
517	{
518	int pri;
519
520	for (pri = 0; pri < ETP_NUM_PRI; ++pri)
521	q->qs[pri] = q->qe[pri] = 0;
522
523	q->size = 0;
524	}
525
526	static int ecb_noinline
527	reqq_push (etp_reqq q, ETP_REQ req)
528	{
529	int pri = req->pri;
530	req->next = 0;
531
532	if (q->qe[pri])
533	{
534	q->qe[pri]->next = req;
535	q->qe[pri] = req;
536	}
537	else
538	q->qe[pri] = q->qs[pri] = req;
539
540	return q->size++;
541	}
542
543	static ETP_REQ * ecb_noinline
544	reqq_shift (etp_reqq *q)
545	{
546	int pri;
547
548	if (!q->size)
549	return 0;
550
551	--q->size;
552
553	for (pri = ETP_NUM_PRI; pri--; )
554	{
555	eio_req *req = q->qs[pri];
556
557	if (req)
558	{
559	if (!(q->qs[pri] = (eio_req *)req->next))
560	q->qe[pri] = 0;
561
562	return req;
563	}
564	}
565
566	abort ();
567	}
568
569	static int ecb_cold
570	etp_init (void (want_poll)(void), void (done_poll)(void))
571	{
572	X_MUTEX_CREATE (wrklock);
573	X_MUTEX_CREATE (reslock);
574	X_MUTEX_CREATE (reqlock);
575	X_COND_CREATE (reqwait);
576
577	reqq_init (&req_queue);
578	reqq_init (&res_queue);
579
580	wrk_first.next =
581	wrk_first.prev = &wrk_first;
582
583	started = 0;
584	idle = 0;
585	nreqs = 0;
586	nready = 0;
587	npending = 0;
588
589	want_poll_cb = want_poll;
590	done_poll_cb = done_poll;
591
592	return 0;
593	}
594
595	X_THREAD_PROC (etp_proc);
596
597	static void ecb_cold
598	etp_start_thread (void)
599	{
600	etp_worker *wrk = calloc (1, sizeof (etp_worker));
601
602	/TODO/
603	assert (("unable to allocate worker thread data", wrk));
604
605	X_LOCK (wrklock);
606
607	if (xthread_create (&wrk->tid, etp_proc, (void *)wrk))
608	{
609	wrk->prev = &wrk_first;
610	wrk->next = wrk_first.next;
611	wrk_first.next->prev = wrk;
612	wrk_first.next = wrk;
613	++started;
614	}
615	else
616	free (wrk);
617
618	X_UNLOCK (wrklock);
619	}
620
621	static void
622	etp_maybe_start_thread (void)
623	{
624	if (ecb_expect_true (etp_nthreads () >= wanted))
625	return;
626
627	/* todo: maybe use idle here, but might be less exact */
628	if (ecb_expect_true (0 <= (int)etp_nthreads () + (int)etp_npending () - (int)etp_nreqs ()))
629	return;
630
631	etp_start_thread ();
632	}
633
634	static void ecb_cold
635	etp_end_thread (void)
636	{
637	eio_req req = calloc (1, sizeof (eio_req)); / will be freed by worker */
638
639	req->type = -1;
640	req->pri = ETP_PRI_MAX - ETP_PRI_MIN;
641
642	X_LOCK (reqlock);
643	reqq_push (&req_queue, req);
644	X_COND_SIGNAL (reqwait);
645	X_UNLOCK (reqlock);
646
647	X_LOCK (wrklock);
648	--started;
649	X_UNLOCK (wrklock);
650	}
651
652	static int
653	etp_poll (void)
654	{
655	unsigned int maxreqs;
656	unsigned int maxtime;
657	struct timeval tv_start, tv_now;
658
659	X_LOCK (reslock);
660	maxreqs = max_poll_reqs;
661	maxtime = max_poll_time;
662	X_UNLOCK (reslock);
663
664	if (maxtime)
665	gettimeofday (&tv_start, 0);
666
667	for (;;)
668	{
669	ETP_REQ *req;
670
671	etp_maybe_start_thread ();
672
673	X_LOCK (reslock);
674	req = reqq_shift (&res_queue);
675
676	if (req)
677	{
678	--npending;
679
680	if (!res_queue.size && done_poll_cb)
681	done_poll_cb ();
682	}
683
684	X_UNLOCK (reslock);
685
686	if (!req)
687	return 0;
688
689	X_LOCK (reqlock);
690	--nreqs;
691	X_UNLOCK (reqlock);
692
693	if (ecb_expect_false (req->type == EIO_GROUP && req->size))
694	{
695	req->int1 = 1; /* mark request as delayed */
696	continue;
697	}
698	else
699	{
700	int res = ETP_FINISH (req);
701	if (ecb_expect_false (res))
702	return res;
703	}
704
705	if (ecb_expect_false (maxreqs && !--maxreqs))
706	break;
707
708	if (maxtime)
709	{
710	gettimeofday (&tv_now, 0);
711
712	if (tvdiff (&tv_start, &tv_now) >= maxtime)
713	break;
714	}
715	}
716
717	errno = EAGAIN;
718	return -1;
719	}
720
721	static void
722	etp_cancel (ETP_REQ *req)
723	{
724	req->cancelled = 1;
725
726	eio_grp_cancel (req);
727	}
728
729	static void
730	etp_submit (ETP_REQ *req)
731	{
732	req->pri -= ETP_PRI_MIN;
733
734	if (ecb_expect_false (req->pri < ETP_PRI_MIN - ETP_PRI_MIN)) req->pri = ETP_PRI_MIN - ETP_PRI_MIN;
735	if (ecb_expect_false (req->pri > ETP_PRI_MAX - ETP_PRI_MIN)) req->pri = ETP_PRI_MAX - ETP_PRI_MIN;
736
737	if (ecb_expect_false (req->type == EIO_GROUP))
738	{
739	/* I hope this is worth it :/ */
740	X_LOCK (reqlock);
741	++nreqs;
742	X_UNLOCK (reqlock);
743
744	X_LOCK (reslock);
745
746	++npending;
747
748	if (!reqq_push (&res_queue, req) && want_poll_cb)
749	want_poll_cb ();
750
751	X_UNLOCK (reslock);
752	}
753	else
754	{
755	X_LOCK (reqlock);
756	++nreqs;
757	++nready;
758	reqq_push (&req_queue, req);
759	X_COND_SIGNAL (reqwait);
760	X_UNLOCK (reqlock);
761
762	etp_maybe_start_thread ();
763	}
764	}
765
766	static void ecb_cold
767	etp_set_max_poll_time (double nseconds)
768	{
769	if (WORDACCESS_UNSAFE) X_LOCK (reslock);
770	max_poll_time = nseconds * EIO_TICKS;
771	if (WORDACCESS_UNSAFE) X_UNLOCK (reslock);
772	}
773
774	static void ecb_cold
775	etp_set_max_poll_reqs (unsigned int maxreqs)
776	{
777	if (WORDACCESS_UNSAFE) X_LOCK (reslock);
778	max_poll_reqs = maxreqs;
779	if (WORDACCESS_UNSAFE) X_UNLOCK (reslock);
780	}
781
782	static void ecb_cold
783	etp_set_max_idle (unsigned int nthreads)
784	{
785	if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
786	max_idle = nthreads;
787	if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
788	}
789
790	static void ecb_cold
791	etp_set_idle_timeout (unsigned int seconds)
792	{
793	if (WORDACCESS_UNSAFE) X_LOCK (reqlock);
794	idle_timeout = seconds;
795	if (WORDACCESS_UNSAFE) X_UNLOCK (reqlock);
796	}
797
798	static void ecb_cold
799	etp_set_min_parallel (unsigned int nthreads)
800	{
801	if (wanted < nthreads)
802	wanted = nthreads;
803	}
804
805	static void ecb_cold
806	etp_set_max_parallel (unsigned int nthreads)
807	{
808	if (wanted > nthreads)
809	wanted = nthreads;
810
811	while (started > wanted)
812	etp_end_thread ();
813	}
814		393
815	/*****************************************************************************/	394	/*****************************************************************************/
816		395
817	static void	396	static void
818	grp_try_feed (eio_req *grp)	397	grp_try_feed (eio_req *grp)
819	{	398	{
820	while (grp->size < grp->int2 && !EIO_CANCELLED (grp))	399	while (grp->size < grp->int2 && !EIO_CANCELLED (grp))
821	{	400	{
822	grp->flags &= ~EIO_FLAG_GROUPADD;	401	grp->flags &= ~ETP_FLAG_GROUPADD;
823		402
824	EIO_FEED (grp);	403	EIO_FEED (grp);
825		404
826	/* stop if no progress has been made */	405	/* stop if no progress has been made */
827	if (!(grp->flags & EIO_FLAG_GROUPADD))	406	if (!(grp->flags & ETP_FLAG_GROUPADD))
828	{	407	{
829	grp->feed = 0;	408	grp->feed = 0;
830	break;	409	break;
831	}	410	}
832	}	411	}
…		…
839		418
840	/* call feeder, if applicable */	419	/* call feeder, if applicable */
841	grp_try_feed (grp);	420	grp_try_feed (grp);
842		421
843	/* finish, if done */	422	/* finish, if done */
844	if (!grp->size && grp->int1)	423	if (!grp->size && grp->flags & ETP_FLAG_DELAYED)
845	return eio_finish (grp);	424	return eio_finish (grp);
846	else	425	else
847	return 0;	426	return 0;
848	}	427	}
849		428
…		…
885	}	464	}
886		465
887	void	466	void
888	eio_grp_cancel (eio_req *grp)	467	eio_grp_cancel (eio_req *grp)
889	{	468	{
890	for (grp = grp->grp_first; grp; grp = grp->grp_next)	469	etp_grp_cancel (EIO_POOL, grp);
891	eio_cancel (grp);
892	}	470	}
893		471
894	void	472	void
895	eio_cancel (eio_req *req)	473	eio_cancel (eio_req *req)
896	{	474	{
897	etp_cancel (req);	475	etp_cancel (EIO_POOL, req);
898	}	476	}
899		477
900	void	478	void
901	eio_submit (eio_req *req)	479	eio_submit (eio_req *req)
902	{	480	{
903	etp_submit (req);	481	etp_submit (EIO_POOL, req);
904	}	482	}
905		483
906	unsigned int	484	unsigned int
907	eio_nreqs (void)	485	eio_nreqs (void)
908	{	486	{
909	return etp_nreqs ();	487	return etp_nreqs (EIO_POOL);
910	}	488	}
911		489
912	unsigned int	490	unsigned int
913	eio_nready (void)	491	eio_nready (void)
914	{	492	{
915	return etp_nready ();	493	return etp_nready (EIO_POOL);
916	}	494	}
917		495
918	unsigned int	496	unsigned int
919	eio_npending (void)	497	eio_npending (void)
920	{	498	{
921	return etp_npending ();	499	return etp_npending (EIO_POOL);
922	}	500	}
923		501
924	unsigned int ecb_cold	502	unsigned int ecb_cold
925	eio_nthreads (void)	503	eio_nthreads (void)
926	{	504	{
927	return etp_nthreads ();	505	return etp_nthreads (EIO_POOL);
928	}	506	}
929		507
930	void ecb_cold	508	void ecb_cold
931	eio_set_max_poll_time (double nseconds)	509	eio_set_max_poll_time (double nseconds)
932	{	510	{
933	etp_set_max_poll_time (nseconds);	511	etp_set_max_poll_time (EIO_POOL, nseconds);
934	}	512	}
935		513
936	void ecb_cold	514	void ecb_cold
937	eio_set_max_poll_reqs (unsigned int maxreqs)	515	eio_set_max_poll_reqs (unsigned int maxreqs)
938	{	516	{
939	etp_set_max_poll_reqs (maxreqs);	517	etp_set_max_poll_reqs (EIO_POOL, maxreqs);
940	}	518	}
941		519
942	void ecb_cold	520	void ecb_cold
943	eio_set_max_idle (unsigned int nthreads)	521	eio_set_max_idle (unsigned int nthreads)
944	{	522	{
945	etp_set_max_idle (nthreads);	523	etp_set_max_idle (EIO_POOL, nthreads);
946	}	524	}
947		525
948	void ecb_cold	526	void ecb_cold
949	eio_set_idle_timeout (unsigned int seconds)	527	eio_set_idle_timeout (unsigned int seconds)
950	{	528	{
951	etp_set_idle_timeout (seconds);	529	etp_set_idle_timeout (EIO_POOL, seconds);
952	}	530	}
953		531
954	void ecb_cold	532	void ecb_cold
955	eio_set_min_parallel (unsigned int nthreads)	533	eio_set_min_parallel (unsigned int nthreads)
956	{	534	{
957	etp_set_min_parallel (nthreads);	535	etp_set_min_parallel (EIO_POOL, nthreads);
958	}	536	}
959		537
960	void ecb_cold	538	void ecb_cold
961	eio_set_max_parallel (unsigned int nthreads)	539	eio_set_max_parallel (unsigned int nthreads)
962	{	540	{
963	etp_set_max_parallel (nthreads);	541	etp_set_max_parallel (EIO_POOL, nthreads);
964	}	542	}
965		543
966	int eio_poll (void)	544	int eio_poll (void)
967	{	545	{
968	return etp_poll ();	546	return etp_poll (EIO_POOL);
969	}	547	}
970		548
971	/*****************************************************************************/	549	/*****************************************************************************/
972	/* work around various missing functions */	550	/* work around various missing functions */
973		551
…		…
1383	req->result = req->offs == (off_t)-1 ? -1 : 0;	961	req->result = req->offs == (off_t)-1 ? -1 : 0;
1384	}	962	}
1385		963
1386	/* result will always end up in tmpbuf, there is always space for adding a 0-byte */	964	/* result will always end up in tmpbuf, there is always space for adding a 0-byte */
1387	static int	965	static int
1388	eio__realpath (struct tmpbuf tmpbuf, eio_wd wd, const char path)	966	eio__realpath (struct etp_tmpbuf tmpbuf, eio_wd wd, const char path)
1389	{	967	{
		968	char *res;
1390	const char *rel = path;	969	const char *rel = path;
1391	char *res;
1392	char tmp1, tmp2;	970	char tmp1, tmp2;
1393	#if SYMLOOP_MAX > 32	971	#if SYMLOOP_MAX > 32
1394	int symlinks = SYMLOOP_MAX;	972	int symlinks = SYMLOOP_MAX;
1395	#else	973	#else
1396	int symlinks = 32;	974	int symlinks = 32;
…		…
1402		980
1403	errno = ENOENT;	981	errno = ENOENT;
1404	if (!*rel)	982	if (!*rel)
1405	return -1;	983	return -1;
1406		984
1407	res = tmpbuf_get (tmpbuf, PATH_MAX * 3);	985	res = etp_tmpbuf_get (tmpbuf, EIO_PATH_MAX * 3);
		986	#ifdef _WIN32
		987	if (_access (rel, 4) != 0)
		988	return -1;
		989
		990	symlinks = GetFullPathName (rel, EIO_PATH_MAX * 3, res, 0);
		991
		992	errno = ENAMETOOLONG;
		993	if (symlinks >= EIO_PATH_MAX * 3)
		994	return -1;
		995
		996	errno = EIO;
		997	if (symlinks <= 0)
		998	return -1;
		999
		1000	return symlinks;
		1001
		1002	#else
1408	tmp1 = res + PATH_MAX;	1003	tmp1 = res + EIO_PATH_MAX;
1409	tmp2 = tmp1 + PATH_MAX;	1004	tmp2 = tmp1 + EIO_PATH_MAX;
1410		1005
1411	#if 0 /* disabled, the musl way to do things is just too racy */	1006	#if 0 /* disabled, the musl way to do things is just too racy */
1412	#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)	1007	#if __linux && defined(O_NONBLOCK) && defined(O_NOATIME)
1413	/* on linux we may be able to ask the kernel */	1008	/* on linux we may be able to ask the kernel */
1414	{	1009	{
1415	int fd = open (rel, O_RDONLY \| O_NONBLOCK \| O_NOCTTY \| O_NOATIME);	1010	int fd = open (rel, O_RDONLY \| O_NONBLOCK \| O_NOCTTY \| O_NOATIME);
1416		1011
1417	if (fd >= 0)	1012	if (fd >= 0)
1418	{	1013	{
1419	sprintf (tmp1, "/proc/self/fd/%d", fd);	1014	sprintf (tmp1, "/proc/self/fd/%d", fd);
1420	req->result = readlink (tmp1, res, PATH_MAX);	1015	req->result = readlink (tmp1, res, EIO_PATH_MAX);
		1016	/* here we should probably stat the open file and the disk file, to make sure they still match */
1421	close (fd);	1017	close (fd);
1422
1423	/* here we should probably stat the open file and the disk file, to make sure they still match */
1424		1018
1425	if (req->result > 0)	1019	if (req->result > 0)
1426	goto done;	1020	goto done;
1427	}	1021	}
1428	else if (errno == ELOOP \|\| errno == ENAMETOOLONG \|\| errno == ENOENT \|\| errno == ENOTDIR \|\| errno == EIO)	1022	else if (errno == ELOOP \|\| errno == ENAMETOOLONG \|\| errno == ENOENT \|\| errno == ENOTDIR \|\| errno == EIO)
1429	return;	1023	return -1;
1430	}	1024	}
1431	#endif	1025	#endif
1432	#endif	1026	#endif
1433		1027
1434	if (*rel != '/')	1028	if (*rel != '/')
…		…
1439	if (wd == EIO_INVALID_WD)	1033	if (wd == EIO_INVALID_WD)
1440	return -1;	1034	return -1;
1441		1035
1442	if (wd == EIO_CWD)	1036	if (wd == EIO_CWD)
1443	{	1037	{
1444	if (!getcwd (res, PATH_MAX))	1038	if (!getcwd (res, EIO_PATH_MAX))
1445	return -1;	1039	return -1;
1446		1040
1447	len = strlen (res);	1041	len = strlen (res);
1448	}	1042	}
1449	else	1043	else
…		…
1496		1090
1497	/* zero-terminate, for readlink */	1091	/* zero-terminate, for readlink */
1498	res [len + 1] = 0;	1092	res [len + 1] = 0;
1499		1093
1500	/* now check if it's a symlink */	1094	/* now check if it's a symlink */
1501	linklen = readlink (tmpbuf->ptr, tmp1, PATH_MAX);	1095	linklen = readlink (tmpbuf->ptr, tmp1, EIO_PATH_MAX);
1502		1096
1503	if (linklen < 0)	1097	if (linklen < 0)
1504	{	1098	{
1505	if (errno != EINVAL)	1099	if (errno != EINVAL)
1506	return -1;	1100	return -1;
…		…
1512	{	1106	{
1513	/* yay, it was a symlink - build new path in tmp2 */	1107	/* yay, it was a symlink - build new path in tmp2 */
1514	int rellen = strlen (rel);	1108	int rellen = strlen (rel);
1515		1109
1516	errno = ENAMETOOLONG;	1110	errno = ENAMETOOLONG;
1517	if (linklen + 1 + rellen >= PATH_MAX)	1111	if (linklen + 1 + rellen >= EIO_PATH_MAX) /* also catch linklen >= EIO_PATH_MAX */
1518	return -1;	1112	return -1;
1519		1113
1520	errno = ELOOP;	1114	errno = ELOOP;
1521	if (!--symlinks)	1115	if (!--symlinks)
1522	return -1;	1116	return -1;
…		…
1536	/* special case for the lone root path */	1130	/* special case for the lone root path */
1537	if (res == tmpbuf->ptr)	1131	if (res == tmpbuf->ptr)
1538	*res++ = '/';	1132	*res++ = '/';
1539		1133
1540	return res - (char *)tmpbuf->ptr;	1134	return res - (char *)tmpbuf->ptr;
		1135	#endif
1541	}	1136	}
1542		1137
1543	static signed char	1138	static signed char
1544	eio_dent_cmp (const eio_dirent a, const eio_dirent b)	1139	eio_dent_cmp (const eio_dirent a, const eio_dirent b)
1545	{	1140	{
…		…
2004	#if !HAVE_AT	1599	#if !HAVE_AT
2005		1600
2006	/* a bit like realpath, but usually faster because it doesn'T have to return */	1601	/* a bit like realpath, but usually faster because it doesn'T have to return */
2007	/* an absolute or canonical path */	1602	/* an absolute or canonical path */
2008	static const char *	1603	static const char *
2009	wd_expand (struct tmpbuf tmpbuf, eio_wd wd, const char path)	1604	wd_expand (struct etp_tmpbuf tmpbuf, eio_wd wd, const char path)
2010	{	1605	{
2011	if (!wd \|\| *path == '/')	1606	if (!wd \|\| *path == '/')
2012	return path;	1607	return path;
2013		1608
2014	if (path [0] == '.' && !path [1])	1609	if (path [0] == '.' && !path [1])
…		…
2016		1611
2017	{	1612	{
2018	int l1 = wd->len;	1613	int l1 = wd->len;
2019	int l2 = strlen (path);	1614	int l2 = strlen (path);
2020		1615
2021	char *res = tmpbuf_get (tmpbuf, l1 + l2 + 2);	1616	char *res = etp_tmpbuf_get (tmpbuf, l1 + l2 + 2);
2022		1617
2023	memcpy (res, wd->str, l1);	1618	memcpy (res, wd->str, l1);
2024	res [l1] = '/';	1619	res [l1] = '/';
2025	memcpy (res + l1 + 1, path, l2 + 1);	1620	memcpy (res + l1 + 1, path, l2 + 1);
2026		1621
…		…
2029	}	1624	}
2030		1625
2031	#endif	1626	#endif
2032		1627
2033	static eio_wd	1628	static eio_wd
2034	eio__wd_open_sync (struct tmpbuf tmpbuf, eio_wd wd, const char path)	1629	eio__wd_open_sync (struct etp_tmpbuf tmpbuf, eio_wd wd, const char path)
2035	{	1630	{
2036	int fd;	1631	int fd;
2037	eio_wd res;	1632	eio_wd res;
2038	int len = eio__realpath (tmpbuf, wd, path);	1633	int len = eio__realpath (tmpbuf, wd, path);
2039		1634
…		…
2061	}	1656	}
2062		1657
2063	eio_wd	1658	eio_wd
2064	eio_wd_open_sync (eio_wd wd, const char *path)	1659	eio_wd_open_sync (eio_wd wd, const char *path)
2065	{	1660	{
2066	struct tmpbuf tmpbuf = { 0 };	1661	struct etp_tmpbuf tmpbuf = { };
2067	wd = eio__wd_open_sync (&tmpbuf, wd, path);	1662	wd = eio__wd_open_sync (&tmpbuf, wd, path);
2068	free (tmpbuf.ptr);	1663	free (tmpbuf.ptr);
2069		1664
2070	return wd;	1665	return wd;
2071	}	1666	}
…		…
2120	/*****************************************************************************/	1715	/*****************************************************************************/
2121		1716
2122	#define ALLOC(len) \	1717	#define ALLOC(len) \
2123	if (!req->ptr2) \	1718	if (!req->ptr2) \
2124	{ \	1719	{ \
2125	X_LOCK (wrklock); \	1720	X_LOCK (EIO_POOL->wrklock); \
2126	req->flags \|= EIO_FLAG_PTR2_FREE; \	1721	req->flags \|= EIO_FLAG_PTR2_FREE; \
2127	X_UNLOCK (wrklock); \	1722	X_UNLOCK (EIO_POOL->wrklock); \
2128	req->ptr2 = malloc (len); \	1723	req->ptr2 = malloc (len); \
2129	if (!req->ptr2) \	1724	if (!req->ptr2) \
2130	{ \	1725	{ \
2131	errno = ENOMEM; \	1726	errno = ENOMEM; \
2132	req->result = -1; \	1727	req->result = -1; \
2133	break; \	1728	break; \
2134	} \	1729	} \
2135	}	1730	}
2136		1731
2137	static void ecb_noinline ecb_cold
2138	etp_proc_init (void)
2139	{
2140	#if HAVE_PRCTL_SET_NAME
2141	/* provide a more sensible "thread name" */
2142	char name[16 + 1];
2143	const int namelen = sizeof (name) - 1;
2144	int len;
2145
2146	prctl (PR_GET_NAME, (unsigned long)name, 0, 0, 0);
2147	name [namelen] = 0;
2148	len = strlen (name);
2149	strcpy (name + (len <= namelen - 4 ? len : namelen - 4), "/eio");
2150	prctl (PR_SET_NAME, (unsigned long)name, 0, 0, 0);
2151	#endif
2152	}
2153
2154	X_THREAD_PROC (etp_proc)
2155	{
2156	ETP_REQ *req;
2157	struct timespec ts;
2158	etp_worker self = (etp_worker )thr_arg;
2159
2160	etp_proc_init ();
2161
2162	/* try to distribute timeouts somewhat evenly */
2163	ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
2164
2165	for (;;)
2166	{
2167	ts.tv_sec = 0;
2168
2169	X_LOCK (reqlock);
2170
2171	for (;;)
2172	{
2173	req = reqq_shift (&req_queue);
2174
2175	if (req)
2176	break;
2177
2178	if (ts.tv_sec == 1) /* no request, but timeout detected, let's quit */
2179	{
2180	X_UNLOCK (reqlock);
2181	X_LOCK (wrklock);
2182	--started;
2183	X_UNLOCK (wrklock);
2184	goto quit;
2185	}
2186
2187	++idle;
2188
2189	if (idle <= max_idle)
2190	/* we are allowed to idle, so do so without any timeout */
2191	X_COND_WAIT (reqwait, reqlock);
2192	else
2193	{
2194	/* initialise timeout once */
2195	if (!ts.tv_sec)
2196	ts.tv_sec = time (0) + idle_timeout;
2197
2198	if (X_COND_TIMEDWAIT (reqwait, reqlock, ts) == ETIMEDOUT)
2199	ts.tv_sec = 1; /* assuming this is not a value computed above.,.. */
2200	}
2201
2202	--idle;
2203	}
2204
2205	--nready;
2206
2207	X_UNLOCK (reqlock);
2208
2209	if (req->type < 0)
2210	goto quit;
2211
2212	ETP_EXECUTE (self, req);
2213
2214	X_LOCK (reslock);
2215
2216	++npending;
2217
2218	if (!reqq_push (&res_queue, req) && want_poll_cb)
2219	want_poll_cb ();
2220
2221	etp_worker_clear (self);
2222
2223	X_UNLOCK (reslock);
2224	}
2225
2226	quit:
2227	free (req);
2228
2229	X_LOCK (wrklock);
2230	etp_worker_free (self);
2231	X_UNLOCK (wrklock);
2232
2233	return 0;
2234	}
2235
2236	/*****************************************************************************/	1732	/*****************************************************************************/
2237		1733
2238	int ecb_cold	1734	int ecb_cold
2239	eio_init (void (want_poll)(void), void (done_poll)(void))	1735	eio_init (void (want_poll)(void), void (done_poll)(void))
2240	{	1736	{
2241	return etp_init (want_poll, done_poll);	1737	eio_want_poll_cb = want_poll;
		1738	eio_done_poll_cb = done_poll;
		1739
		1740	return etp_init (EIO_POOL, 0, 0, 0);
2242	}	1741	}
2243		1742
2244	ecb_inline void	1743	ecb_inline void
2245	eio_api_destroy (eio_req *req)	1744	eio_api_destroy (eio_req *req)
2246	{	1745	{
…		…
2269	{ \	1768	{ \
2270	eio_api_destroy (req); \	1769	eio_api_destroy (req); \
2271	return 0; \	1770	return 0; \
2272	}	1771	}
2273		1772
		1773	#define SINGLEDOT(ptr) (0[(char )(ptr)] == '.' && !1[(char )(ptr)])
		1774
2274	static void	1775	static void
2275	eio_execute (etp_worker self, eio_req req)	1776	eio_execute (etp_worker self, eio_req req)
2276	{	1777	{
2277	#if HAVE_AT	1778	#if HAVE_AT
2278	int dirfd;	1779	int dirfd;
…		…
2318	: read (req->int1, req->ptr2, req->size); break;	1819	: read (req->int1, req->ptr2, req->size); break;
2319	case EIO_WRITE: req->result = req->offs >= 0	1820	case EIO_WRITE: req->result = req->offs >= 0
2320	? pwrite (req->int1, req->ptr2, req->size, req->offs)	1821	? pwrite (req->int1, req->ptr2, req->size, req->offs)
2321	: write (req->int1, req->ptr2, req->size); break;	1822	: write (req->int1, req->ptr2, req->size); break;
2322		1823
		1824	case EIO_FCNTL: req->result = fcntl (req->int1, (int) req->int2, req->ptr2); break;
		1825	case EIO_IOCTL: req->result = ioctl (req->int1, (unsigned long)req->int2, req->ptr2); break;
		1826
2323	case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;	1827	case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
2324	case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break;	1828	case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break;
2325		1829
2326	#if HAVE_AT	1830	#if HAVE_AT
2327		1831
…		…
2333	case EIO_CHMOD: req->result = fchmodat (dirfd, req->ptr1, (mode_t)req->int2, 0); break;	1837	case EIO_CHMOD: req->result = fchmodat (dirfd, req->ptr1, (mode_t)req->int2, 0); break;
2334	case EIO_TRUNCATE: req->result = eio__truncateat (dirfd, req->ptr1, req->offs); break;	1838	case EIO_TRUNCATE: req->result = eio__truncateat (dirfd, req->ptr1, req->offs); break;
2335	case EIO_OPEN: req->result = openat (dirfd, req->ptr1, req->int1, (mode_t)req->int2); break;	1839	case EIO_OPEN: req->result = openat (dirfd, req->ptr1, req->int1, (mode_t)req->int2); break;
2336		1840
2337	case EIO_UNLINK: req->result = unlinkat (dirfd, req->ptr1, 0); break;	1841	case EIO_UNLINK: req->result = unlinkat (dirfd, req->ptr1, 0); break;
2338	case EIO_RMDIR: req->result = unlinkat (dirfd, req->ptr1, AT_REMOVEDIR); break;	1842	case EIO_RMDIR: /* complications arise because "." cannot be removed, so we might have to expand */
		1843	req->result = req->wd && SINGLEDOT (req->ptr1)
		1844	? rmdir (req->wd->str)
		1845	: unlinkat (dirfd, req->ptr1, AT_REMOVEDIR); break;
2339	case EIO_MKDIR: req->result = mkdirat (dirfd, req->ptr1, (mode_t)req->int2); break;	1846	case EIO_MKDIR: req->result = mkdirat (dirfd, req->ptr1, (mode_t)req->int2); break;
2340	case EIO_RENAME: req->result = renameat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2); break;	1847	case EIO_RENAME: /* complications arise because "." cannot be renamed, so we might have to expand */
		1848	req->result = req->wd && SINGLEDOT (req->ptr1)
		1849	? rename (req->wd->str, req->ptr2)
		1850	: renameat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2); break;
2341	case EIO_LINK: req->result = linkat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2, 0); break;	1851	case EIO_LINK: req->result = linkat (dirfd, req->ptr1, WD2FD ((eio_wd)req->int3), req->ptr2, 0); break;
2342	case EIO_SYMLINK: req->result = symlinkat (req->ptr1, dirfd, req->ptr2); break;	1852	case EIO_SYMLINK: req->result = symlinkat (req->ptr1, dirfd, req->ptr2); break;
2343	case EIO_MKNOD: req->result = mknodat (dirfd, req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;	1853	case EIO_MKNOD: req->result = mknodat (dirfd, req->ptr1, (mode_t)req->int2, (dev_t)req->offs); break;
2344	case EIO_READLINK: ALLOC (PATH_MAX);
2345	req->result = readlinkat (dirfd, req->ptr1, req->ptr2, PATH_MAX); break;
2346	case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));	1854	case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2347	req->result = eio__statvfsat (dirfd, req->ptr1, (EIO_STRUCT_STATVFS *)req->ptr2); break;	1855	req->result = eio__statvfsat (dirfd, req->ptr1, (EIO_STRUCT_STATVFS *)req->ptr2); break;
		1856	case EIO_READLINK: ALLOC (EIO_PATH_MAX);
		1857	req->result = readlinkat (dirfd, req->ptr1, req->ptr2, EIO_PATH_MAX);
		1858	if (req->result == EIO_PATH_MAX)
		1859	{
		1860	req->result = -1;
		1861	errno = ENAMETOOLONG;
		1862	}
		1863	break;
2348	case EIO_UTIME:	1864	case EIO_UTIME:
2349	case EIO_FUTIME:	1865	case EIO_FUTIME:
2350	{	1866	{
2351	struct timespec ts[2];	1867	struct timespec ts[2];
2352	struct timespec *times;	1868	struct timespec *times;
…		…
2385	case EIO_MKDIR: req->result = mkdir (path , (mode_t)req->int2); break;	1901	case EIO_MKDIR: req->result = mkdir (path , (mode_t)req->int2); break;
2386	case EIO_RENAME: req->result = rename (path , req->ptr2); break;	1902	case EIO_RENAME: req->result = rename (path , req->ptr2); break;
2387	case EIO_LINK: req->result = link (path , req->ptr2); break;	1903	case EIO_LINK: req->result = link (path , req->ptr2); break;
2388	case EIO_SYMLINK: req->result = symlink (path , req->ptr2); break;	1904	case EIO_SYMLINK: req->result = symlink (path , req->ptr2); break;
2389	case EIO_MKNOD: req->result = mknod (path , (mode_t)req->int2, (dev_t)req->offs); break;	1905	case EIO_MKNOD: req->result = mknod (path , (mode_t)req->int2, (dev_t)req->offs); break;
2390	case EIO_READLINK: ALLOC (PATH_MAX);
2391	req->result = readlink (path, req->ptr2, PATH_MAX); break;
2392	case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));	1906	case EIO_STATVFS: ALLOC (sizeof (EIO_STRUCT_STATVFS));
2393	req->result = statvfs (path , (EIO_STRUCT_STATVFS *)req->ptr2); break;	1907	req->result = statvfs (path , (EIO_STRUCT_STATVFS *)req->ptr2); break;
		1908	case EIO_READLINK: ALLOC (EIO_PATH_MAX);
		1909	req->result = readlink (path, req->ptr2, EIO_PATH_MAX);
		1910	if (req->result == EIO_PATH_MAX)
		1911	{
		1912	req->result = -1;
		1913	errno = ENAMETOOLONG;
		1914	}
		1915	break;
2394		1916
2395	case EIO_UTIME:	1917	case EIO_UTIME:
2396	case EIO_FUTIME:	1918	case EIO_FUTIME:
2397	{	1919	{
2398	struct timeval tv[2];	1920	struct timeval tv[2];
…		…
2463	req->result = select (0, 0, 0, 0, &tv);	1985	req->result = select (0, 0, 0, 0, &tv);
2464	}	1986	}
2465	#endif	1987	#endif
2466	break;	1988	break;
2467		1989
		1990	#if 0
2468	case EIO_GROUP:	1991	case EIO_GROUP:
2469	abort (); /* handled in eio_request */	1992	abort (); /* handled in eio_request */
		1993	#endif
2470		1994
2471	case EIO_NOP:	1995	case EIO_NOP:
2472	req->result = 0;	1996	req->result = 0;
2473	break;	1997	break;
2474		1998
…		…
2577	}	2101	}
2578		2102
2579	eio_req eio_write (int fd, void buf, size_t length, off_t offset, int pri, eio_cb cb, void *data)	2103	eio_req eio_write (int fd, void buf, size_t length, off_t offset, int pri, eio_cb cb, void *data)
2580	{	2104	{
2581	REQ (EIO_WRITE); req->int1 = fd; req->offs = offset; req->size = length; req->ptr2 = buf; SEND;	2105	REQ (EIO_WRITE); req->int1 = fd; req->offs = offset; req->size = length; req->ptr2 = buf; SEND;
		2106	}
		2107
		2108	eio_req eio_fcntl (int fd, int cmd, void arg, int pri, eio_cb cb, void *data)
		2109	{
		2110	REQ (EIO_IOCTL); req->int1 = fd; req->int2 = cmd; req->ptr2 = arg; SEND;
		2111	}
		2112
		2113	eio_req eio_ioctl (int fd, unsigned long request, void buf, int pri, eio_cb cb, void *data)
		2114	{
		2115	REQ (EIO_IOCTL); req->int1 = fd; req->int2 = request; req->ptr2 = buf; SEND;
2582	}	2116	}
2583		2117
2584	eio_req eio_fstat (int fd, int pri, eio_cb cb, void data)	2118	eio_req eio_fstat (int fd, int pri, eio_cb cb, void data)
2585	{	2119	{
2586	REQ (EIO_FSTAT); req->int1 = fd; SEND;	2120	REQ (EIO_FSTAT); req->int1 = fd; SEND;
…		…
2774	void	2308	void
2775	eio_grp_add (eio_req grp, eio_req req)	2309	eio_grp_add (eio_req grp, eio_req req)
2776	{	2310	{
2777	assert (("cannot add requests to IO::AIO::GRP after the group finished", grp->int1 != 2));	2311	assert (("cannot add requests to IO::AIO::GRP after the group finished", grp->int1 != 2));
2778		2312
2779	grp->flags \|= EIO_FLAG_GROUPADD;	2313	grp->flags \|= ETP_FLAG_GROUPADD;
2780		2314
2781	++grp->size;	2315	++grp->size;
2782	req->grp = grp;	2316	req->grp = grp;
2783		2317
2784	req->grp_prev = 0;	2318	req->grp_prev = 0;

Diff Legend

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

Comparing libeio/eio.c (file contents): Revision 1.125 by root, Thu Dec 6 12:21:41 2012 UTC vs. Revision 1.144 by root, Tue Dec 27 09:58:44 2016 UTC

Diff Legend

Comparing libeio/eio.c (file contents):
Revision 1.125 by root, Thu Dec 6 12:21:41 2012 UTC vs.
Revision 1.144 by root, Tue Dec 27 09:58:44 2016 UTC