ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/IO-AIO/AIO.xs
(Generate patch)

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.248 by root, Fri Jun 23 22:33:06 2017 UTC vs.
Revision 1.251 by root, Sat Jan 6 01:04:42 2018 UTC

… …
104#define expect_false(expr) expect ((expr) != 0, 0) 104#define expect_false(expr) expect ((expr) != 0, 0)
105#define expect_true(expr) expect ((expr) != 0, 1) 105#define expect_true(expr) expect ((expr) != 0, 1)
106 106
107/*****************************************************************************/ 107/*****************************************************************************/
108 108
109#include "libeio/config.h"
110
111#if HAVE_RLIMITS
112 #include <sys/time.h>
113 #include <sys/resource.h>
114#endif
115
109typedef SV SV8; /* byte-sv, used for argument-checking */ 116typedef SV SV8; /* byte-sv, used for argument-checking */
110typedef int aio_rfd; /* read file desriptor */ 117typedef int aio_rfd; /* read file desriptor */
111typedef int aio_wfd; /* write file descriptor */ 118typedef int aio_wfd; /* write file descriptor */
112 119
113static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash; 120static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash;
… …
119 STRLEN stroffset; \ 126 STRLEN stroffset; \
120 SV *self; 127 SV *self;
121 128
122#define EIO_NO_WRAPPERS 1 129#define EIO_NO_WRAPPERS 1
123 130
124#include "libeio/config.h"
125#include "libeio/eio.h" 131#include "libeio/eio.h"
126 132
127static int req_invoke (eio_req *req); 133static int req_invoke (eio_req *req);
128#define EIO_FINISH(req) req_invoke (req) 134#define EIO_FINISH(req) req_invoke (req)
129static void req_destroy (eio_req *grp); 135static void req_destroy (eio_req *grp);
… …
162#endif 168#endif
163 169
164#if PAGESIZE <= 0 170#if PAGESIZE <= 0
165# define PAGESIZE sysconf (_SC_PAGESIZE) 171# define PAGESIZE sysconf (_SC_PAGESIZE)
166#endif 172#endif
173
174/*****************************************************************************/
175
176#if !_POSIX_MAPPED_FILES
177# define mmap(addr,length,prot,flags,fd,offs) EIO_ENOSYS ()
178# define munmap(addr,length) EIO_ENOSYS ()
179#endif
180
181#if !_POSIX_MEMORY_PROTECTION
182# define mprotect(addr,len,prot) EIO_ENOSYS ()
183#endif
184
185#define FOREIGN_MAGIC PERL_MAGIC_ext
186
187static int ecb_cold
188mmap_free (pTHX_ SV *sv, MAGIC *mg)
189{
190 int old_errno = errno;
191 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
192 errno = old_errno;
193
194 mg->mg_obj = 0; /* just in case */
195
196 SvREADONLY_off (sv);
197
198 if (SvPVX (sv) != mg->mg_ptr)
199 croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
200
201 SvCUR_set (sv, 0);
202 SvPVX (sv) = 0;
203 SvOK_off (sv);
204
205 return 0;
206}
207
208static MGVTBL mmap_vtbl = {
209 0, 0, 0, 0, mmap_free
210};
211
212static int ecb_cold
213sysfree_free (pTHX_ SV *sv, MAGIC *mg)
214{
215 free (mg->mg_ptr);
216 mg->mg_obj = 0; /* just in case */
217
218 SvREADONLY_off (sv);
219
220 if (SvPVX (sv) != mg->mg_ptr)
221 croak ("ERROR: IO::AIO mapped scalar changed location, detected");
222
223 SvCUR_set (sv, 0);
224 SvPVX (sv) = 0;
225 SvOK_off (sv);
226
227 return 0;
228}
229
230static MGVTBL sysfree_vtbl = {
231 0, 0, 0, 0, sysfree_free
232};
233
234/*****************************************************************************/
235
236/* helper: set scalar to foreign ptr with custom free */
237static void
238sv_set_foreign (SV *sv, const MGVTBL *const vtbl, void *addr, IV length)
239{
240 sv_force_normal (sv);
241
242 /* we store the length in mg_obj, as namlen is I32 :/ */
243 sv_magicext (sv, 0, FOREIGN_MAGIC, vtbl, (char *)addr, 0)
244 ->mg_obj = (SV *)length;
245
246 SvUPGRADE (sv, SVt_PV); /* nop... */
247
248 if (SvLEN (sv))
249 Safefree (SvPVX (sv));
250
251 SvPVX (sv) = (char *)addr;
252 SvCUR_set (sv, length);
253 SvLEN_set (sv, 0);
254 SvPOK_only (sv);
255}
256
257static void
258sv_clear_foreign (SV *sv)
259{
260 /* todo: iterate over magic and only free ours, but of course */
261 /* the perl5porters will call that (correct) behaviour buggy */
262 sv_unmagic (sv, FOREIGN_MAGIC);
263}
167 264
168/*****************************************************************************/ 265/*****************************************************************************/
169 266
170static void 267static void
171fiemap (eio_req *req) 268fiemap (eio_req *req)
… …
591 SvSETMAGIC (req->sv2); 688 SvSETMAGIC (req->sv2);
592 PUSHs (sv_result); 689 PUSHs (sv_result);
593 } 690 }
594 break; 691 break;
595 692
693 case EIO_SLURP:
694 {
695 if (req->result >= 0)
696 {
697 /* if length was originally not known, we steal the malloc'ed memory */
698 if (req->flags & EIO_FLAG_PTR2_FREE)
699 {
700 req->flags &= ~EIO_FLAG_PTR2_FREE;
701 sv_set_foreign (req->sv2, &sysfree_vtbl, req->ptr2, req->result);
702 }
703 else
704 SvCUR_set (req->sv2, req->result);
705 }
706
707 PUSHs (sv_result);
708 }
709 break;
710
596 case EIO_CUSTOM: 711 case EIO_CUSTOM:
597 if (req->feed == fiemap) 712 if (req->feed == fiemap)
598 { 713 {
599#if HAVE_FIEMAP 714#if HAVE_FIEMAP
600 if (!req->result) 715 if (!req->result)
… …
743 create_respipe (); 858 create_respipe ();
744 859
745 if (eio_init (want_poll, done_poll) < 0) 860 if (eio_init (want_poll, done_poll) < 0)
746 croak ("IO::AIO: unable to initialise eio library"); 861 croak ("IO::AIO: unable to initialise eio library");
747} 862}
748
749/*****************************************************************************/
750
751#if !_POSIX_MAPPED_FILES
752# define mmap(addr,length,prot,flags,fd,offs) EIO_ENOSYS ()
753# define munmap(addr,length) EIO_ENOSYS ()
754#endif
755
756#if !_POSIX_MEMORY_PROTECTION
757# define mprotect(addr,len,prot) EIO_ENOSYS ()
758#endif
759
760#define MMAP_MAGIC PERL_MAGIC_ext
761
762static int ecb_cold
763mmap_free (pTHX_ SV *sv, MAGIC *mg)
764{
765 int old_errno = errno;
766 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
767 errno = old_errno;
768
769 mg->mg_obj = 0; /* just in case */
770
771 SvREADONLY_off (sv);
772
773 if (SvPVX (sv) != mg->mg_ptr)
774 croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
775
776 SvCUR_set (sv, 0);
777 SvPVX (sv) = 0;
778 SvOK_off (sv);
779
780 return 0;
781}
782
783static MGVTBL mmap_vtbl = {
784 0, 0, 0, 0, mmap_free
785};
786 863
787/*****************************************************************************/ 864/*****************************************************************************/
788 865
789static SV * 866static SV *
790get_cb (SV *cb_sv) 867get_cb (SV *cb_sv)
… …
1100 1177
1101 const_eio (FALLOC_FL_KEEP_SIZE) 1178 const_eio (FALLOC_FL_KEEP_SIZE)
1102 const_eio (FALLOC_FL_PUNCH_HOLE) 1179 const_eio (FALLOC_FL_PUNCH_HOLE)
1103 const_eio (FALLOC_FL_COLLAPSE_RANGE) 1180 const_eio (FALLOC_FL_COLLAPSE_RANGE)
1104 const_eio (FALLOC_FL_ZERO_RANGE) 1181 const_eio (FALLOC_FL_ZERO_RANGE)
1105 const_eio (FALLOC_FL_INSET_RANGE) 1182 const_eio (FALLOC_FL_INSERT_RANGE)
1106 const_eio (FALLOC_FL_UNSHARE_RANGE) 1183 const_eio (FALLOC_FL_UNSHARE_RANGE)
1107 1184
1108 const_eio (RENAME_NOREPLACE) 1185 const_eio (RENAME_NOREPLACE)
1109 const_eio (RENAME_EXCHANGE) 1186 const_eio (RENAME_EXCHANGE)
1110 const_eio (RENAME_WHITEOUT) 1187 const_eio (RENAME_WHITEOUT)
… …
1338 } 1415 }
1339 else 1416 else
1340 { 1417 {
1341 /* read: check type and grow scalar as necessary */ 1418 /* read: check type and grow scalar as necessary */
1342 if (!SvPOK (data) || SvLEN (data) >= SvCUR (data)) 1419 if (!SvPOK (data) || SvLEN (data) >= SvCUR (data))
1343 svptr = sv_grow (data, len + dataoffset + 1); 1420 svptr = sv_grow (data, len + dataoffset);
1344 else if (SvCUR (data) < len + dataoffset) 1421 else if (SvCUR (data) < len + dataoffset)
1345 croak ("length + dataoffset outside of scalar, and cannot grow"); 1422 croak ("length + dataoffset outside of scalar, and cannot grow");
1346 } 1423 }
1347 1424
1348 { 1425 {
… …
1729 req->int2 = flags; 1806 req->int2 = flags;
1730 req->int3 = SvOK (count) ? SvIV (count) : -1; 1807 req->int3 = SvOK (count) ? SvIV (count) : -1;
1731#endif 1808#endif
1732 1809
1733 REQ_SEND; 1810 REQ_SEND;
1811}
1812
1813void
1814aio_slurp (SV *pathname, off_t offset, UV length, SV8 *data, SV *callback = &PL_sv_undef)
1815 PPCODE:
1816{
1817 char *svptr = 0;
1818
1819 sv_clear_foreign (data);
1820
1821 if (length) /* known length, directly read into scalar */
1822 {
1823 if (!SvPOK (data) || SvLEN (data) >= SvCUR (data))
1824 svptr = sv_grow (data, length);
1825 else if (SvCUR (data) < length)
1826 croak ("length outside of scalar, and cannot grow");
1827 else
1828 svptr = SvPVbyte_nolen (data);
1829 }
1830
1831 {
1832 dREQ;
1833
1834 req->type = EIO_SLURP;
1835 req_set_path1 (req, pathname);
1836 req->offs = offset;
1837 req->size = length;
1838 req->sv2 = SvREFCNT_inc (data);
1839 req->ptr2 = svptr;
1840
1841 if (!SvREADONLY (data))
1842 {
1843 SvREADONLY_on (data);
1844 req->flags |= FLAG_SV2_RO_OFF;
1845 }
1846
1847 REQ_SEND;
1848 }
1734} 1849}
1735 1850
1736void 1851void
1737aio_busy (double delay, SV *callback = &PL_sv_undef) 1852aio_busy (double delay, SV *callback = &PL_sv_undef)
1738 PPCODE: 1853 PPCODE:
… …
1875 RETVAL 1990 RETVAL
1876 1991
1877void 1992void
1878mmap (SV *scalar, STRLEN length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0) 1993mmap (SV *scalar, STRLEN length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0)
1879 PPCODE: 1994 PPCODE:
1880 sv_unmagic (scalar, MMAP_MAGIC); 1995 sv_clear_foreign (scalar);
1881{ 1996{
1882 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1; 1997 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1;
1883 void *addr = (void *)mmap (0, length, prot, flags, fd, offset); 1998 void *addr = (void *)mmap (0, length, prot, flags, fd, offset);
1884 if (addr == (void *)-1) 1999 if (addr == (void *)-1)
1885 XSRETURN_NO; 2000 XSRETURN_NO;
1886 2001
1887 sv_force_normal (scalar); 2002 sv_set_foreign (scalar, &mmap_vtbl, addr, length);
1888
1889 /* we store the length in mg_obj, as namlen is I32 :/ */
1890 sv_magicext (scalar, 0, MMAP_MAGIC, &mmap_vtbl, (char *)addr, 0)
1891 ->mg_obj = (SV *)length;
1892
1893 SvUPGRADE (scalar, SVt_PV); /* nop... */
1894 2003
1895 if (!(prot & PROT_WRITE)) 2004 if (!(prot & PROT_WRITE))
1896 SvREADONLY_on (scalar); 2005 SvREADONLY_on (scalar);
1897 2006
1898 if (SvLEN (scalar))
1899 Safefree (SvPVX (scalar));
1900
1901 SvPVX (scalar) = (char *)addr;
1902 SvCUR_set (scalar, length);
1903 SvLEN_set (scalar, 0);
1904 SvPOK_only (scalar);
1905
1906 XSRETURN_YES; 2007 XSRETURN_YES;
1907} 2008}
1908 2009
1909void 2010void
1910munmap (SV *scalar) 2011munmap (SV *scalar)
1911 CODE: 2012 CODE:
1912 sv_unmagic (scalar, MMAP_MAGIC); 2013 sv_clear_foreign (scalar);
1913 2014
1914int 2015int
1915madvise (SV *scalar, STRLEN offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot) 2016madvise (SV *scalar, STRLEN offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot)
1916 ALIAS: 2017 ALIAS:
1917 mprotect = 1 2018 mprotect = 1
… …
2047 { 2148 {
2048 EXTEND (SP, 2); 2149 EXTEND (SP, 2);
2049 PUSHs (newmortalFH (fd[0], O_RDONLY)); 2150 PUSHs (newmortalFH (fd[0], O_RDONLY));
2050 PUSHs (newmortalFH (fd[1], O_WRONLY)); 2151 PUSHs (newmortalFH (fd[1], O_WRONLY));
2051 } 2152 }
2153}
2154
2155UV
2156get_fdlimit ()
2157 CODE:
2158#if HAVE_RLIMITS
2159 struct rlimit rl;
2160 if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2161 XSRETURN_UV (rl.rlim_cur == RLIM_INFINITY ? (UV)-1 : rl.rlim_cur);
2162#endif
2163 XSRETURN_UNDEF;
2164 OUTPUT:
2165 RETVAL
2166
2167void
2168min_fdlimit (UV limit = 0x7fffffffU)
2169 CODE:
2170{
2171#if HAVE_RLIMITS
2172 struct rlimit rl;
2173 rlim_t orig_rlim_max;
2174 UV bit;
2175
2176 if (0 != getrlimit (RLIMIT_NOFILE, &rl))
2177 goto fail;
2178
2179 if (rl.rlim_cur == RLIM_INFINITY)
2180 XSRETURN_YES;
2181
2182 orig_rlim_max = rl.rlim_max == RLIM_INFINITY ? ((rlim_t)0)-1 : rl.rlim_max;
2183
2184 if (rl.rlim_cur < limit)
2185 {
2186 rl.rlim_cur = limit;
2187
2188 if (rl.rlim_max < rl.rlim_cur && rl.rlim_max != RLIM_INFINITY)
2189 rl.rlim_max = rl.rlim_cur;
2190 }
2191
2192 if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2193 XSRETURN_YES;
2194
2195 if (errno == EPERM)
2196 {
2197 /* setlimit failed with EPERM - maybe we can't raise the hardlimit, or maybe */
2198 /* our limit overflows a system-wide limit */
2199 /* try an adaptive algorithm, but do not lower the hardlimit */
2200 rl.rlim_max = 0;
2201 for (bit = 0x40000000U; bit; bit >>= 1)
2202 {
2203 rl.rlim_max |= bit;
2204 rl.rlim_cur = rl.rlim_max;
2205
2206 /* nevr decrease the hard limit */
2207 if (rl.rlim_max < orig_rlim_max)
2208 break;
2209
2210 if (0 != setrlimit (RLIMIT_NOFILE, &rl))
2211 rl.rlim_max &= ~bit; /* too high, remove bit again */
2212 }
2213
2214 /* now, raise the soft limit to the max permitted */
2215 if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2216 {
2217 rl.rlim_cur = rl.rlim_max;
2218 if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2219 errno = EPERM;
2220 }
2221 }
2222#endif
2223 fail:
2224 XSRETURN_UNDEF;
2052} 2225}
2053 2226
2054void _on_next_submit (SV *cb) 2227void _on_next_submit (SV *cb)
2055 CODE: 2228 CODE:
2056 SvREFCNT_dec (on_next_submit); 2229 SvREFCNT_dec (on_next_submit);

Diff Legend

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