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

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.36 by root, Tue Aug 23 01:18:04 2005 UTC vs.
Revision 1.38 by root, Sun Aug 28 10:51:33 2005 UTC

…		…
7		7
8	#include "autoconf/config.h"	8	#include "autoconf/config.h"
9		9
10	#include <pthread.h>	10	#include <pthread.h>
11		11
		12	#include <stddef.h>
12	#include <sys/types.h>	13	#include <sys/types.h>
13	#include <sys/stat.h>	14	#include <sys/stat.h>
14		15	#include <limits.h>
15	#include <unistd.h>	16	#include <unistd.h>
16	#include <fcntl.h>	17	#include <fcntl.h>
17	#include <signal.h>	18	#include <signal.h>
18	#include <sched.h>	19	#include <sched.h>
19		20
…		…
33	#endif	34	#endif
34		35
35	#if __ia64	36	#if __ia64
36	# define STACKSIZE 65536	37	# define STACKSIZE 65536
37	#else	38	#else
38	# define STACKSIZE 4096	39	# define STACKSIZE 8192
39	#endif	40	#endif
40		41
41	enum {	42	enum {
42	REQ_QUIT,	43	REQ_QUIT,
43	REQ_OPEN, REQ_CLOSE,	44	REQ_OPEN, REQ_CLOSE,
44	REQ_READ, REQ_WRITE, REQ_READAHEAD,	45	REQ_READ, REQ_WRITE, REQ_READAHEAD,
45	REQ_SENDFILE,	46	REQ_SENDFILE,
46	REQ_STAT, REQ_LSTAT, REQ_FSTAT,	47	REQ_STAT, REQ_LSTAT, REQ_FSTAT,
47	REQ_FSYNC, REQ_FDATASYNC,	48	REQ_FSYNC, REQ_FDATASYNC,
48	REQ_UNLINK, REQ_RMDIR,	49	REQ_UNLINK, REQ_RMDIR,
		50	REQ_READDIR,
49	REQ_SYMLINK,	51	REQ_SYMLINK,
50	};	52	};
51		53
52	typedef struct aio_cb {	54	typedef struct aio_cb {
53	struct aio_cb *volatile next;	55	struct aio_cb *volatile next;
54		56
55	int type;	57	int type;
56		58
		59	/* should receive a cleanup, with unions */
57	int fd, fd2;	60	int fd, fd2;
58	off_t offset;	61	off_t offset;
59	size_t length;	62	size_t length;
60	ssize_t result;	63	ssize_t result;
61	mode_t mode; /* open */	64	mode_t mode; /* open */
…		…
97	Safefree (req->statdata);	100	Safefree (req->statdata);
98		101
99	if (req->callback)	102	if (req->callback)
100	SvREFCNT_dec (req->callback);	103	SvREFCNT_dec (req->callback);
101		104
		105	if (req->type == REQ_READDIR && req->result >= 0)
		106	free (req->data2ptr);
		107
102	Safefree (req);	108	Safefree (req);
103	}	109	}
104		110
105	static void	111	static void
106	poll_wait ()	112	poll_wait ()
…		…
170	PL_statcache = *(req->statdata);	176	PL_statcache = *(req->statdata);
171	}	177	}
172		178
173	ENTER;	179	ENTER;
174	PUSHMARK (SP);	180	PUSHMARK (SP);
175	XPUSHs (sv_2mortal (newSViv (req->result)));
176		181
177	if (req->type == REQ_OPEN)	182	if (req->type == REQ_READDIR)
178	{	183	{
		184	SV *rv = &PL_sv_undef;
		185
		186	if (req->result >= 0)
		187	{
		188	char *buf = req->data2ptr;
		189	AV *av = newAV ();
		190
		191	while (req->result)
		192	{
		193	SV *sv = newSVpv (buf, 0);
		194
		195	av_push (av, sv);
		196	buf += SvCUR (sv) + 1;
		197	req->result--;
		198	}
		199
		200	rv = sv_2mortal (newRV_noinc ((SV *)av));
		201	}
		202
		203	XPUSHs (rv);
		204	}
		205	else
		206	{
		207	XPUSHs (sv_2mortal (newSViv (req->result)));
		208
		209	if (req->type == REQ_OPEN)
		210	{
179	/* convert fd to fh */	211	/* convert fd to fh */
180	SV *fh;	212	SV *fh;
181		213
182	PUTBACK;	214	PUTBACK;
183	call_pv ("IO::AIO::_fd2fh", G_SCALAR \| G_EVAL);	215	call_pv ("IO::AIO::_fd2fh", G_SCALAR \| G_EVAL);
184	SPAGAIN;	216	SPAGAIN;
185		217
186	fh = SvREFCNT_inc (POPs);	218	fh = SvREFCNT_inc (POPs);
187		219
188	PUSHMARK (SP);	220	PUSHMARK (SP);
189	XPUSHs (sv_2mortal (fh));	221	XPUSHs (sv_2mortal (fh));
		222	}
190	}	223	}
191		224
192	if (SvOK (req->callback))	225	if (SvOK (req->callback))
193	{	226	{
194	PUTBACK;	227	PUTBACK;
…		…
317		350
318	if (fcntl (respipe [1], F_SETFL, O_NONBLOCK))	351	if (fcntl (respipe [1], F_SETFL, O_NONBLOCK))
319	croak ("cannot set result pipe to nonblocking mode");	352	croak ("cannot set result pipe to nonblocking mode");
320	}	353	}
321		354
322	static void atfork_prepare (void)
323	{
324	pthread_mutex_lock (&reqlock);
325	pthread_mutex_lock (&reslock);
326	}
327
328	static void atfork_parent (void)
329	{
330	pthread_mutex_unlock (&reslock);
331	pthread_mutex_unlock (&reqlock);
332	}
333
334	static void atfork_child (void)
335	{
336	aio_req prv;
337
338	started = 0;
339
340	while (reqs)
341	{
342	prv = reqs;
343	reqs = prv->next;
344	free_req (prv);
345	}
346
347	reqs = reqe = 0;
348
349	while (ress)
350	{
351	prv = ress;
352	ress = prv->next;
353	free_req (prv);
354	}
355
356	ress = rese = 0;
357
358	close (respipe [0]);
359	close (respipe [1]);
360	create_pipe ();
361
362	atfork_parent ();
363	}
364
365	/*****************************************************************************/	355	/*****************************************************************************/
366	/* work around various missing functions */	356	/* work around various missing functions */
367		357
368	#if !HAVE_PREADWRITE	358	#if !HAVE_PREADWRITE
369	# define pread aio_pread	359	# define pread aio_pread
…		…
372	/*	362	/*
373	* make our pread/pwrite safe against themselves, but not against	363	* make our pread/pwrite safe against themselves, but not against
374	* normal read/write by using a mutex. slows down execution a lot,	364	* normal read/write by using a mutex. slows down execution a lot,
375	* but that's your problem, not mine.	365	* but that's your problem, not mine.
376	*/	366	*/
377	static pthread_mutex_t iolock = PTHREAD_MUTEX_INITIALIZER;	367	static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER;
378		368
379	static ssize_t	369	static ssize_t
380	pread (int fd, void *buf, size_t count, off_t offset)	370	pread (int fd, void *buf, size_t count, off_t offset)
381	{	371	{
382	ssize_t res;	372	ssize_t res;
383	off_t ooffset;	373	off_t ooffset;
384		374
385	pthread_mutex_lock (&iolock);	375	pthread_mutex_lock (&preadwritelock);
386	ooffset = lseek (fd, 0, SEEK_CUR);	376	ooffset = lseek (fd, 0, SEEK_CUR);
387	lseek (fd, offset, SEEK_SET);	377	lseek (fd, offset, SEEK_SET);
388	res = read (fd, buf, count);	378	res = read (fd, buf, count);
389	lseek (fd, ooffset, SEEK_SET);	379	lseek (fd, ooffset, SEEK_SET);
390	pthread_mutex_unlock (&iolock);	380	pthread_mutex_unlock (&preadwritelock);
391		381
392	return res;	382	return res;
393	}	383	}
394		384
395	static ssize_t	385	static ssize_t
396	pwrite (int fd, void *buf, size_t count, off_t offset)	386	pwrite (int fd, void *buf, size_t count, off_t offset)
397	{	387	{
398	ssize_t res;	388	ssize_t res;
399	off_t ooffset;	389	off_t ooffset;
400		390
401	pthread_mutex_lock (&iolock);	391	pthread_mutex_lock (&preadwritelock);
402	ooffset = lseek (fd, 0, SEEK_CUR);	392	ooffset = lseek (fd, 0, SEEK_CUR);
403	lseek (fd, offset, SEEK_SET);	393	lseek (fd, offset, SEEK_SET);
404	res = write (fd, buf, count);	394	res = write (fd, buf, count);
405	lseek (fd, offset, SEEK_SET);	395	lseek (fd, offset, SEEK_SET);
406	pthread_mutex_unlock (&iolock);	396	pthread_mutex_unlock (&preadwritelock);
407		397
408	return res;	398	return res;
409	}	399	}
410	#endif	400	#endif
411		401
…		…
414	#endif	404	#endif
415		405
416	#if !HAVE_READAHEAD	406	#if !HAVE_READAHEAD
417	# define readahead aio_readahead	407	# define readahead aio_readahead
418		408
419	static char readahead_buf[4096];
420
421	static ssize_t	409	static ssize_t
422	readahead (int fd, off_t offset, size_t count)	410	readahead (int fd, off_t offset, size_t count)
423	{	411	{
		412	char readahead_buf[4096];
		413
424	while (count > 0)	414	while (count > 0)
425	{	415	{
426	size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf);	416	size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf);
427		417
428	pread (fd, readahead_buf, len, offset);	418	pread (fd, readahead_buf, len, offset);
…		…
432		422
433	errno = 0;	423	errno = 0;
434	}	424	}
435	#endif	425	#endif
436		426
		427	#if !HAVE_READDIR_R
		428	# define readdir_r aio_readdir_r
		429
		430	static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER;
		431
		432	static int
		433	readdir_r (DIR dirp, struct dirent ent, struct dirent **res)
		434	{
		435	struct dirent *e;
		436	int errorno;
		437
		438	pthread_mutex_lock (&readdirlock);
		439
		440	e = readdir (dirp);
		441	errorno = errno;
		442
		443	if (e)
		444	{
		445	*res = ent;
		446	strcpy (ent->d_name, e->d_name);
		447	}
		448	else
		449	*res = 0;
		450
		451	pthread_mutex_unlock (&readdirlock);
		452
		453	errno = errorno;
		454	return e ? 0 : -1;
		455	}
		456	#endif
		457
437	/* sendfile always needs emulation */	458	/* sendfile always needs emulation */
438	static ssize_t	459	static ssize_t
439	sendfile_ (int ofd, int ifd, off_t offset, size_t count)	460	sendfile_ (int ofd, int ifd, off_t offset, size_t count)
440	{	461	{
441	ssize_t res;	462	ssize_t res;
442		463
443	if (!count)	464	if (!count)
444	return 0;	465	return 0;
445		466
446	#if HAVE_SENDFILE	467	#if HAVE_SENDFILE
447	# if __linux	468	# if __linux
448	res = sendfile (ofd, ifd, &offset, count);	469	res = sendfile (ofd, ifd, &offset, count);
449		470
450	# elif __freebsd	471	# elif __freebsd
451	/*	472	/*
452	* Of course, the freebsd sendfile is a dire hack with no thoughts	473	* Of course, the freebsd sendfile is a dire hack with no thoughts
453	* wasted on making it similar to other I/O functions.	474	* wasted on making it similar to other I/O functions.
454	*/	475	*/
455	{	476	{
456	off_t sbytes;	477	off_t sbytes;
457	res = sendfile (ifd, ofd, offset, count, 0, &sbytes, 0);	478	res = sendfile (ifd, ofd, offset, count, 0, &sbytes, 0);
458		479
459	if (res < 0 && sbytes)	480	if (res < 0 && sbytes)
460	/* maybe only on EAGAIN only: as usual, the manpage leaves you guessing */	481	/* maybe only on EAGAIN only: as usual, the manpage leaves you guessing */
461	res = sbytes;	482	res = sbytes;
462	}	483	}
463		484
464	# elif __hpux	485	# elif __hpux
465	res = sendfile (ofd, ifd, offset, count, 0, 0);	486	res = sendfile (ofd, ifd, offset, count, 0, 0);
466		487
467	# elif __solaris	488	# elif __solaris
468	{	489	{
469	struct sendfilevec vec;	490	struct sendfilevec vec;
470	size_t sbytes;	491	size_t sbytes;
471		492
472	vec.sfv_fd = ifd;	493	vec.sfv_fd = ifd;
473	vec.sfv_flag = 0;	494	vec.sfv_flag = 0;
474	vec.sfv_off = offset;	495	vec.sfv_off = offset;
475	vec.sfv_len = count;	496	vec.sfv_len = count;
476		497
477	res = sendfilev (ofd, &vec, 1, &sbytes);	498	res = sendfilev (ofd, &vec, 1, &sbytes);
478		499
479	if (res < 0 && sbytes)	500	if (res < 0 && sbytes)
480	res = sbytes;	501	res = sbytes;
481	}	502	}
482		503
483	# else
484	res = -1;
485	errno = ENOSYS;
486	# endif	504	# endif
		505	#else
		506	res = -1;
		507	errno = ENOSYS;
487	#endif	508	#endif
488		509
489	if (res < 0	510	if (res < 0
490	&& (errno == ENOSYS \|\| errno == EINVAL \|\| errno == ENOTSOCK	511	&& (errno == ENOSYS \|\| errno == EINVAL \|\| errno == ENOTSOCK
491	#if __solaris	512	#if __solaris
492	\|\| errno == EAFNOSUPPORT \|\| errno == EPROTOTYPE	513	\|\| errno == EAFNOSUPPORT \|\| errno == EPROTOTYPE
493	#endif	514	#endif
494	)	515	)
495	)	516	)
496	{	517	{
497	/* emulate sendfile. this is a major pain in the ass */	518	/* emulate sendfile. this is a major pain in the ass */
498	char *buf = malloc (4096);	519	char buf[4096];
499	res = 0;	520	res = 0;
500		521
501	for (;;)	522	while (count)
502	{	523	{
503	ssize_t cnt;	524	ssize_t cnt;
504		525
505	cnt = pread (ifd, buf, 4096, offset);	526	cnt = pread (ifd, buf, count > 4096 ? 4096 : count, offset);
506		527
507	if (cnt <= 0)	528	if (cnt <= 0)
508	{	529	{
509	if (cnt && !res) res = -1;	530	if (cnt && !res) res = -1;
510	break;	531	break;
511	}	532	}
512		533
513	cnt = write (ofd, buf, cnt);	534	cnt = write (ofd, buf, cnt);
514		535
515	if (cnt <= 0)	536	if (cnt <= 0)
516	{	537	{
517	if (cnt && !res) res = -1;	538	if (cnt && !res) res = -1;
518	break;	539	break;
519	}	540	}
520		541
521	offset += cnt;	542	offset += cnt;
522	res += cnt;	543	res += cnt;
		544	count -= cnt;
523	}	545	}
524
525	{
526	int errorno = errno;
527	free (buf);
528	errno = errorno;
529	}
530	}	546	}
531		547
532	return res;	548	return res;
		549	}
		550
		551	/* read a full directory */
		552	static int
		553	scandir_ (const char path, void *namesp)
		554	{
		555	DIR *dirp = opendir (path);
		556	union
		557	{
		558	struct dirent d;
		559	char b [offsetof (struct dirent, d_name) + NAME_MAX + 1];
		560	} u;
		561	struct dirent *entp;
		562	char name, names;
		563	int memlen = 4096;
		564	int memofs = 0;
		565	int res = 0;
		566	int errorno;
		567
		568	if (!dirp)
		569	return -1;
		570
		571	names = malloc (memlen);
		572
		573	for (;;)
		574	{
		575	errno = 0, readdir_r (dirp, &u.d, &entp);
		576
		577	if (!entp)
		578	break;
		579
		580	name = entp->d_name;
		581
		582	if (name [0] != '.' \|\| (name [1] && (name [1] != '.' \|\| name [2])))
		583	{
		584	int len = strlen (name) + 1;
		585
		586	res++;
		587
		588	while (memofs + len > memlen)
		589	{
		590	memlen *= 2;
		591	names = realloc (names, memlen);
		592	if (!names)
		593	break;
		594	}
		595
		596	memcpy (names + memofs, name, len);
		597	memofs += len;
		598	}
		599	}
		600
		601	errorno = errno;
		602	closedir (dirp);
		603
		604	if (errorno)
		605	{
		606	free (names);
		607	errno = errorno;
		608	res = -1;
		609	}
		610
		611	namesp = (void )names;
		612	return res;
533	}	613	}
534		614
535	/*****************************************************************************/	615	/*****************************************************************************/
536		616
537	static void *	617	static void *
…		…
584	case REQ_RMDIR: req->result = rmdir (req->dataptr); break;	664	case REQ_RMDIR: req->result = rmdir (req->dataptr); break;
585	case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break;	665	case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break;
586		666
587	case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;	667	case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
588	case REQ_FSYNC: req->result = fsync (req->fd); break;	668	case REQ_FSYNC: req->result = fsync (req->fd); break;
		669	case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break;
589		670
590	case REQ_QUIT:	671	case REQ_QUIT:
591	break;	672	break;
592		673
593	default:	674	default:
…		…
617	pthread_mutex_unlock (&reslock);	698	pthread_mutex_unlock (&reslock);
618	}	699	}
619	while (type != REQ_QUIT);	700	while (type != REQ_QUIT);
620		701
621	return 0;	702	return 0;
		703	}
		704
		705	/*****************************************************************************/
		706
		707	static void atfork_prepare (void)
		708	{
		709	pthread_mutex_lock (&reqlock);
		710	pthread_mutex_lock (&reslock);
		711	#if !HAVE_PREADWRITE
		712	pthread_mutex_lock (&preadwritelock);
		713	#endif
		714	#if !HAVE_READDIR_R
		715	pthread_mutex_lock (&readdirlock);
		716	#endif
		717	}
		718
		719	static void atfork_parent (void)
		720	{
		721	#if !HAVE_READDIR_R
		722	pthread_mutex_unlock (&readdirlock);
		723	#endif
		724	#if !HAVE_PREADWRITE
		725	pthread_mutex_unlock (&preadwritelock);
		726	#endif
		727	pthread_mutex_unlock (&reslock);
		728	pthread_mutex_unlock (&reqlock);
		729	}
		730
		731	static void atfork_child (void)
		732	{
		733	aio_req prv;
		734
		735	started = 0;
		736
		737	while (reqs)
		738	{
		739	prv = reqs;
		740	reqs = prv->next;
		741	free_req (prv);
		742	}
		743
		744	reqs = reqe = 0;
		745
		746	while (ress)
		747	{
		748	prv = ress;
		749	ress = prv->next;
		750	free_req (prv);
		751	}
		752
		753	ress = rese = 0;
		754
		755	close (respipe [0]);
		756	close (respipe [1]);
		757	create_pipe ();
		758
		759	atfork_parent ();
622	}	760	}
623		761
624	#define dREQ \	762	#define dREQ \
625	aio_req req; \	763	aio_req req; \
626	\	764	\
…		…
877		1015
878	send_req (req);	1016	send_req (req);
879	}	1017	}
880		1018
881	void	1019	void
		1020	aio_readdir(pathname,callback=&PL_sv_undef)
		1021	SV * pathname
		1022	SV * callback
		1023	CODE:
		1024	{
		1025	dREQ;
		1026
		1027	req->type = REQ_READDIR;
		1028	req->data = newSVsv (pathname);
		1029	req->dataptr = SvPVbyte_nolen (req->data);
		1030
		1031	send_req (req);
		1032	}
		1033
		1034	void
882	flush()	1035	flush()
883	PROTOTYPE:	1036	PROTOTYPE:
884	CODE:	1037	CODE:
885	while (nreqs)	1038	while (nreqs)
886	{	1039	{

Diff Legend

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

Comparing IO-AIO/AIO.xs (file contents): Revision 1.36 by root, Tue Aug 23 01:18:04 2005 UTC vs. Revision 1.38 by root, Sun Aug 28 10:51:33 2005 UTC

Diff Legend

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.36 by root, Tue Aug 23 01:18:04 2005 UTC vs.
Revision 1.38 by root, Sun Aug 28 10:51:33 2005 UTC