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

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.115 by root, Sat May 10 18:06:41 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
106	static unsigned int max_outstanding = 0x7fffffff;	128	static SV *on_next_submit;
107		129	static int next_pri = EIO_PRI_DEFAULT;
108	static int next_pri = EIO_DEFAULT_PRI + EIO_PRI_BIAS;	130	static int max_outstanding;
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	{
		483	for (;;)
		484	{
410	int res = eio_poll ();	485	int res = eio_poll ();
411		486
412	if (res > 0)	487	if (res > 0)
413	croak (0);	488	croak (0);
414		489
		490	if (!max_outstanding \|\| max_outstanding > eio_nreqs ())
415	return res;	491	return res;
		492
		493	poll_wait ();
		494	}
		495	}
		496
		497	static void atfork_child (void)
		498	{
		499	create_respipe ();
		500	}
		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;
416	}	518	}
417		519
418	#define dREQ \	520	#define dREQ \
		521	SV *cb_cv; \
419	aio_req req; \	522	aio_req req; \
420	int req_pri = next_pri; \	523	int req_pri = next_pri; \
421	next_pri = EIO_DEFAULT_PRI + EIO_PRI_BIAS; \	524	next_pri = EIO_PRI_DEFAULT; \
422	\	525	\
423	if (SvOK (callback) && !SvROK (callback)) \	526	cb_cv = get_cb (callback); \
424	croak ("callback must be undef or of reference type"); \
425	\	527	\
426	Newz (0, req, 1, eio_req); \	528	Newz (0, req, 1, eio_req); \
427	if (!req) \	529	if (!req) \
428	croak ("out of memory during eio_req allocation"); \	530	croak ("out of memory during eio_req allocation"); \
429	\	531	\
430	req->callback = newSVsv (callback); \	532	req->callback = SvREFCNT_inc (cb_cv); \
431	req->pri = req_pri	533	req->pri = req_pri
432		534
433	#define REQ_SEND \	535	#define REQ_SEND \
		536	PUTBACK; \
434	eio_submit (req); \	537	req_submit (req); \
		538	SPAGAIN; \
435	\	539	\
436	if (GIMME_V != G_VOID) \	540	if (GIMME_V != G_VOID) \
437	XPUSHs (req_sv (req, AIO_REQ_KLASS));	541	XPUSHs (req_sv (req, AIO_REQ_KLASS));
438		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
439	MODULE = IO::AIO PACKAGE = IO::AIO	554	MODULE = IO::AIO PACKAGE = IO::AIO
440		555
441	PROTOTYPES: ENABLE	556	PROTOTYPES: ENABLE
442		557
443	BOOT:	558	BOOT:
444	{	559	{
445	stash = gv_stashpv ("IO::AIO", 1);	560	static const struct {
446		561	const char *name;
447	newCONSTSUB (stash, "EXDEV", newSViv (EXDEV));	562	IV iv;
448	newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY));	563	} *civ, const_iv[] = {
449	newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY));	564	# define const_iv(name, value) { # name, (IV) value },
450	newCONSTSUB (stash, "O_CREAT", newSViv (O_CREAT));	565	# define const_eio(name) { # name, (IV) EIO_ ## name },
451	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)
452	#ifdef _WIN32	572	#ifndef _WIN32
453	X_MUTEX_CHECK (wrklock);	573	const_iv (S_IFIFO , S_IFIFO)
454	X_MUTEX_CHECK (reslock);
455	X_MUTEX_CHECK (reqlock);
456	X_MUTEX_CHECK (reqwait);
457	X_MUTEX_CHECK (preadwritelock);
458	X_MUTEX_CHECK (readdirlock);
459
460	X_COND_CHECK (reqwait);
461	#else
462	newCONSTSUB (stash, "S_IFIFO", newSViv (S_IFIFO));
463	#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)
464		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
465	create_respipe ();	600	create_respipe ();
466		601
467	if (eio_init (want_poll, done_poll) < 0)	602	if (eio_init (want_poll, done_poll) < 0)
468	croak ("IO::AIO: unable to initialise eio library");	603	croak ("IO::AIO: unable to initialise eio library");
		604
		605	/* atfork child called in fifo order, so before eio's handler */
		606	X_THREAD_ATFORK (0, 0, atfork_child);
469	}	607	}
470		608
471	void	609	void
472	max_poll_reqs (int nreqs)	610	max_poll_reqs (int nreqs)
473	PROTOTYPE: $	611	PROTOTYPE: $
…		…
526	ALIAS:	664	ALIAS:
527	aio_fsync = EIO_FSYNC	665	aio_fsync = EIO_FSYNC
528	aio_fdatasync = EIO_FDATASYNC	666	aio_fdatasync = EIO_FDATASYNC
529	PPCODE:	667	PPCODE:
530	{	668	{
		669	int fd = extract_fd (fh, 0);
531	dREQ;	670	dREQ;
532		671
533	req->type = ix;	672	req->type = ix;
534	req->sv1 = newSVsv (fh);	673	req->sv1 = newSVsv (fh);
535	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;
536		693
537	REQ_SEND (req);	694	REQ_SEND (req);
538	}	695	}
539		696
540	void	697	void
541	aio_close (SV fh, SV callback=&PL_sv_undef)	698	aio_close (SV fh, SV callback=&PL_sv_undef)
542	PROTOTYPE: $;$	699	PROTOTYPE: $;$
543	PPCODE:	700	PPCODE:
544	{	701	{
545	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);
546	dREQ;	704	dREQ;
547		705
548	if (close_pipe < 0)	706	if (close_pipe < 0)
549	{	707	{
550	int pipefd [2];	708	int pipefd [2];
…		…
558	}	716	}
559		717
560	req->type = EIO_DUP2;	718	req->type = EIO_DUP2;
561	req->int1 = close_pipe;	719	req->int1 = close_pipe;
562	req->sv2 = newSVsv (fh);	720	req->sv2 = newSVsv (fh);
563	req->int2 = PerlIO_fileno (IoIFP (sv_2io (fh)));	721	req->int2 = fd;
564		722
565	REQ_SEND (req);	723	REQ_SEND (req);
566	}	724	}
567		725
568	void	726	void
…		…
572	aio_write = EIO_WRITE	730	aio_write = EIO_WRITE
573	PROTOTYPE: $$$$$;$	731	PROTOTYPE: $$$$$;$
574	PPCODE:	732	PPCODE:
575	{	733	{
576	STRLEN svlen;	734	STRLEN svlen;
		735	int fd = extract_fd (fh, ix == EIO_WRITE);
577	char *svptr = SvPVbyte (data, svlen);	736	char *svptr = SvPVbyte (data, svlen);
578	UV len = SvUV (length);	737	UV len = SvUV (length);
579
580	SvUPGRADE (data, SVt_PV);
581	SvPOK_on (data);
582		738
583	if (dataoffset < 0)	739	if (dataoffset < 0)
584	dataoffset += svlen;	740	dataoffset += svlen;
585		741
586	if (dataoffset < 0 \|\| dataoffset > svlen)	742	if (dataoffset < 0 \|\| dataoffset > svlen)
…		…
592	if (!SvOK (length) \|\| len + dataoffset > svlen)	748	if (!SvOK (length) \|\| len + dataoffset > svlen)
593	len = svlen - dataoffset;	749	len = svlen - dataoffset;
594	}	750	}
595	else	751	else
596	{	752	{
597	/* read: grow scalar as necessary */	753	/* read: check type and grow scalar as necessary */
		754	SvUPGRADE (data, SVt_PV);
598	svptr = SvGROW (data, len + dataoffset + 1);	755	svptr = SvGROW (data, len + dataoffset + 1);
599	}	756	}
600
601	if (len < 0)
602	croak ("length must not be negative");
603		757
604	{	758	{
605	dREQ;	759	dREQ;
606		760
607	req->type = ix;	761	req->type = ix;
608	req->sv1 = newSVsv (fh);	762	req->sv1 = newSVsv (fh);
609	req->int1 = PerlIO_fileno (ix == EIO_READ ? IoIFP (sv_2io (fh))	763	req->int1 = fd;
610	: IoOFP (sv_2io (fh)));
611	req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;	764	req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
612	req->size = len;	765	req->size = len;
613	req->sv2 = SvREFCNT_inc (data);	766	req->sv2 = SvREFCNT_inc (data);
614	req->ptr2 = (char *)svptr + dataoffset;	767	req->ptr2 = (char *)svptr + dataoffset;
615	req->stroffset = dataoffset;	768	req->stroffset = dataoffset;
…		…
630	PPCODE:	783	PPCODE:
631	{	784	{
632	SV *data;	785	SV *data;
633	dREQ;	786	dREQ;
634		787
635	data = newSV (NAME_MAX);
636	SvPOK_on (data);
637
638	req->type = EIO_READLINK;	788	req->type = EIO_READLINK;
639	req->sv1 = newSVsv (path);	789	req->sv1 = newSVsv (path);
640	req->ptr1 = SvPVbyte_nolen (req->sv1);	790	req->ptr1 = SvPVbyte_nolen (req->sv1);
641	req->sv2 = data;
642	req->ptr2 = SvPVbyte_nolen (data);
643		791
644	REQ_SEND;	792	REQ_SEND;
645	}	793	}
646		794
647	void	795	void
648	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)
649	PROTOTYPE: $$$$;$	797	PROTOTYPE: $$$$;$
650	PPCODE:	798	PPCODE:
651	{	799	{
		800	int ifd = extract_fd (in_fh , 0);
		801	int ofd = extract_fd (out_fh, 0);
652	dREQ;	802	dREQ;
653		803
654	req->type = EIO_SENDFILE;	804	req->type = EIO_SENDFILE;
655	req->sv1 = newSVsv (out_fh);	805	req->sv1 = newSVsv (out_fh);
656	req->int1 = PerlIO_fileno (IoIFP (sv_2io (out_fh)));	806	req->int1 = ofd;
657	req->sv2 = newSVsv (in_fh);	807	req->sv2 = newSVsv (in_fh);
658	req->int2 = PerlIO_fileno (IoIFP (sv_2io (in_fh)));	808	req->int2 = ifd;
659	req->offs = SvVAL64 (in_offset);	809	req->offs = SvVAL64 (in_offset);
660	req->size = length;	810	req->size = length;
661		811
662	REQ_SEND;	812	REQ_SEND;
663	}	813	}
…		…
665	void	815	void
666	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)
667	PROTOTYPE: $$$;$	817	PROTOTYPE: $$$;$
668	PPCODE:	818	PPCODE:
669	{	819	{
		820	int fd = extract_fd (fh, 0);
670	dREQ;	821	dREQ;
671		822
672	req->type = EIO_READAHEAD;	823	req->type = EIO_READAHEAD;
673	req->sv1 = newSVsv (fh);	824	req->sv1 = newSVsv (fh);
674	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh)));	825	req->int1 = fd;
675	req->offs = SvVAL64 (offset);	826	req->offs = SvVAL64 (offset);
676	req->size = length;	827	req->size = length;
677		828
678	REQ_SEND;	829	REQ_SEND;
679	}	830	}
…		…
685	aio_lstat = EIO_LSTAT	836	aio_lstat = EIO_LSTAT
686	PPCODE:	837	PPCODE:
687	{	838	{
688	dREQ;	839	dREQ;
689		840
690	req->ptr2 = malloc (sizeof (EIO_STRUCT_STAT));
691	if (!req->ptr2)
692	{
693	req_destroy (req);
694	croak ("out of memory during aio_stat statdata allocation");
695	}
696
697	req->flags \|= EIO_FLAG_PTR2_FREE;
698	req->sv1 = newSVsv (fh_or_path);	841	req->sv1 = newSVsv (fh_or_path);
699		842
700	if (SvPOK (fh_or_path))	843	if (SvPOK (req->sv1))
701	{	844	{
702	req->type = ix;	845	req->type = ix;
703	req->ptr1 = SvPVbyte_nolen (req->sv1);	846	req->ptr1 = SvPVbyte_nolen (req->sv1);
704	}	847	}
705	else	848	else
…		…
719		862
720	req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;	863	req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
721	req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;	864	req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;
722	req->sv1 = newSVsv (fh_or_path);	865	req->sv1 = newSVsv (fh_or_path);
723		866
724	if (SvPOK (fh_or_path))	867	if (SvPOK (req->sv1))
725	{	868	{
726	req->type = EIO_UTIME;	869	req->type = EIO_UTIME;
727	req->ptr1 = SvPVbyte_nolen (req->sv1);	870	req->ptr1 = SvPVbyte_nolen (req->sv1);
728	}	871	}
729	else	872	else
…		…
742	dREQ;	885	dREQ;
743		886
744	req->sv1 = newSVsv (fh_or_path);	887	req->sv1 = newSVsv (fh_or_path);
745	req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;	888	req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
746		889
747	if (SvPOK (fh_or_path))	890	if (SvPOK (req->sv1))
748	{	891	{
749	req->type = EIO_TRUNCATE;	892	req->type = EIO_TRUNCATE;
750	req->ptr1 = SvPVbyte_nolen (req->sv1);	893	req->ptr1 = SvPVbyte_nolen (req->sv1);
751	}	894	}
752	else	895	else
…		…
760		903
761	void	904	void
762	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)
763	ALIAS:	906	ALIAS:
764	aio_chmod = EIO_CHMOD	907	aio_chmod = EIO_CHMOD
765	aio_fchmod = EIO_FCHMOD
766	aio_mkdir = EIO_MKDIR	908	aio_mkdir = EIO_MKDIR
767	PPCODE:	909	PPCODE:
768	{	910	{
769	dREQ;	911	dREQ;
770		912
771	req->type = ix;
772	req->int2 = mode;	913	req->int2 = mode;
773	req->sv1 = newSVsv (fh_or_path);	914	req->sv1 = newSVsv (fh_or_path);
774		915
775	if (ix == EIO_FCHMOD)	916	if (SvPOK (req->sv1))
776	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));	917	{
		918	req->type = ix;
		919	req->ptr1 = SvPVbyte_nolen (req->sv1);
		920	}
777	else	921	else
778	req->ptr1 = SvPVbyte_nolen (req->sv1);	922	{
		923	req->type = EIO_FCHMOD;
		924	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
		925	}
779		926
780	REQ_SEND;	927	REQ_SEND;
781	}	928	}
782		929
783	void	930	void
…		…
788		935
789	req->int2 = SvOK (uid) ? SvIV (uid) : -1;	936	req->int2 = SvOK (uid) ? SvIV (uid) : -1;
790	req->int3 = SvOK (gid) ? SvIV (gid) : -1;	937	req->int3 = SvOK (gid) ? SvIV (gid) : -1;
791	req->sv1 = newSVsv (fh_or_path);	938	req->sv1 = newSVsv (fh_or_path);
792		939
793	if (SvPOK (fh_or_path))	940	if (SvPOK (req->sv1))
794	{	941	{
795	req->type = EIO_CHOWN;	942	req->type = EIO_CHOWN;
796	req->ptr1 = SvPVbyte_nolen (req->sv1);	943	req->ptr1 = SvPVbyte_nolen (req->sv1);
797	}	944	}
798	else	945	else
…		…
800	req->type = EIO_FCHOWN;	947	req->type = EIO_FCHOWN;
801	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));	948	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
802	}	949	}
803		950
804	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;
805	}	969	}
806		970
807	void	971	void
808	aio_unlink (SV8 pathname, SV callback=&PL_sv_undef)	972	aio_unlink (SV8 pathname, SV callback=&PL_sv_undef)
809	ALIAS:	973	ALIAS:
…		…
874	{	1038	{
875	dREQ;	1039	dREQ;
876		1040
877	req->type = EIO_GROUP;	1041	req->type = EIO_GROUP;
878		1042
879	eio_submit (req);	1043	req_submit (req);
880	XPUSHs (req_sv (req, AIO_GRP_KLASS));	1044	XPUSHs (req_sv (req, AIO_GRP_KLASS));
881	}	1045	}
882		1046
883	void	1047	void
884	aio_nop (SV *callback=&PL_sv_undef)	1048	aio_nop (SV *callback=&PL_sv_undef)
…		…
896		1060
897	int	1061	int
898	aioreq_pri (int pri = 0)	1062	aioreq_pri (int pri = 0)
899	PROTOTYPE: ;$	1063	PROTOTYPE: ;$
900	CODE:	1064	CODE:
901	RETVAL = next_pri - EIO_PRI_BIAS;	1065	RETVAL = next_pri;
902	if (items > 0)	1066	if (items > 0)
903	{	1067	{
904	if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN;	1068	if (pri < EIO_PRI_MIN) pri = EIO_PRI_MIN;
905	if (pri > EIO_PRI_MAX) pri = EIO_PRI_MAX;	1069	if (pri > EIO_PRI_MAX) pri = EIO_PRI_MAX;
906	next_pri = pri + EIO_PRI_BIAS;	1070	next_pri = pri;
907	}	1071	}
908	OUTPUT:	1072	OUTPUT:
909	RETVAL	1073	RETVAL
910		1074
911	void	1075	void
912	aioreq_nice (int nice = 0)	1076	aioreq_nice (int nice = 0)
913	CODE:	1077	CODE:
914	nice = next_pri - nice;	1078	nice = next_pri - nice;
915	if (nice < EIO_PRI_MIN) nice = EIO_PRI_MIN;	1079	if (nice < EIO_PRI_MIN) nice = EIO_PRI_MIN;
916	if (nice > EIO_PRI_MAX) nice = EIO_PRI_MAX;	1080	if (nice > EIO_PRI_MAX) nice = EIO_PRI_MAX;
917	next_pri = nice + EIO_PRI_BIAS;	1081	next_pri = nice;
918		1082
919	void	1083	void
920	flush ()	1084	flush ()
921	PROTOTYPE:	1085	PROTOTYPE:
922	CODE:	1086	CODE:
923	while (nreqs)	1087	while (eio_nreqs ())
924	{	1088	{
925	poll_wait ();	1089	poll_wait ();
926	poll_cb ();	1090	poll_cb ();
927	}	1091	}
928		1092
…		…
983		1147
984	int	1148	int
985	nthreads()	1149	nthreads()
986	PROTOTYPE:	1150	PROTOTYPE:
987	CODE:	1151	CODE:
988	if (WORDACCESS_UNSAFE) X_LOCK (wrklock);	1152	RETVAL = eio_nthreads ();
989	RETVAL = started;
990	if (WORDACCESS_UNSAFE) X_UNLOCK (wrklock);
991	OUTPUT:	1153	OUTPUT:
992	RETVAL	1154	RETVAL
993		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
994	PROTOTYPES: DISABLE	1161	PROTOTYPES: DISABLE
995		1162
996	MODULE = IO::AIO PACKAGE = IO::AIO::REQ	1163	MODULE = IO::AIO PACKAGE = IO::AIO::REQ
997		1164
998	void	1165	void
…		…
1000	CODE:	1167	CODE:
1001	eio_cancel (req);	1168	eio_cancel (req);
1002		1169
1003	void	1170	void
1004	cb (aio_req_ornot req, SV *callback=&PL_sv_undef)	1171	cb (aio_req_ornot req, SV *callback=&PL_sv_undef)
1005	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
1006	SvREFCNT_dec (req->callback);	1181	SvREFCNT_dec (req->callback);
1007	req->callback = newSVsv (callback);	1182	req->callback = SvREFCNT_inc (cb_cv);
		1183	}
		1184	}
1008		1185
1009	MODULE = IO::AIO PACKAGE = IO::AIO::GRP	1186	MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1010		1187
1011	void	1188	void
1012	add (aio_req grp, ...)	1189	add (aio_req grp, ...)
…		…
1044	AV *av;	1221	AV *av;
1045		1222
1046	grp->errorno = errno;	1223	grp->errorno = errno;
1047		1224
1048	av = newAV ();	1225	av = newAV ();
		1226	av_extend (av, items - 1);
1049		1227
1050	for (i = 1; i < items; ++i )	1228	for (i = 1; i < items; ++i )
1051	av_push (av, newSVsv (ST (i)));	1229	av_push (av, newSVsv (ST (i)));
1052		1230
1053	SvREFCNT_dec (grp->sv1);	1231	SvREFCNT_dec (grp->sv1);
…		…
1067	void	1245	void
1068	feed (aio_req grp, SV *callback=&PL_sv_undef)	1246	feed (aio_req grp, SV *callback=&PL_sv_undef)
1069	CODE:	1247	CODE:
1070	{	1248	{
1071	SvREFCNT_dec (grp->sv2);	1249	SvREFCNT_dec (grp->sv2);
1072	grp->sv2 = newSVsv (callback);	1250	grp->sv2 = newSVsv (callback);
		1251	grp->feed = aio_grp_feed;
1073		1252
1074	if (grp->int2 <= 0)	1253	if (grp->int2 <= 0)
1075	grp->int2 = 2;	1254	grp->int2 = 2;
1076		1255
1077	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.115 by root, Sat May 10 18:06:41 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.115 by root, Sat May 10 18:06:41 2008 UTC vs.
Revision 1.147 by root, Mon Jun 15 05:34:49 2009 UTC