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

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.190 by root, Mon Jul 18 02:02:26 2011 UTC vs.
Revision 1.207 by root, Fri Dec 30 07:40:54 2011 UTC

…		…
102		102
103	typedef SV SV8; /* byte-sv, used for argument-checking */	103	typedef SV SV8; /* byte-sv, used for argument-checking */
104	typedef int aio_rfd; /* read file desriptor */	104	typedef int aio_rfd; /* read file desriptor */
105	typedef int aio_wfd; /* write file descriptor */	105	typedef int aio_wfd; /* write file descriptor */
106		106
107	static HV aio_stash, aio_req_stash, *aio_grp_stash;	107	static HV aio_stash, aio_req_stash, aio_grp_stash, aio_wd_stash;
108		108
109	#define EIO_REQ_MEMBERS \	109	#define EIO_REQ_MEMBERS \
110	SV *callback; \	110	SV *callback; \
111	SV sv1, sv2; \	111	SV sv1, sv2; \
		112	SV sv3, sv4; \
112	STRLEN stroffset; \	113	STRLEN stroffset; \
113	SV *self;	114	SV *self;
114		115
115	#define EIO_NO_WRAPPERS 1	116	#define EIO_NO_WRAPPERS 1
116		117
…		…
329	FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */	330	FLAG_SV2_RO_OFF = 0x40, /* data was set readonly */
330	};	331	};
331		332
332	typedef eio_req *aio_req;	333	typedef eio_req *aio_req;
333	typedef eio_req *aio_req_ornot;	334	typedef eio_req *aio_req_ornot;
		335	typedef eio_wd aio_wd;
334		336
335	static SV *on_next_submit;	337	static SV *on_next_submit;
336	static int next_pri = EIO_PRI_DEFAULT;	338	static int next_pri = EIO_PRI_DEFAULT;
337	static int max_outstanding;	339	static int max_outstanding;
338		340
339	static s_epipe respipe;	341	static s_epipe respipe;
340		342
341	static void req_destroy (aio_req req);	343	static void req_destroy (aio_req req);
342	static void req_cancel (aio_req req);	344	static void req_cancel (aio_req req);
343		345
344	static void want_poll (void)	346	static void
		347	want_poll (void)
345	{	348	{
346	/* write a dummy byte to the pipe so fh becomes ready */	349	/* write a dummy byte to the pipe so fh becomes ready */
347	s_epipe_signal (&respipe);	350	s_epipe_signal (&respipe);
348	}	351	}
349		352
350	static void done_poll (void)	353	static void
		354	done_poll (void)
351	{	355	{
352	/* read any signals sent by the worker threads */	356	/* read any signals sent by the worker threads */
353	s_epipe_drain (&respipe);	357	s_epipe_drain (&respipe);
354	}	358	}
355		359
356	/* must be called at most once */	360	/* must be called at most once */
		361	static SV *
357	static SV req_sv (aio_req req, HV stash)	362	req_sv (aio_req req, HV *stash)
358	{	363	{
359	if (!req->self)	364	if (!req->self)
360	{	365	{
361	req->self = (SV *)newHV ();	366	req->self = (SV *)newHV ();
362	sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);	367	sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
363	}	368	}
364		369
365	return sv_2mortal (sv_bless (newRV_inc (req->self), stash));	370	return sv_2mortal (sv_bless (newRV_inc (req->self), stash));
366	}	371	}
367		372
368	static aio_req SvAIO_REQ (SV *sv)	373	static SV *
		374	newSVaio_wd (aio_wd wd)
		375	{
		376	return sv_bless (newRV_noinc (newSViv ((IV)wd)), aio_wd_stash);
		377	}
		378
		379	static aio_req
		380	SvAIO_REQ (SV *sv)
369	{	381	{
370	MAGIC *mg;	382	MAGIC *mg;
371		383
372	if (!SvROK (sv)	384	if (!SvROK (sv)
		385	/* for speed reasons, we do not verify that SvROK actually has a stash ptr */
373	\|\| (SvSTASH (SvRV (sv)) != aio_grp_stash	386	\|\| (SvSTASH (SvRV (sv)) != aio_grp_stash
374	&& SvSTASH (SvRV (sv)) != aio_req_stash	387	&& SvSTASH (SvRV (sv)) != aio_req_stash
375	&& !sv_derived_from (sv, "IO::AIO::REQ")))	388	&& !sv_derived_from (sv, "IO::AIO::REQ")))
376	croak ("object of class IO::AIO::REQ expected");	389	croak ("object of class IO::AIO::REQ expected");
377		390
378	mg = mg_find (SvRV (sv), PERL_MAGIC_ext);	391	mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
379		392
380	return mg ? (aio_req)mg->mg_ptr : 0;	393	return mg ? (aio_req)mg->mg_ptr : 0;
381	}	394	}
382		395
		396	static aio_wd
		397	SvAIO_WD (SV *sv)
		398	{
		399	if (!SvROK (sv)
		400	\|\| SvTYPE (SvRV (sv)) != SVt_PVMG
		401	\|\| SvSTASH (SvRV (sv)) != aio_wd_stash)
		402	croak ("IO::AIO: expected a working directory object as returned by aio_wd");
		403
		404	return (aio_wd)(long)SvIVX (SvRV (sv));
		405	}
		406
		407	static void
383	static void aio_grp_feed (aio_req grp)	408	aio_grp_feed (aio_req grp)
384	{	409	{
385	if (grp->sv2 && SvOK (grp->sv2))	410	if (grp->sv2 && SvOK (grp->sv2))
386	{	411	{
387	dSP;	412	dSP;
388		413
…		…
396	FREETMPS;	421	FREETMPS;
397	LEAVE;	422	LEAVE;
398	}	423	}
399	}	424	}
400		425
		426	static void
401	static void req_submit (eio_req *req)	427	req_submit (eio_req *req)
402	{	428	{
403	eio_submit (req);	429	eio_submit (req);
404		430
405	if (expect_false (on_next_submit))	431	if (expect_false (on_next_submit))
406	{	432	{
…		…
413	PUTBACK;	439	PUTBACK;
414	call_sv (cb, G_DISCARD \| G_EVAL);	440	call_sv (cb, G_DISCARD \| G_EVAL);
415	}	441	}
416	}	442	}
417		443
		444	static int
418	static int req_invoke (eio_req *req)	445	req_invoke (eio_req *req)
419	{	446	{
420	if (req->flags & FLAG_SV2_RO_OFF)	447	if (req->flags & FLAG_SV2_RO_OFF)
421	SvREADONLY_off (req->sv2);	448	SvREADONLY_off (req->sv2);
422		449
423	if (!EIO_CANCELLED (req) && req->callback)	450	if (!EIO_CANCELLED (req) && req->callback)
…		…
444	SvREADONLY_on (sv_result);	471	SvREADONLY_on (sv_result);
445	}	472	}
446		473
447	switch (req->type)	474	switch (req->type)
448	{	475	{
		476	case EIO_WD_OPEN:
		477	PUSHs (req->result ? &PL_sv_undef : sv_2mortal (newSVaio_wd (req->wd)));
		478	break;
		479
449	case EIO_READDIR:	480	case EIO_READDIR:
450	{	481	{
451	SV *rv = &PL_sv_undef;	482	SV *rv = &PL_sv_undef;
452		483
453	if (req->result >= 0)	484	if (req->result >= 0)
…		…
595	break;	626	break;
596		627
597	case EIO_STAT:	628	case EIO_STAT:
598	case EIO_LSTAT:	629	case EIO_LSTAT:
599	case EIO_FSTAT:	630	case EIO_FSTAT:
600	PL_laststype = req->type == EIO_LSTAT ? OP_LSTAT : OP_STAT;	631	PL_laststype = req->type == EIO_LSTAT ? OP_LSTAT : OP_STAT;
		632
601	PL_laststatval = req->result;	633	if (!(PL_laststatval = req->result))
602	/* if compilation fails here then perl's Stat_t is not struct _stati64 */	634	/* if compilation fails here then perl's Stat_t is not struct _stati64 */
603	PL_statcache = (EIO_STRUCT_STAT )(req->ptr2);	635	PL_statcache = (EIO_STRUCT_STAT )(req->ptr2);
		636
604	PUSHs (sv_result);	637	PUSHs (sv_result);
605	break;	638	break;
606		639
607	case EIO_READ:	640	case EIO_READ:
608	{	641	{
…		…
642	}	675	}
643		676
644	return !!SvTRUE (ERRSV);	677	return !!SvTRUE (ERRSV);
645	}	678	}
646		679
		680	static void
647	static void req_destroy (aio_req req)	681	req_destroy (aio_req req)
648	{	682	{
649	if (req->self)	683	if (req->self)
650	{	684	{
651	sv_unmagic (req->self, PERL_MAGIC_ext);	685	sv_unmagic (req->self, PERL_MAGIC_ext);
652	SvREFCNT_dec (req->self);	686	SvREFCNT_dec (req->self);
653	}	687	}
654		688
655	SvREFCNT_dec (req->sv1);	689	SvREFCNT_dec (req->sv1);
656	SvREFCNT_dec (req->sv2);	690	SvREFCNT_dec (req->sv2);
		691	SvREFCNT_dec (req->sv3);
		692	SvREFCNT_dec (req->sv4);
657	SvREFCNT_dec (req->callback);	693	SvREFCNT_dec (req->callback);
658		694
659	Safefree (req);	695	free (req);
660	}	696	}
661		697
		698	static void
662	static void req_cancel_subs (aio_req grp)	699	req_cancel_subs (aio_req grp)
663	{	700	{
664	if (grp->type != EIO_GROUP)	701	if (grp->type != EIO_GROUP)
665	return;	702	return;
666		703
667	SvREFCNT_dec (grp->sv2);	704	SvREFCNT_dec (grp->sv2);
668	grp->sv2 = 0;	705	grp->sv2 = 0;
669		706
670	eio_grp_cancel (grp);	707	eio_grp_cancel (grp);
671	}	708	}
672		709
		710	static void ecb_cold
673	static void create_respipe (void)	711	create_respipe (void)
674	{	712	{
675	if (s_epipe_renew (&respipe))	713	if (s_epipe_renew (&respipe))
676	croak ("IO::AIO: unable to initialize result pipe");	714	croak ("IO::AIO: unable to initialize result pipe");
677	}	715	}
678		716
679	static void poll_wait (void)	717	static void
		718	poll_wait (void)
680	{	719	{
681	while (eio_nreqs ())	720	while (eio_nreqs ())
682	{	721	{
683	int size;	722	int size;
684		723
…		…
693		732
694	s_epipe_wait (&respipe);	733	s_epipe_wait (&respipe);
695	}	734	}
696	}	735	}
697		736
698	static int poll_cb (void)	737	static int
		738	poll_cb (void)
699	{	739	{
700	for (;;)	740	for (;;)
701	{	741	{
702	int res = eio_poll ();	742	int res = eio_poll ();
703		743
…		…
736	# define MAP_FIXED 0	776	# define MAP_FIXED 0
737	#endif	777	#endif
738		778
739	#define MMAP_MAGIC PERL_MAGIC_ext	779	#define MMAP_MAGIC PERL_MAGIC_ext
740		780
		781	static int ecb_cold
741	static int mmap_free (pTHX_ SV sv, MAGIC mg)	782	mmap_free (pTHX_ SV sv, MAGIC mg)
742	{	783	{
743	int old_errno = errno;	784	int old_errno = errno;
744	munmap (mg->mg_ptr, (size_t)mg->mg_obj);	785	munmap (mg->mg_ptr, (size_t)mg->mg_obj);
745	errno = old_errno;	786	errno = old_errno;
746		787
…		…
762	0, 0, 0, 0, mmap_free	803	0, 0, 0, 0, mmap_free
763	};	804	};
764		805
765	/*****************************************************************************/	806	/*****************************************************************************/
766		807
		808	static SV *
767	static SV * get_cb (SV *cb_sv)	809	get_cb (SV *cb_sv)
768	{	810	{
769	SvGETMAGIC (cb_sv);	811	SvGETMAGIC (cb_sv);
770	return SvOK (cb_sv) ? s_get_cv_croak (cb_sv) : 0;	812	return SvOK (cb_sv) ? s_get_cv_croak (cb_sv) : 0;
771	}	813	}
772		814
		815	static aio_req ecb_noinline
		816	dreq (SV *callback)
		817	{
		818	SV *cb_cv;
		819	aio_req req;
		820	int req_pri = next_pri;
		821	next_pri = EIO_PRI_DEFAULT;
		822
		823	cb_cv = get_cb (callback);
		824
		825	req = calloc (sizeof (*req), 1);
		826	if (!req)
		827	croak ("out of memory during eio_req allocation");
		828
		829	req->callback = SvREFCNT_inc (cb_cv);
		830	req->pri = req_pri;
		831
		832	return req;
		833	}
		834
773	#define dREQ \	835	#define dREQ \
774	SV *cb_cv; \	836	aio_req req = dreq (callback); \
775	aio_req req; \
776	int req_pri = next_pri; \
777	next_pri = EIO_PRI_DEFAULT; \
778	\
779	cb_cv = get_cb (callback); \
780	\
781	Newz (0, req, 1, eio_req); \
782	if (!req) \
783	croak ("out of memory during eio_req allocation"); \
784	\
785	req->callback = SvREFCNT_inc (cb_cv); \
786	req->pri = req_pri
787		837
788	#define REQ_SEND \	838	#define REQ_SEND \
789	PUTBACK; \	839	PUTBACK; \
790	req_submit (req); \	840	req_submit (req); \
791	SPAGAIN; \	841	SPAGAIN; \
792	\	842	\
793	if (GIMME_V != G_VOID) \	843	if (GIMME_V != G_VOID) \
794	XPUSHs (req_sv (req, aio_req_stash));	844	XPUSHs (req_sv (req, aio_req_stash));
		845
		846	ecb_inline void
		847	req_set_path (aio_req req, SV path, SV wdsv, SV pathsv, eio_wd wd, void **ptr)
		848	{
		849	if (expect_false (SvROK (path)))
		850	{
		851	SV *rv = SvRV (path);
		852	SV *wdob;
		853
		854	if (SvTYPE (rv) == SVt_PVAV && AvFILLp (rv) == 1)
		855	{
		856	path = AvARRAY (rv)[1];
		857	wdob = AvARRAY (rv)[0];
		858
		859	if (SvOK (wdob))
		860	{
		861	*wd = SvAIO_WD (wdob);
		862	*wdsv = SvREFCNT_inc_NN (SvRV (wdob));
		863	}
		864	else
		865	*wd = EIO_INVALID_WD;
		866	}
		867	else if (SvTYPE (rv) == SVt_PVMG && SvSTASH (rv) == aio_wd_stash)
		868	{
		869	*wd = (aio_wd)(long)SvIVX (rv);
		870	*wdsv = SvREFCNT_inc_NN (rv);
		871	*ptr = ".";
		872	return; /* path set to "." */
		873	}
		874	else
		875	croak ("IO::AIO: pathname arguments must be specified as a string, an IO::AIO::WD object or a [IO::AIO::WD, path] pair");
		876	}
		877
		878	*pathsv = newSVsv (path);
		879	ptr = SvPVbyte_nolen (pathsv);
		880	}
		881
		882	static void ecb_noinline
		883	req_set_path1 (aio_req req, SV *path)
		884	{
		885	req_set_path (req, path, &req->sv1, &req->sv3, &req->wd, &req->ptr1);
		886	}
		887
		888	static void ecb_noinline
		889	req_set_fh_or_path (aio_req req, int type_path, int type_fh, SV *fh_or_path)
		890	{
		891	SV *rv = SvROK (fh_or_path) ? SvRV (fh_or_path) : fh_or_path;
		892
		893	switch (SvTYPE (rv))
		894	{
		895	case SVt_PVIO:
		896	case SVt_PVLV:
		897	case SVt_PVGV:
		898	req->type = type_fh;
		899	req->sv1 = newSVsv (fh_or_path);
		900	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
		901	break;
		902
		903	default:
		904	req->type = type_path;
		905	req_set_path1 (req, fh_or_path);
		906	break;
		907	}
		908	}
		909
		910	XS(boot_IO__AIO) ecb_cold;
795		911
796	MODULE = IO::AIO PACKAGE = IO::AIO	912	MODULE = IO::AIO PACKAGE = IO::AIO
797		913
798	PROTOTYPES: ENABLE	914	PROTOTYPES: ENABLE
799		915
…		…
917	};	1033	};
918		1034
919	aio_stash = gv_stashpv ("IO::AIO" , 1);	1035	aio_stash = gv_stashpv ("IO::AIO" , 1);
920	aio_req_stash = gv_stashpv ("IO::AIO::REQ", 1);	1036	aio_req_stash = gv_stashpv ("IO::AIO::REQ", 1);
921	aio_grp_stash = gv_stashpv ("IO::AIO::GRP", 1);	1037	aio_grp_stash = gv_stashpv ("IO::AIO::GRP", 1);
		1038	aio_wd_stash = gv_stashpv ("IO::AIO::WD" , 1);
922		1039
923	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1040	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
924	newCONSTSUB (aio_stash, (char *)civ->name, newSViv (civ->iv));	1041	newCONSTSUB (aio_stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
925		1042
926	newCONSTSUB (aio_stash, "PAGESIZE", newSViv (PAGESIZE));	1043	newCONSTSUB (aio_stash, "PAGESIZE", newSViv (PAGESIZE));
927		1044
928	reinit ();	1045	reinit ();
929	}	1046	}
930		1047
931	void	1048	void
932	reinit ()	1049	reinit ()
933	PROTOTYPE:	1050	PROTOTYPE:
934	CODE:
935	reinit ();
936		1051
937	void	1052	void
938	max_poll_reqs (unsigned int nreqs)	1053	max_poll_reqs (unsigned int nreqs)
939	PROTOTYPE: $	1054	PROTOTYPE: $
940	CODE:	1055	CODE:
…		…
975	PROTOTYPE: $	1090	PROTOTYPE: $
976	CODE:	1091	CODE:
977	max_outstanding = maxreqs;	1092	max_outstanding = maxreqs;
978		1093
979	void	1094	void
		1095	aio_wd (SV8 pathname, SV callback=&PL_sv_undef)
		1096	PPCODE:
		1097	{
		1098	dREQ;
		1099
		1100	req->type = EIO_WD_OPEN;
		1101	req_set_path1 (req, pathname);
		1102
		1103	REQ_SEND;
		1104	}
		1105
		1106	void
980	aio_open (SV8 pathname, int flags, int mode, SV callback=&PL_sv_undef)	1107	aio_open (SV8 pathname, int flags, int mode, SV callback=&PL_sv_undef)
981	PPCODE:	1108	PPCODE:
982	{	1109	{
983	dREQ;	1110	dREQ;
984		1111
985	req->type = EIO_OPEN;	1112	req->type = EIO_OPEN;
986	req->sv1 = newSVsv (pathname);	1113	req_set_path1 (req, pathname);
987	req->ptr1 = SvPVbyte_nolen (req->sv1);
988	req->int1 = flags;	1114	req->int1 = flags;
989	req->int2 = mode;	1115	req->int2 = mode;
990		1116
991	REQ_SEND;	1117	REQ_SEND;
992	}	1118	}
…		…
994	void	1120	void
995	aio_fsync (SV fh, SV callback=&PL_sv_undef)	1121	aio_fsync (SV fh, SV callback=&PL_sv_undef)
996	ALIAS:	1122	ALIAS:
997	aio_fsync = EIO_FSYNC	1123	aio_fsync = EIO_FSYNC
998	aio_fdatasync = EIO_FDATASYNC	1124	aio_fdatasync = EIO_FDATASYNC
		1125	aio_syncfs = EIO_SYNCFS
999	PPCODE:	1126	PPCODE:
1000	{	1127	{
1001	int fd = s_fileno_croak (fh, 0);	1128	int fd = s_fileno_croak (fh, 0);
1002	dREQ;	1129	dREQ;
1003		1130
…		…
1128	REQ_SEND;	1255	REQ_SEND;
1129	}	1256	}
1130	}	1257	}
1131		1258
1132	void	1259	void
1133	aio_readlink (SV8 path, SV callback=&PL_sv_undef)	1260	aio_readlink (SV8 pathname, SV callback=&PL_sv_undef)
1134	ALIAS:	1261	ALIAS:
1135	aio_readlink = EIO_READLINK	1262	aio_readlink = EIO_READLINK
1136	aio_realpath = EIO_REALPATH	1263	aio_realpath = EIO_REALPATH
1137	PPCODE:	1264	PPCODE:
1138	{	1265	{
1139	dREQ;	1266	dREQ;
1140		1267
1141	req->type = ix;	1268	req->type = ix;
1142	req->sv1 = newSVsv (path);	1269	req_set_path1 (req, pathname);
1143	req->ptr1 = SvPVbyte_nolen (req->sv1);
1144		1270
1145	REQ_SEND;	1271	REQ_SEND;
1146	}	1272	}
1147		1273
1148	void	1274	void
…		…
1188	aio_statvfs = EIO_STATVFS	1314	aio_statvfs = EIO_STATVFS
1189	PPCODE:	1315	PPCODE:
1190	{	1316	{
1191	dREQ;	1317	dREQ;
1192		1318
1193	req->sv1 = newSVsv (fh_or_path);	1319	req_set_fh_or_path (req, ix, ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT, fh_or_path);
1194
1195	if (SvPOK (req->sv1))
1196	{
1197	req->type = ix;
1198	req->ptr1 = SvPVbyte_nolen (req->sv1);
1199	}
1200	else
1201	{
1202	req->type = ix == EIO_STATVFS ? EIO_FSTATVFS : EIO_FSTAT;
1203	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1204	}
1205		1320
1206	REQ_SEND;	1321	REQ_SEND;
1207	}	1322	}
1208		1323
1209	UV	1324	UV
…		…
1228	{	1343	{
1229	dREQ;	1344	dREQ;
1230		1345
1231	req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;	1346	req->nv1 = SvOK (atime) ? SvNV (atime) : -1.;
1232	req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;	1347	req->nv2 = SvOK (mtime) ? SvNV (mtime) : -1.;
1233	req->sv1 = newSVsv (fh_or_path);	1348	req_set_fh_or_path (req, EIO_UTIME, EIO_FUTIME, fh_or_path);
1234
1235	if (SvPOK (req->sv1))
1236	{
1237	req->type = EIO_UTIME;
1238	req->ptr1 = SvPVbyte_nolen (req->sv1);
1239	}
1240	else
1241	{
1242	req->type = EIO_FUTIME;
1243	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1244	}
1245		1349
1246	REQ_SEND;	1350	REQ_SEND;
1247	}	1351	}
1248		1352
1249	void	1353	void
1250	aio_truncate (SV8 fh_or_path, SV offset, SV *callback=&PL_sv_undef)	1354	aio_truncate (SV8 fh_or_path, SV offset, SV *callback=&PL_sv_undef)
1251	PPCODE:	1355	PPCODE:
1252	{	1356	{
1253	dREQ;	1357	dREQ;
1254		1358
1255	req->sv1 = newSVsv (fh_or_path);
1256	req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;	1359	req->offs = SvOK (offset) ? SvVAL64 (offset) : -1;
1257		1360	req_set_fh_or_path (req, EIO_TRUNCATE, EIO_FTRUNCATE, fh_or_path);
1258	if (SvPOK (req->sv1))
1259	{
1260	req->type = EIO_TRUNCATE;
1261	req->ptr1 = SvPVbyte_nolen (req->sv1);
1262	}
1263	else
1264	{
1265	req->type = EIO_FTRUNCATE;
1266	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1267	}
1268		1361
1269	REQ_SEND;	1362	REQ_SEND;
1270	}	1363	}
1271		1364
1272	void	1365	void
1273	aio_chmod (SV8 fh_or_path, int mode, SV callback=&PL_sv_undef)	1366	aio_chmod (SV8 fh_or_path, int mode, SV callback=&PL_sv_undef)
1274	ALIAS:
1275	aio_chmod = EIO_CHMOD
1276	aio_mkdir = EIO_MKDIR
1277	PPCODE:	1367	PPCODE:
1278	{	1368	{
1279	dREQ;	1369	dREQ;
1280		1370
1281	req->int2 = mode;	1371	req->int2 = mode;
1282	req->sv1 = newSVsv (fh_or_path);	1372	req_set_fh_or_path (req, EIO_CHMOD, EIO_FCHMOD, fh_or_path);
1283
1284	if (SvPOK (req->sv1))
1285	{
1286	req->type = ix;
1287	req->ptr1 = SvPVbyte_nolen (req->sv1);
1288	}
1289	else
1290	{
1291	req->type = EIO_FCHMOD;
1292	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1293	}
1294		1373
1295	REQ_SEND;	1374	REQ_SEND;
1296	}	1375	}
1297		1376
1298	void	1377	void
…		…
1301	{	1380	{
1302	dREQ;	1381	dREQ;
1303		1382
1304	req->int2 = SvOK (uid) ? SvIV (uid) : -1;	1383	req->int2 = SvOK (uid) ? SvIV (uid) : -1;
1305	req->int3 = SvOK (gid) ? SvIV (gid) : -1;	1384	req->int3 = SvOK (gid) ? SvIV (gid) : -1;
1306	req->sv1 = newSVsv (fh_or_path);	1385	req_set_fh_or_path (req, EIO_CHOWN, EIO_FCHOWN, fh_or_path);
1307
1308	if (SvPOK (req->sv1))
1309	{
1310	req->type = EIO_CHOWN;
1311	req->ptr1 = SvPVbyte_nolen (req->sv1);
1312	}
1313	else
1314	{
1315	req->type = EIO_FCHOWN;
1316	req->int1 = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
1317	}
1318		1386
1319	REQ_SEND;	1387	REQ_SEND;
1320	}	1388	}
1321		1389
1322	void	1390	void
…		…
1324	PPCODE:	1392	PPCODE:
1325	{	1393	{
1326	dREQ;	1394	dREQ;
1327		1395
1328	req->type = EIO_READDIR;	1396	req->type = EIO_READDIR;
1329	req->sv1 = newSVsv (pathname);
1330	req->ptr1 = SvPVbyte_nolen (req->sv1);
1331	req->int1 = flags \| EIO_READDIR_DENTS \| EIO_READDIR_CUSTOM1;	1397	req->int1 = flags \| EIO_READDIR_DENTS \| EIO_READDIR_CUSTOM1;
1332		1398
1333	if (flags & EIO_READDIR_DENTS)	1399	if (flags & EIO_READDIR_DENTS)
1334	req->int1 \|= EIO_READDIR_CUSTOM2;	1400	req->int1 \|= EIO_READDIR_CUSTOM2;
1335		1401
		1402	req_set_path1 (req, pathname);
		1403
1336	REQ_SEND;	1404	REQ_SEND;
		1405	}
		1406
		1407	void
		1408	aio_mkdir (SV8 pathname, int mode, SV callback=&PL_sv_undef)
		1409	PPCODE:
		1410	{
		1411	dREQ;
		1412
		1413	req->type = EIO_MKDIR;
		1414	req->int2 = mode;
		1415	req_set_path1 (req, pathname);
		1416
		1417	REQ_SEND;
1337	}	1418	}
1338		1419
1339	void	1420	void
1340	aio_unlink (SV8 pathname, SV callback=&PL_sv_undef)	1421	aio_unlink (SV8 pathname, SV callback=&PL_sv_undef)
1341	ALIAS:	1422	ALIAS:
…		…
1345	PPCODE:	1426	PPCODE:
1346	{	1427	{
1347	dREQ;	1428	dREQ;
1348		1429
1349	req->type = ix;	1430	req->type = ix;
1350	req->sv1 = newSVsv (pathname);	1431	req_set_path1 (req, pathname);
1351	req->ptr1 = SvPVbyte_nolen (req->sv1);
1352		1432
1353	REQ_SEND;	1433	REQ_SEND;
1354	}	1434	}
1355		1435
1356	void	1436	void
…		…
1359	aio_link = EIO_LINK	1439	aio_link = EIO_LINK
1360	aio_symlink = EIO_SYMLINK	1440	aio_symlink = EIO_SYMLINK
1361	aio_rename = EIO_RENAME	1441	aio_rename = EIO_RENAME
1362	PPCODE:	1442	PPCODE:
1363	{	1443	{
		1444	eio_wd wd2 = 0;
1364	dREQ;	1445	dREQ;
1365		1446
1366	req->type = ix;	1447	req->type = ix;
1367	req->sv1 = newSVsv (oldpath);	1448	req_set_path1 (req, oldpath);
1368	req->ptr1 = SvPVbyte_nolen (req->sv1);	1449	req_set_path (req, newpath, &req->sv2, &req->sv4, &wd2, &req->ptr2);
1369	req->sv2 = newSVsv (newpath);	1450	req->int3 = (long)wd2;
1370	req->ptr2 = SvPVbyte_nolen (req->sv2);
1371		1451
1372	REQ_SEND;	1452	REQ_SEND;
1373	}	1453	}
1374		1454
1375	void	1455	void
…		…
1377	PPCODE:	1457	PPCODE:
1378	{	1458	{
1379	dREQ;	1459	dREQ;
1380		1460
1381	req->type = EIO_MKNOD;	1461	req->type = EIO_MKNOD;
1382	req->sv1 = newSVsv (pathname);
1383	req->ptr1 = SvPVbyte_nolen (req->sv1);
1384	req->int2 = (mode_t)mode;	1462	req->int2 = (mode_t)mode;
1385	req->offs = dev;	1463	req->offs = dev;
		1464	req_set_path1 (req, pathname);
1386		1465
1387	REQ_SEND;	1466	REQ_SEND;
1388	}	1467	}
1389		1468
1390	void	1469	void
…		…
1590	CODE:	1669	CODE:
1591	RETVAL = posix_fadvise (fh, offset, length, advice);	1670	RETVAL = posix_fadvise (fh, offset, length, advice);
1592	OUTPUT:	1671	OUTPUT:
1593	RETVAL	1672	RETVAL
1594		1673
1595	ssize_t	1674	IV
1596	sendfile (aio_wfd ofh, aio_rfd ifh, off_t offset, size_t count)	1675	sendfile (aio_wfd ofh, aio_rfd ifh, off_t offset, size_t count)
1597	CODE:	1676	CODE:
1598	RETVAL = eio_sendfile_sync (ofh, ifh, offset, count);	1677	RETVAL = eio_sendfile_sync (ofh, ifh, offset, count);
1599	OUTPUT:	1678	OUTPUT:
1600	RETVAL	1679	RETVAL
…		…
1712	SvREFCNT_dec (on_next_submit);	1791	SvREFCNT_dec (on_next_submit);
1713	on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;	1792	on_next_submit = SvOK (cb) ? newSVsv (cb) : 0;
1714		1793
1715	PROTOTYPES: DISABLE	1794	PROTOTYPES: DISABLE
1716		1795
		1796	MODULE = IO::AIO PACKAGE = IO::AIO::WD
		1797
		1798	BOOT:
		1799	{
		1800	newCONSTSUB (aio_stash, "CWD" , newSVaio_wd (EIO_CWD ));
		1801	newCONSTSUB (aio_stash, "INVALID_WD", newSVaio_wd (EIO_INVALID_WD));
		1802	}
		1803
		1804	void
		1805	DESTROY (SV *self)
		1806	CODE:
		1807	{
		1808	aio_wd wd = SvAIO_WD (self);
		1809	#if HAVE_AT
		1810	{
		1811	SV *callback = &PL_sv_undef;
		1812	dREQ; /* clobbers next_pri :/ */
		1813	next_pri = req->pri; /* restore next_pri */
		1814	req->pri = EIO_PRI_MAX; /* better use max. priority to conserve fds */
		1815	req->type = EIO_WD_CLOSE;
		1816	req->wd = wd;
		1817	REQ_SEND;
		1818	}
		1819	#else
		1820	eio_wd_close_sync (wd);
		1821	#endif
		1822	}
		1823
1717	MODULE = IO::AIO PACKAGE = IO::AIO::REQ	1824	MODULE = IO::AIO PACKAGE = IO::AIO::REQ
1718		1825
1719	void	1826	void
1720	cancel (aio_req_ornot req)	1827	cancel (aio_req_ornot req)
1721	CODE:	1828	CODE:

Diff Legend

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

Comparing IO-AIO/AIO.xs (file contents): Revision 1.190 by root, Mon Jul 18 02:02:26 2011 UTC vs. Revision 1.207 by root, Fri Dec 30 07:40:54 2011 UTC

Diff Legend

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.190 by root, Mon Jul 18 02:02:26 2011 UTC vs.
Revision 1.207 by root, Fri Dec 30 07:40:54 2011 UTC