[ViewVC] Diff of: cvs/IO-AIO/AIO.xs

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.116 by root, Sat May 10 19:25:33 2008 UTC vs.
Revision 1.147 by root, Mon Jun 15 05:34:49 2009 UTC

…		…
12	#include <sys/types.h>	12	#include <sys/types.h>
13	#include <sys/stat.h>	13	#include <sys/stat.h>
14	#include <limits.h>	14	#include <limits.h>
15	#include <fcntl.h>	15	#include <fcntl.h>
16	#include <sched.h>	16	#include <sched.h>
		17
		18	/* perl namespace pollution */
		19	#undef VERSION
17		20
18	#ifdef _WIN32	21	#ifdef _WIN32
19		22
20	# define EIO_STRUCT_DIRENT Direntry_t	23	# define EIO_STRUCT_DIRENT Direntry_t
21	# undef malloc	24	# undef malloc
…		…
62	# include <signal.h>	65	# include <signal.h>
63	# define EIO_STRUCT_DIRENT struct dirent	66	# define EIO_STRUCT_DIRENT struct dirent
64		67
65	#endif	68	#endif
66		69
		70	/* perl stupidly overrides readdir and maybe others */
		71	/* with thread-unsafe versions, imagine that :( */
		72	#undef readdir
		73	#undef opendir
		74	#undef closedir
		75
67	#define EIO_STRUCT_STAT Stat_t	76	#define EIO_STRUCT_STAT Stat_t
68		77
69	/* use NV for 32 bit perls as it allows larger offsets */	78	/* use NV for 32 bit perls as it allows larger offsets */
70	#if IVSIZE >= 8	79	#if IVSIZE >= 8
71	# define SvVAL64 SvIV	80	# define SvVAL64 SvIV
72	#else	81	#else
73	# define SvVAL64 SvNV	82	# define SvVAL64 SvNV
74	#endif	83	#endif
75		84
		85	/*****************************************************************************/
		86
		87	#if __GNUC__ >= 3
		88	# define expect(expr,value) __builtin_expect ((expr),(value))
		89	#else
		90	# define expect(expr,value) (expr)
		91	#endif
		92
		93	#define expect_false(expr) expect ((expr) != 0, 0)
		94	#define expect_true(expr) expect ((expr) != 0, 1)
		95
		96	/*****************************************************************************/
		97
76	static HV *stash;	98	static HV *stash;
77	typedef SV SV8; /* byte-sv, used for argument-checking */	99	typedef SV SV8; /* byte-sv, used for argument-checking */
78		100
79	#define AIO_REQ_KLASS "IO::AIO::REQ"	101	#define AIO_REQ_KLASS "IO::AIO::REQ"
80	#define AIO_GRP_KLASS "IO::AIO::GRP"	102	#define AIO_GRP_KLASS "IO::AIO::GRP"
81		103
82	#define EIO_COMMON \	104	#define EIO_REQ_MEMBERS \
83	SV *callback; \	105	SV *callback; \
84	SV sv1, sv2; \	106	SV sv1, sv2; \
85	STRLEN stroffset; \	107	STRLEN stroffset; \
86	SV *self	108	SV *self;
		109
		110	#define EIO_NO_WRAPPERS 1
87		111
88	#include "libeio/eio.h"	112	#include "libeio/eio.h"
89		113
90	static int req_invoke (eio_req *req);	114	static int req_invoke (eio_req *req);
91	#define EIO_FINISH(req) req_invoke (req)	115	#define EIO_FINISH(req) req_invoke (req)
92	static void aio_grp_feed (eio_req *grp);
93	#define EIO_FEED(req) aio_grp_feed (req)
94	static void req_destroy (eio_req *grp);	116	static void req_destroy (eio_req *grp);
95	#define EIO_DESTROY(req) req_destroy (req)	117	#define EIO_DESTROY(req) req_destroy (req)
96		118
97	enum {	119	enum {
98	FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */	120	FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */
…		…
101	#include "libeio/eio.c"	123	#include "libeio/eio.c"
102		124
103	typedef eio_req *aio_req;	125	typedef eio_req *aio_req;
104	typedef eio_req *aio_req_ornot;	126	typedef eio_req *aio_req_ornot;
105		127
		128	static SV *on_next_submit;
		129	static int next_pri = EIO_PRI_DEFAULT;
106	static int max_outstanding = 0;	130	static int max_outstanding;
107
108	static int next_pri = EIO_DEFAULT_PRI + EIO_PRI_BIAS;
109		131
110	static int respipe_osf [2], respipe [2] = { -1, -1 };	132	static int respipe_osf [2], respipe [2] = { -1, -1 };
111		133
112	static void req_destroy (aio_req req);	134	static void req_destroy (aio_req req);
113	static void req_cancel (aio_req req);	135	static void req_cancel (aio_req req);
…		…
166	FREETMPS;	188	FREETMPS;
167	LEAVE;	189	LEAVE;
168	}	190	}
169	}	191	}
170		192
		193	static void req_submit (eio_req *req)
		194	{
		195	eio_submit (req);
		196
		197	if (expect_false (on_next_submit))
		198	{
		199	dSP;
		200	SV *cb = sv_2mortal (on_next_submit);
		201
		202	on_next_submit = 0;
		203
		204	PUSHMARK (SP);
		205	PUTBACK;
		206	call_sv (cb, G_DISCARD \| G_EVAL);
		207	}
		208	}
		209
171	static int req_invoke (eio_req *req)	210	static int req_invoke (eio_req *req)
172	{	211	{
173	dSP;	212	dSP;
174		213
175	if (req->flags & FLAG_SV2_RO_OFF)	214	if (req->flags & FLAG_SV2_RO_OFF)
176	SvREADONLY_off (req->sv2);	215	SvREADONLY_off (req->sv2);
177		216
178	if (!EIO_CANCELLED (req) && SvOK (req->callback))	217	if (!EIO_CANCELLED (req) && req->callback)
179	{	218	{
180	ENTER;	219	ENTER;
181	SAVETMPS;	220	SAVETMPS;
182	PUSHMARK (SP);	221	PUSHMARK (SP);
183	EXTEND (SP, 1);	222	EXTEND (SP, 1);
…		…
189	SV *rv = &PL_sv_undef;	228	SV *rv = &PL_sv_undef;
190		229
191	if (req->result >= 0)	230	if (req->result >= 0)
192	{	231	{
193	int i;	232	int i;
194	char *buf = req->ptr2;	233	char names = (char )req->ptr2;
		234	eio_dirent ent = (eio_dirent )req->ptr1; /* might be 0 */
195	AV *av = newAV ();	235	AV *av = newAV ();
196		236
197	av_extend (av, req->result - 1);	237	av_extend (av, req->result - 1);
198		238
199	for (i = 0; i < req->result; ++i)	239	for (i = 0; i < req->result; ++i)
200	{	240	{
201	SV *sv = newSVpv (buf, 0);	241	if (req->int1 & EIO_READDIR_DENTS)
		242	{
		243	SV *namesv = newSVpvn (names + ent->nameofs, ent->namelen);
202		244
		245	if (req->int1 & EIO_READDIR_CUSTOM2)
		246	{
		247	static SV sv_type [EIO_DT_MAX + 1]; / type sv cache */
		248	AV *avent = newAV ();
		249
		250	av_extend (avent, 2);
		251
		252	if (!sv_type [ent->type])
		253	{
		254	sv_type [ent->type] = newSViv (ent->type);
		255	SvREADONLY_on (sv_type [ent->type]);
		256	}
		257
		258	av_store (avent, 0, namesv);
		259	av_store (avent, 1, SvREFCNT_inc (sv_type [ent->type]));
		260	av_store (avent, 2, IVSIZE >= 8 ? newSVuv (ent->inode) : newSVnv (ent->inode));
		261
		262	av_store (av, i, newRV_noinc ((SV *)avent));
		263	}
		264	else
203	av_store (av, i, sv);	265	av_store (av, i, namesv);
		266
		267	++ent;
		268	}
		269	else
		270	{
		271	SV *name = newSVpv (names, 0);
		272	av_store (av, i, name);
204	buf += SvCUR (sv) + 1;	273	names += SvCUR (name) + 1;
		274	}
205	}	275	}
206		276
207	rv = sv_2mortal (newRV_noinc ((SV *)av));	277	rv = sv_2mortal (newRV_noinc ((SV *)av));
208	}	278	}
209		279
210	PUSHs (rv);	280	PUSHs (rv);
		281
		282	if (req->int1 & EIO_READDIR_CUSTOM1)
		283	XPUSHs (sv_2mortal (newSViv (req->int1 & ~(EIO_READDIR_CUSTOM1 \| EIO_READDIR_CUSTOM2))));
211	}	284	}
212	break;	285	break;
213		286
214	case EIO_OPEN:	287	case EIO_OPEN:
215	{	288	{
…		…
221	GV gv = (GV )sv_newmortal ();	294	GV gv = (GV )sv_newmortal ();
222	int flags = req->int1 & (O_RDONLY \| O_WRONLY \| O_RDWR);	295	int flags = req->int1 & (O_RDONLY \| O_WRONLY \| O_RDWR);
223	char sym [64];	296	char sym [64];
224	int symlen;	297	int symlen;
225		298
226	symlen = snprintf (sym, sizeof (sym), "fd#%d", req->result);	299	symlen = snprintf (sym, sizeof (sym), "fd#%d", (int)req->result);
227	gv_init (gv, stash, sym, symlen, 0);	300	gv_init (gv, stash, sym, symlen, 0);
228		301
229	symlen = snprintf (	302	symlen = snprintf (
230	sym,	303	sym,
231	sizeof (sym),	304	sizeof (sym),
232	"%s&=%d",	305	"%s&=%d",
233	flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",	306	flags == O_RDONLY ? "<" : flags == O_WRONLY ? ">" : "+<",
234	req->result	307	(int)req->result
235	);	308	);
236		309
237	if (do_open (gv, sym, symlen, 0, 0, 0, 0))	310	if (do_open (gv, sym, symlen, 0, 0, 0, 0))
238	fh = (SV *)gv;	311	fh = (SV *)gv;
239	}	312	}
…		…
260	case EIO_BUSY:	333	case EIO_BUSY:
261	break;	334	break;
262		335
263	case EIO_READLINK:	336	case EIO_READLINK:
264	if (req->result > 0)	337	if (req->result > 0)
265	{	338	PUSHs (sv_2mortal (newSVpvn (req->ptr2, req->result)));
266	SvCUR_set (req->sv2, req->result);
267	*SvEND (req->sv2) = 0;
268	PUSHs (req->sv2);
269	}
270	break;	339	break;
271		340
272	case EIO_STAT:	341	case EIO_STAT:
273	case EIO_LSTAT:	342	case EIO_LSTAT:
274	case EIO_FSTAT:	343	case EIO_FSTAT:
…		…
277	PL_statcache = (EIO_STRUCT_STAT )(req->ptr2);	346	PL_statcache = (EIO_STRUCT_STAT )(req->ptr2);
278	PUSHs (sv_2mortal (newSViv (req->result)));	347	PUSHs (sv_2mortal (newSViv (req->result)));
279	break;	348	break;
280		349
281	case EIO_READ:	350	case EIO_READ:
		351	{
282	SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));	352	SvCUR_set (req->sv2, req->stroffset + (req->result > 0 ? req->result : 0));
283	*SvEND (req->sv2) = 0;	353	*SvEND (req->sv2) = 0;
		354	SvPOK_only (req->sv2);
		355	SvSETMAGIC (req->sv2);
284	PUSHs (sv_2mortal (newSViv (req->result)));	356	PUSHs (sv_2mortal (newSViv (req->result)));
		357	}
285	break;	358	break;
286		359
287	case EIO_DUP2:	360	case EIO_DUP2:
288	if (req->result > 0)	361	if (req->result > 0)
289	req->result = 0;	362	req->result = 0;
…		…
394	X_UNLOCK (reslock);	467	X_UNLOCK (reslock);
395		468
396	if (size)	469	if (size)
397	return;	470	return;
398		471
399	maybe_start_thread ();	472	etp_maybe_start_thread ();
400		473
401	FD_ZERO (&rfd);	474	FD_ZERO (&rfd);
402	FD_SET (respipe [0], &rfd);	475	FD_SET (respipe [0], &rfd);
403		476
404	PerlSock_select (respipe [0] + 1, &rfd, 0, 0, 0);	477	PerlSock_select (respipe [0] + 1, &rfd, 0, 0, 0);
405	}	478	}
406	}	479	}
407		480
408	static int poll_cb (void)	481	static int poll_cb (void)
409	{	482	{
410	int res;	483	for (;;)
411
412	do
413	{	484	{
414	res = eio_poll ();	485	int res = eio_poll ();
415		486
416	if (res > 0)	487	if (res > 0)
417	croak (0);	488	croak (0);
		489
		490	if (!max_outstanding \|\| max_outstanding > eio_nreqs ())
		491	return res;
		492
		493	poll_wait ();
418	}	494	}
419	while (max_outstanding && max_outstanding <= eio_nreqs ());
420
421	return res;
422	}	495	}
423		496
424	static void atfork_child (void)	497	static void atfork_child (void)
425	{	498	{
426	create_respipe ();	499	create_respipe ();
427	}	500	}
428		501
		502	static SV *
		503	get_cb (SV *cb_sv)
		504	{
		505	HV *st;
		506	GV *gvp;
		507	CV *cv;
		508
		509	if (!SvOK (cb_sv))
		510	return 0;
		511
		512	cv = sv_2cv (cb_sv, &st, &gvp, 0);
		513
		514	if (!cv)
		515	croak ("IO::AIO callback must be undef or a CODE reference");
		516
		517	return (SV *)cv;
		518	}
		519
429	#define dREQ \	520	#define dREQ \
		521	SV *cb_cv; \
430	aio_req req; \	522	aio_req req; \
431	int req_pri = next_pri; \	523	int req_pri = next_pri; \
432	next_pri = EIO_DEFAULT_PRI + EIO_PRI_BIAS; \	524	next_pri = EIO_PRI_DEFAULT; \
433	\	525	\
434	if (SvOK (callback) && !SvROK (callback)) \	526	cb_cv = get_cb (callback); \
435	croak ("callback must be undef or of reference type"); \
436	\	527	\
437	Newz (0, req, 1, eio_req); \	528	Newz (0, req, 1, eio_req); \
438	if (!req) \	529	if (!req) \
439	croak ("out of memory during eio_req allocation"); \	530	croak ("out of memory during eio_req allocation"); \
440	\	531	\
441	req->callback = newSVsv (callback); \	532	req->callback = SvREFCNT_inc (cb_cv); \
442	req->pri = req_pri	533	req->pri = req_pri
443		534
444	#define REQ_SEND \	535	#define REQ_SEND \
		536	PUTBACK; \
445	eio_submit (req); \	537	req_submit (req); \
		538	SPAGAIN; \
446	\	539	\
447	if (GIMME_V != G_VOID) \	540	if (GIMME_V != G_VOID) \
448	XPUSHs (req_sv (req, AIO_REQ_KLASS));	541	XPUSHs (req_sv (req, AIO_REQ_KLASS));
449		542
		543	static int
		544	extract_fd (SV *fh, int wr)
		545	{
		546	int fd = PerlIO_fileno (wr ? IoOFP (sv_2io (fh)) : IoIFP (sv_2io (fh)));
		547
		548	if (fd < 0)
		549	croak ("illegal fh argument, either not an OS file or read/write mode mismatch");
		550
		551	return fd;
		552	}
		553
450	MODULE = IO::AIO PACKAGE = IO::AIO	554	MODULE = IO::AIO PACKAGE = IO::AIO
451		555
452	PROTOTYPES: ENABLE	556	PROTOTYPES: ENABLE
453		557
454	BOOT:	558	BOOT:
455	{	559	{
456	stash = gv_stashpv ("IO::AIO", 1);	560	static const struct {
457		561	const char *name;
458	newCONSTSUB (stash, "EXDEV", newSViv (EXDEV));	562	IV iv;
459	newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY));	563	} *civ, const_iv[] = {
460	newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY));	564	# define const_iv(name, value) { # name, (IV) value },
461	newCONSTSUB (stash, "O_CREAT", newSViv (O_CREAT));	565	# define const_eio(name) { # name, (IV) EIO_ ## name },
462	newCONSTSUB (stash, "O_TRUNC", newSViv (O_TRUNC));	566	const_iv (EXDEV , EXDEV)
		567	const_iv (ENOSYS , ENOSYS)
		568	const_iv (O_RDONLY, O_RDONLY)
		569	const_iv (O_WRONLY, O_WRONLY)
		570	const_iv (O_CREAT , O_CREAT)
		571	const_iv (O_TRUNC , O_TRUNC)
463	#ifdef _WIN32	572	#ifndef _WIN32
464	X_MUTEX_CHECK (wrklock);	573	const_iv (S_IFIFO , S_IFIFO)
465	X_MUTEX_CHECK (reslock);
466	X_MUTEX_CHECK (reqlock);
467	X_MUTEX_CHECK (reqwait);
468	X_MUTEX_CHECK (preadwritelock);
469	X_MUTEX_CHECK (readdirlock);
470
471	X_COND_CHECK (reqwait);
472	#else
473	newCONSTSUB (stash, "S_IFIFO", newSViv (S_IFIFO));
474	#endif	574	#endif
		575	const_eio (SYNC_FILE_RANGE_WAIT_BEFORE)
		576	const_eio (SYNC_FILE_RANGE_WRITE)
		577	const_eio (SYNC_FILE_RANGE_WAIT_AFTER)
475		578
		579	const_eio (READDIR_DENTS)
		580	const_eio (READDIR_DIRS_FIRST)
		581	const_eio (READDIR_STAT_ORDER)
		582	const_eio (READDIR_FOUND_UNKNOWN)
		583
		584	const_eio (DT_UNKNOWN)
		585	const_eio (DT_FIFO)
		586	const_eio (DT_CHR)
		587	const_eio (DT_DIR)
		588	const_eio (DT_BLK)
		589	const_eio (DT_REG)
		590	const_eio (DT_LNK)
		591	const_eio (DT_SOCK)
		592	const_eio (DT_WHT)
		593	};
		594
		595	stash = gv_stashpv ("IO::AIO", 1);
		596
		597	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
		598	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
		599
476	create_respipe ();	600	create_respipe ();
477		601
478	if (eio_init (want_poll, done_poll) < 0)	602	if (eio_init (want_poll, done_poll) < 0)
479	croak ("IO::AIO: unable to initialise eio library");	603	croak ("IO::AIO: unable to initialise eio library");
480		604
481	/* atfork child called in fifo order, so before eio's handler */	605	/* atfork child called in fifo order, so before eio's handler */
482	X_THREAD_ATFORK (0, 0, atfork_child);	606	X_THREAD_ATFORK (0, 0, atfork_child);
483	}	607	}
484		608
485	void	609	void
486	max_poll_reqs (int nreqs)	610	max_poll_reqs (int nreqs)
487	PROTOTYPE: $	611	PROTOTYPE: $
…		…
540	ALIAS:	664	ALIAS:
541	aio_fsync = EIO_FSYNC	665	aio_fsync = EIO_FSYNC
542	aio_fdatasync = EIO_FDATASYNC	666	aio_fdatasync = EIO_FDATASYNC
543	PPCODE:	667	PPCODE:
544	{	668	{
		669	int fd = extract_fd (fh, 0);
545	dREQ;	670	dREQ;
546		671
547	req->type = ix;	672	req->type = ix;
548	req->sv1 = newSVsv (fh);	673	req->sv1 = newSVsv (fh);
549	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));	674	req->int1 = fd;
		675
		676	REQ_SEND (req);
		677	}
		678
		679	void
		680	aio_sync_file_range (SV fh, SV offset, SV nbytes, IV flags, SV callback=&PL_sv_undef)
		681	PROTOTYPE: $$$$;$
		682	PPCODE:
		683	{
		684	int fd = extract_fd (fh, 0);
		685	dREQ;
		686
		687	req->type = EIO_SYNC_FILE_RANGE;
		688	req->sv1 = newSVsv (fh);
		689	req->int1 = fd;
		690	req->offs = SvVAL64 (offset);
		691	req->size = SvVAL64 (nbytes);
		692	req->int2 = flags;
550		693
551	REQ_SEND (req);	694	REQ_SEND (req);
552	}	695	}
553		696
554	void	697	void
555	aio_close (SV fh, SV callback=&PL_sv_undef)	698	aio_close (SV fh, SV callback=&PL_sv_undef)
556	PROTOTYPE: $;$	699	PROTOTYPE: $;$
557	PPCODE:	700	PPCODE:
558	{	701	{
559	static int close_pipe = -1; /* dummy fd to close fds via dup2 */	702	static int close_pipe = -1; /* dummy fd to close fds via dup2 */
		703	int fd = extract_fd (fh, 0);
560	dREQ;	704	dREQ;
561		705
562	if (close_pipe < 0)	706	if (close_pipe < 0)
563	{	707	{
564	int pipefd [2];	708	int pipefd [2];
…		…
572	}	716	}
573		717
574	req->type = EIO_DUP2;	718	req->type = EIO_DUP2;
575	req->int1 = close_pipe;	719	req->int1 = close_pipe;
576	req->sv2 = newSVsv (fh);	720	req->sv2 = newSVsv (fh);
577	req->int2 = PerlIO_fileno (IoIFP (sv_2io (fh)));	721	req->int2 = fd;
578		722
579	REQ_SEND (req);	723	REQ_SEND (req);
580	}	724	}
581		725
582	void	726	void
…		…
586	aio_write = EIO_WRITE	730	aio_write = EIO_WRITE
587	PROTOTYPE: $$$$$;$	731	PROTOTYPE: $$$$$;$
588	PPCODE:	732	PPCODE:
589	{	733	{
590	STRLEN svlen;	734	STRLEN svlen;
		735	int fd = extract_fd (fh, ix == EIO_WRITE);
591	char *svptr = SvPVbyte (data, svlen);	736	char *svptr = SvPVbyte (data, svlen);
592	UV len = SvUV (length);	737	UV len = SvUV (length);
593
594	SvUPGRADE (data, SVt_PV);
595	SvPOK_on (data);
596		738
597	if (dataoffset < 0)	739	if (dataoffset < 0)
598	dataoffset += svlen;	740	dataoffset += svlen;
599		741
600	if (dataoffset < 0 \|\| dataoffset > svlen)	742	if (dataoffset < 0 \|\| dataoffset > svlen)
…		…
606	if (!SvOK (length) \|\| len + dataoffset > svlen)	748	if (!SvOK (length) \|\| len + dataoffset > svlen)
607	len = svlen - dataoffset;	749	len = svlen - dataoffset;
608	}	750	}
609	else	751	else
610	{	752	{
611	/* read: grow scalar as necessary */	753	/* read: check type and grow scalar as necessary */
		754	SvUPGRADE (data, SVt_PV);
612	svptr = SvGROW (data, len + dataoffset + 1);	755	svptr = SvGROW (data, len + dataoffset + 1);
613	}	756	}
614
615	if (len < 0)
616	croak ("length must not be negative");
617		757
618	{	758	{
619	dREQ;	759	dREQ;
620		760
621	req->type = ix;	761	req->type = ix;
622	req->sv1 = newSVsv (fh);	762	req->sv1 = newSVsv (fh);
623	req->int1 = PerlIO_fileno (ix == EIO_READ ? IoIFP (sv_2io (fh))	763	req->int1 = fd;
624	: IoOFP (sv_2io (fh)));
625	req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;	764	req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
626	req->size = len;	765	req->size = len;
627	req->sv2 = SvREFCNT_inc (data);	766	req->sv2 = SvREFCNT_inc (data);
628	req->ptr2 = (char *)svptr + dataoffset;	767	req->ptr2 = (char *)svptr + dataoffset;
629	req->stroffset = dataoffset;	768	req->stroffset = dataoffset;
…		…
644	PPCODE:	783	PPCODE:
645	{	784	{
646	SV *data;	785	SV *data;
647	dREQ;	786	dREQ;
648		787
649	data = newSV (NAME_MAX);
650	SvPOK_on (data);
651
652	req->type = EIO_READLINK;	788	req->type = EIO_READLINK;
653	req->sv1 = newSVsv (path);	789	req->sv1 = newSVsv (path);
654	req->ptr1 = SvPVbyte_nolen (req->sv1);	790	req->ptr1 = SvPVbyte_nolen (req->sv1);
655	req->sv2 = data;
656	req->ptr2 = SvPVbyte_nolen (data);
657		791
658	REQ_SEND;	792	REQ_SEND;
659	}	793	}
660		794
661	void	795	void
662	aio_sendfile (SV out_fh, SV in_fh, SV in_offset, UV length, SV callback=&PL_sv_undef)	796	aio_sendfile (SV out_fh, SV in_fh, SV in_offset, UV length, SV callback=&PL_sv_undef)
663	PROTOTYPE: $$$$;$	797	PROTOTYPE: $$$$;$
664	PPCODE:	798	PPCODE:
665	{	799	{
		800	int ifd = extract_fd (in_fh , 0);
		801	int ofd = extract_fd (out_fh, 0);
666	dREQ;	802	dREQ;
667		803
668	req->type = EIO_SENDFILE;	804	req->type = EIO_SENDFILE;
669	req->sv1 = newSVsv (out_fh);	805	req->sv1 = newSVsv (out_fh);
670	req->int1 = PerlIO_fileno (IoIFP (sv_2io (out_fh)));	806	req->int1 = ofd;
671	req->sv2 = newSVsv (in_fh);	807	req->sv2 = newSVsv (in_fh);
672	req->int2 = PerlIO_fileno (IoIFP (sv_2io (in_fh)));	808	req->int2 = ifd;
673	req->offs = SvVAL64 (in_offset);	809	req->offs = SvVAL64 (in_offset);
674	req->size = length;	810	req->size = length;
675		811
676	REQ_SEND;	812	REQ_SEND;
677	}	813	}
…		…
679	void	815	void
680	aio_readahead (SV fh, SV offset, IV length, SV *callback=&PL_sv_undef)	816	aio_readahead (SV fh, SV offset, IV length, SV *callback=&PL_sv_undef)
681	PROTOTYPE: $$$;$	817	PROTOTYPE: $$$;$
682	PPCODE:	818	PPCODE:
683	{	819	{
		820	int fd = extract_fd (fh, 0);
684	dREQ;	821	dREQ;
685		822
686	req->type = EIO_READAHEAD;	823	req->type = EIO_READAHEAD;
687	req->sv1 = newSVsv (fh);	824	req->sv1 = newSVsv (fh);
688	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));	825	req->int1 = fd;
689	req->offs = SvVAL64 (offset);	826	req->offs = SvVAL64 (offset);
690	req->size = length;	827	req->size = length;
691		828
692	REQ_SEND;	829	REQ_SEND;
693	}	830	}
…		…
699	aio_lstat = EIO_LSTAT	836	aio_lstat = EIO_LSTAT
700	PPCODE:	837	PPCODE:
701	{	838	{
702	dREQ;	839	dREQ;
703		840
704	req->ptr2 = malloc (sizeof (EIO_STRUCT_STAT));
705	if (!req->ptr2)
706	{
707	req_destroy (req);
708	croak ("out of memory during aio_stat statdata allocation");
709	}
710
711	req->flags \|= EIO_FLAG_PTR2_FREE;
712	req->sv1 = newSVsv (fh_or_path);	841	req->sv1 = newSVsv (fh_or_path);
713		842
714	if (SvPOK (fh_or_path))	843	if (SvPOK (req->sv1))
715	{	844	{
716	req->type = ix;	845	req->type = ix;
717	req->ptr1 = SvPVbyte_nolen (req->sv1);	846	req->ptr1 = SvPVbyte_nolen (req->sv1);
718	}	847	}
719	else	848	else
…		…
733		862
734	req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;	863	req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
735	req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;	864	req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;
736	req->sv1 = newSVsv (fh_or_path);	865	req->sv1 = newSVsv (fh_or_path);
737		866
738	if (SvPOK (fh_or_path))	867	if (SvPOK (req->sv1))
739	{	868	{
740	req->type = EIO_UTIME;	869	req->type = EIO_UTIME;
741	req->ptr1 = SvPVbyte_nolen (req->sv1);	870	req->ptr1 = SvPVbyte_nolen (req->sv1);
742	}	871	}
743	else	872	else
…		…
756	dREQ;	885	dREQ;
757		886
758	req->sv1 = newSVsv (fh_or_path);	887	req->sv1 = newSVsv (fh_or_path);
759	req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;	888	req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
760		889
761	if (SvPOK (fh_or_path))	890	if (SvPOK (req->sv1))
762	{	891	{
763	req->type = EIO_TRUNCATE;	892	req->type = EIO_TRUNCATE;
764	req->ptr1 = SvPVbyte_nolen (req->sv1);	893	req->ptr1 = SvPVbyte_nolen (req->sv1);
765	}	894	}
766	else	895	else
…		…
774		903
775	void	904	void
776	aio_chmod (SV8 fh_or_path, int mode, SV callback=&PL_sv_undef)	905	aio_chmod (SV8 fh_or_path, int mode, SV callback=&PL_sv_undef)
777	ALIAS:	906	ALIAS:
778	aio_chmod = EIO_CHMOD	907	aio_chmod = EIO_CHMOD
779	aio_fchmod = EIO_FCHMOD
780	aio_mkdir = EIO_MKDIR	908	aio_mkdir = EIO_MKDIR
781	PPCODE:	909	PPCODE:
782	{	910	{
783	dREQ;	911	dREQ;
784		912
785	req->type = ix;
786	req->int2 = mode;	913	req->int2 = mode;
787	req->sv1 = newSVsv (fh_or_path);	914	req->sv1 = newSVsv (fh_or_path);
788		915
789	if (ix == EIO_FCHMOD)	916	if (SvPOK (req->sv1))
790	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));	917	{
		918	req->type = ix;
		919	req->ptr1 = SvPVbyte_nolen (req->sv1);
		920	}
791	else	921	else
792	req->ptr1 = SvPVbyte_nolen (req->sv1);	922	{
		923	req->type = EIO_FCHMOD;
		924	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
		925	}
793		926
794	REQ_SEND;	927	REQ_SEND;
795	}	928	}
796		929
797	void	930	void
…		…
802		935
803	req->int2 = SvOK (uid) ? SvIV (uid) : -1;	936	req->int2 = SvOK (uid) ? SvIV (uid) : -1;
804	req->int3 = SvOK (gid) ? SvIV (gid) : -1;	937	req->int3 = SvOK (gid) ? SvIV (gid) : -1;
805	req->sv1 = newSVsv (fh_or_path);	938	req->sv1 = newSVsv (fh_or_path);
806		939
807	if (SvPOK (fh_or_path))	940	if (SvPOK (req->sv1))
808	{	941	{
809	req->type = EIO_CHOWN;	942	req->type = EIO_CHOWN;
810	req->ptr1 = SvPVbyte_nolen (req->sv1);	943	req->ptr1 = SvPVbyte_nolen (req->sv1);
811	}	944	}
812	else	945	else
…		…
814	req->type = EIO_FCHOWN;	947	req->type = EIO_FCHOWN;
815	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));	948	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
816	}	949	}
817		950
818	REQ_SEND;	951	REQ_SEND;
		952	}
		953
		954	void
		955	aio_readdirx (SV8 pathname, IV flags, SV callback=&PL_sv_undef)
		956	PPCODE:
		957	{
		958	dREQ;
		959
		960	req->type = EIO_READDIR;
		961	req->sv1 = newSVsv (pathname);
		962	req->ptr1 = SvPVbyte_nolen (req->sv1);
		963	req->int1 = flags \| EIO_READDIR_DENTS \| EIO_READDIR_CUSTOM1;
		964
		965	if (flags & EIO_READDIR_DENTS)
		966	req->int1 \|= EIO_READDIR_CUSTOM2;
		967
		968	REQ_SEND;
819	}	969	}
820		970
821	void	971	void
822	aio_unlink (SV8 pathname, SV callback=&PL_sv_undef)	972	aio_unlink (SV8 pathname, SV callback=&PL_sv_undef)
823	ALIAS:	973	ALIAS:
…		…
888	{	1038	{
889	dREQ;	1039	dREQ;
890		1040
891	req->type = EIO_GROUP;	1041	req->type = EIO_GROUP;
892		1042
893	eio_submit (req);	1043	req_submit (req);
894	XPUSHs (req_sv (req, AIO_GRP_KLASS));	1044	XPUSHs (req_sv (req, AIO_GRP_KLASS));
895	}	1045	}
896		1046
897	void	1047	void
898	aio_nop (SV *callback=&PL_sv_undef)	1048	aio_nop (SV *callback=&PL_sv_undef)
…		…
910		1060
911	int	1061	int
912	aioreq_pri (int pri = 0)	1062	aioreq_pri (int pri = 0)
913	PROTOTYPE: ;$	1063	PROTOTYPE: ;$
914	CODE:	1064	CODE:
915	RETVAL = next_pri - EIO_PRI_BIAS;	1065	RETVAL = next_pri;
916	if (items > 0)	1066	if (items > 0)
917	{	1067	{
918	if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN;	1068	if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN;
919	if (pri > EIO_PRI_MAX) pri = EIO_PRI_MAX;	1069	if (pri > EIO_PRI_MAX) pri = EIO_PRI_MAX;
920	next_pri = pri + EIO_PRI_BIAS;	1070	next_pri = pri;
921	}	1071	}
922	OUTPUT:	1072	OUTPUT:
923	RETVAL	1073	RETVAL
924		1074
925	void	1075	void
926	aioreq_nice (int nice = 0)	1076	aioreq_nice (int nice = 0)
927	CODE:	1077	CODE:
928	nice = next_pri - nice;	1078	nice = next_pri - nice;
929	if (nice < EIO_PRI_MIN) nice = EIO_PRI_MIN;	1079	if (nice < EIO_PRI_MIN) nice = EIO_PRI_MIN;
930	if (nice > EIO_PRI_MAX) nice = EIO_PRI_MAX;	1080	if (nice > EIO_PRI_MAX) nice = EIO_PRI_MAX;
931	next_pri = nice + EIO_PRI_BIAS;	1081	next_pri = nice;
932		1082
933	void	1083	void
934	flush ()	1084	flush ()
935	PROTOTYPE:	1085	PROTOTYPE:
936	CODE:	1086	CODE:
…		…
997		1147
998	int	1148	int
999	nthreads()	1149	nthreads()
1000	PROTOTYPE:	1150	PROTOTYPE:
1001	CODE:	1151	CODE:
1002	if (WORDACCESS_UNSAFE) X_LOCK (wrklock);	1152	RETVAL = eio_nthreads ();
1003	RETVAL = started;
1004	if (WORDACCESS_UNSAFE) X_UNLOCK (wrklock);
1005	OUTPUT:	1153	OUTPUT:
1006	RETVAL	1154	RETVAL
1007		1155
		1156	void _on_next_submit (SV *cb)
		1157	CODE:
		1158	SvREFCNT_dec (on_next_submit);
		1159	on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;
		1160
1008	PROTOTYPES: DISABLE	1161	PROTOTYPES: DISABLE
1009		1162
1010	MODULE = IO::AIO PACKAGE = IO::AIO::REQ	1163	MODULE = IO::AIO PACKAGE = IO::AIO::REQ
1011		1164
1012	void	1165	void
…		…
1014	CODE:	1167	CODE:
1015	eio_cancel (req);	1168	eio_cancel (req);
1016		1169
1017	void	1170	void
1018	cb (aio_req_ornot req, SV *callback=&PL_sv_undef)	1171	cb (aio_req_ornot req, SV *callback=&PL_sv_undef)
1019	CODE:	1172	PPCODE:
		1173	{
		1174	if (GIMME_V != G_VOID)
		1175	XPUSHs (req->callback ? sv_2mortal (newRV_inc (req->callback)) : &PL_sv_undef);
		1176
		1177	if (items > 1)
		1178	{
		1179	SV *cb_cv = get_cb (callback);
		1180
1020	SvREFCNT_dec (req->callback);	1181	SvREFCNT_dec (req->callback);
1021	req->callback = newSVsv (callback);	1182	req->callback = SvREFCNT_inc (cb_cv);
		1183	}
		1184	}
1022		1185
1023	MODULE = IO::AIO PACKAGE = IO::AIO::GRP	1186	MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1024		1187
1025	void	1188	void
1026	add (aio_req grp, ...)	1189	add (aio_req grp, ...)
…		…
1058	AV *av;	1221	AV *av;
1059		1222
1060	grp->errorno = errno;	1223	grp->errorno = errno;
1061		1224
1062	av = newAV ();	1225	av = newAV ();
		1226	av_extend (av, items - 1);
1063		1227
1064	for (i = 1; i < items; ++i )	1228	for (i = 1; i < items; ++i )
1065	av_push (av, newSVsv (ST (i)));	1229	av_push (av, newSVsv (ST (i)));
1066		1230
1067	SvREFCNT_dec (grp->sv1);	1231	SvREFCNT_dec (grp->sv1);
…		…
1081	void	1245	void
1082	feed (aio_req grp, SV *callback=&PL_sv_undef)	1246	feed (aio_req grp, SV *callback=&PL_sv_undef)
1083	CODE:	1247	CODE:
1084	{	1248	{
1085	SvREFCNT_dec (grp->sv2);	1249	SvREFCNT_dec (grp->sv2);
1086	grp->sv2 = newSVsv (callback);	1250	grp->sv2 = newSVsv (callback);
		1251	grp->feed = aio_grp_feed;
1087		1252
1088	if (grp->int2 <= 0)	1253	if (grp->int2 <= 0)
1089	grp->int2 = 2;	1254	grp->int2 = 2;
1090		1255
1091	eio_grp_limit (grp, grp->int2);	1256	eio_grp_limit (grp, grp->int2);

Diff Legend

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

Comparing IO-AIO/AIO.xs (file contents): Revision 1.116 by root, Sat May 10 19:25:33 2008 UTC vs. Revision 1.147 by root, Mon Jun 15 05:34:49 2009 UTC

Diff Legend

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.116 by root, Sat May 10 19:25:33 2008 UTC vs.
Revision 1.147 by root, Mon Jun 15 05:34:49 2009 UTC