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.249 by root, Fri Jun 23 23:50:25 2017 UTC vs.
Revision 1.253 by root, Tue Feb 20 04:32:59 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_EVENTFD
112# include <sys/eventfd.h>
113#endif
114
115#if HAVE_RLIMITS
116 #include <sys/time.h>
117 #include <sys/resource.h>
118#endif
119
109typedef SV SV8; /* byte-sv, used for argument-checking */ 120typedef SV SV8; /* byte-sv, used for argument-checking */
110typedef int aio_rfd; /* read file desriptor */ 121typedef int aio_rfd; /* read file desriptor */
111typedef int aio_wfd; /* write file descriptor */ 122typedef int aio_wfd; /* write file descriptor */
112 123
113static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash; 124static HV *aio_stash, *aio_req_stash, *aio_grp_stash, *aio_wd_stash;
… …
119 STRLEN stroffset; \ 130 STRLEN stroffset; \
120 SV *self; 131 SV *self;
121 132
122#define EIO_NO_WRAPPERS 1 133#define EIO_NO_WRAPPERS 1
123 134
124#include "libeio/config.h"
125#include "libeio/eio.h" 135#include "libeio/eio.h"
126 136
127static int req_invoke (eio_req *req); 137static int req_invoke (eio_req *req);
128#define EIO_FINISH(req) req_invoke (req) 138#define EIO_FINISH(req) req_invoke (req)
129static void req_destroy (eio_req *grp); 139static void req_destroy (eio_req *grp);
… …
162#endif 172#endif
163 173
164#if PAGESIZE <= 0 174#if PAGESIZE <= 0
165# define PAGESIZE sysconf (_SC_PAGESIZE) 175# define PAGESIZE sysconf (_SC_PAGESIZE)
166#endif 176#endif
177
178/*****************************************************************************/
179
180#if !_POSIX_MAPPED_FILES
181# define mmap(addr,length,prot,flags,fd,offs) EIO_ENOSYS ()
182# define munmap(addr,length) EIO_ENOSYS ()
183#endif
184
185#if !_POSIX_MEMORY_PROTECTION
186# define mprotect(addr,len,prot) EIO_ENOSYS ()
187#endif
188
189#define FOREIGN_MAGIC PERL_MAGIC_ext
190
191static int ecb_cold
192mmap_free (pTHX_ SV *sv, MAGIC *mg)
193{
194 int old_errno = errno;
195 munmap (mg->mg_ptr, (size_t)mg->mg_obj);
196 errno = old_errno;
197
198 mg->mg_obj = 0; /* just in case */
199
200 SvREADONLY_off (sv);
201
202 if (SvPVX (sv) != mg->mg_ptr)
203 croak ("ERROR: IO::AIO::mmap-mapped scalar changed location, detected");
204
205 SvCUR_set (sv, 0);
206 SvPVX (sv) = 0;
207 SvOK_off (sv);
208
209 return 0;
210}
211
212static MGVTBL mmap_vtbl = {
213 0, 0, 0, 0, mmap_free
214};
215
216static int ecb_cold
217sysfree_free (pTHX_ SV *sv, MAGIC *mg)
218{
219 free (mg->mg_ptr);
220 mg->mg_obj = 0; /* just in case */
221
222 SvREADONLY_off (sv);
223
224 if (SvPVX (sv) != mg->mg_ptr)
225 croak ("ERROR: IO::AIO mapped scalar changed location, detected");
226
227 SvCUR_set (sv, 0);
228 SvPVX (sv) = 0;
229 SvOK_off (sv);
230
231 return 0;
232}
233
234static MGVTBL sysfree_vtbl = {
235 0, 0, 0, 0, sysfree_free
236};
237
238/*****************************************************************************/
239
240/* helper: set scalar to foreign ptr with custom free */
241static void
242sv_set_foreign (SV *sv, const MGVTBL *const vtbl, void *addr, IV length)
243{
244 sv_force_normal (sv);
245
246 /* we store the length in mg_obj, as namlen is I32 :/ */
247 sv_magicext (sv, 0, FOREIGN_MAGIC, vtbl, (char *)addr, 0)
248 ->mg_obj = (SV *)length;
249
250 SvUPGRADE (sv, SVt_PV); /* nop... */
251
252 if (SvLEN (sv))
253 Safefree (SvPVX (sv));
254
255 SvPVX (sv) = (char *)addr;
256 SvCUR_set (sv, length);
257 SvLEN_set (sv, 0);
258 SvPOK_only (sv);
259}
260
261static void
262sv_clear_foreign (SV *sv)
263{
264 /* todo: iterate over magic and only free ours, but of course */
265 /* the perl5porters will call that (correct) behaviour buggy */
266 sv_unmagic (sv, FOREIGN_MAGIC);
267}
167 268
168/*****************************************************************************/ 269/*****************************************************************************/
169 270
170static void 271static void
171fiemap (eio_req *req) 272fiemap (eio_req *req)
… …
591 SvSETMAGIC (req->sv2); 692 SvSETMAGIC (req->sv2);
592 PUSHs (sv_result); 693 PUSHs (sv_result);
593 } 694 }
594 break; 695 break;
595 696
697 case EIO_SLURP:
698 {
699 if (req->result >= 0)
700 {
701 /* if length was originally not known, we steal the malloc'ed memory */
702 if (req->flags & EIO_FLAG_PTR2_FREE)
703 {
704 req->flags &= ~EIO_FLAG_PTR2_FREE;
705 sv_set_foreign (req->sv2, &sysfree_vtbl, req->ptr2, req->result);
706 }
707 else
708 {
709 SvCUR_set (req->sv2, req->result);
710 *SvEND (req->sv2) = 0;
711 SvPOK_only (req->sv2);
712 }
713
714 SvSETMAGIC (req->sv2);
715 }
716
717 PUSHs (sv_result);
718 }
719 break;
720
596 case EIO_CUSTOM: 721 case EIO_CUSTOM:
597 if (req->feed == fiemap) 722 if (req->feed == fiemap)
598 { 723 {
599#if HAVE_FIEMAP 724#if HAVE_FIEMAP
600 if (!req->result) 725 if (!req->result)
… …
743 create_respipe (); 868 create_respipe ();
744 869
745 if (eio_init (want_poll, done_poll) < 0) 870 if (eio_init (want_poll, done_poll) < 0)
746 croak ("IO::AIO: unable to initialise eio library"); 871 croak ("IO::AIO: unable to initialise eio library");
747} 872}
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 873
787/*****************************************************************************/ 874/*****************************************************************************/
788 875
789static SV * 876static SV *
790get_cb (SV *cb_sv) 877get_cb (SV *cb_sv)
… …
1078 const_iv (SPLICE_F_MOVE) 1165 const_iv (SPLICE_F_MOVE)
1079 const_iv (SPLICE_F_NONBLOCK) 1166 const_iv (SPLICE_F_NONBLOCK)
1080 const_iv (SPLICE_F_MORE) 1167 const_iv (SPLICE_F_MORE)
1081 const_iv (SPLICE_F_GIFT) 1168 const_iv (SPLICE_F_GIFT)
1082 1169
1170 const_iv (EFD_CLOEXEC)
1171 const_iv (EFD_NONBLOCK)
1172 const_iv (EFD_SEMAPHORE)
1173
1083 /* these are libeio constants, and are independent of gendef0 */ 1174 /* these are libeio constants, and are independent of gendef0 */
1084 const_eio (SEEK_SET) 1175 const_eio (SEEK_SET)
1085 const_eio (SEEK_CUR) 1176 const_eio (SEEK_CUR)
1086 const_eio (SEEK_END) 1177 const_eio (SEEK_END)
1087 1178
… …
1732 1823
1733 REQ_SEND; 1824 REQ_SEND;
1734} 1825}
1735 1826
1736void 1827void
1828aio_slurp (SV *pathname, off_t offset, UV length, SV8 *data, SV *callback = &PL_sv_undef)
1829 PPCODE:
1830{
1831 char *svptr = 0;
1832
1833 sv_clear_foreign (data);
1834
1835 if (length) /* known length, directly read into scalar */
1836 {
1837 if (!SvPOK (data) || SvLEN (data) >= SvCUR (data))
1838 svptr = sv_grow (data, length + 1);
1839 else if (SvCUR (data) < length)
1840 croak ("length outside of scalar, and cannot grow");
1841 else
1842 svptr = SvPVbyte_nolen (data);
1843 }
1844
1845 {
1846 dREQ;
1847
1848 req->type = EIO_SLURP;
1849 req_set_path1 (req, pathname);
1850 req->offs = offset;
1851 req->size = length;
1852 req->sv2 = SvREFCNT_inc (data);
1853 req->ptr2 = svptr;
1854
1855 if (!SvREADONLY (data))
1856 {
1857 SvREADONLY_on (data);
1858 req->flags |= FLAG_SV2_RO_OFF;
1859 }
1860
1861 REQ_SEND;
1862 }
1863}
1864
1865void
1737aio_busy (double delay, SV *callback = &PL_sv_undef) 1866aio_busy (double delay, SV *callback = &PL_sv_undef)
1738 PPCODE: 1867 PPCODE:
1739{ 1868{
1740 dREQ; 1869 dREQ;
1741 1870
… …
1875 RETVAL 2004 RETVAL
1876 2005
1877void 2006void
1878mmap (SV *scalar, STRLEN length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0) 2007mmap (SV *scalar, STRLEN length, int prot, int flags, SV *fh = &PL_sv_undef, off_t offset = 0)
1879 PPCODE: 2008 PPCODE:
1880 sv_unmagic (scalar, MMAP_MAGIC); 2009 sv_clear_foreign (scalar);
1881{ 2010{
1882 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1; 2011 int fd = SvOK (fh) ? s_fileno_croak (fh, flags & PROT_WRITE) : -1;
1883 void *addr = (void *)mmap (0, length, prot, flags, fd, offset); 2012 void *addr = (void *)mmap (0, length, prot, flags, fd, offset);
1884 if (addr == (void *)-1) 2013 if (addr == (void *)-1)
1885 XSRETURN_NO; 2014 XSRETURN_NO;
1886 2015
1887 sv_force_normal (scalar); 2016 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 2017
1895 if (!(prot & PROT_WRITE)) 2018 if (!(prot & PROT_WRITE))
1896 SvREADONLY_on (scalar); 2019 SvREADONLY_on (scalar);
1897 2020
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; 2021 XSRETURN_YES;
1907} 2022}
1908 2023
1909void 2024void
1910munmap (SV *scalar) 2025munmap (SV *scalar)
1911 CODE: 2026 CODE:
1912 sv_unmagic (scalar, MMAP_MAGIC); 2027 sv_clear_foreign (scalar);
1913 2028
1914int 2029int
1915madvise (SV *scalar, STRLEN offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot) 2030madvise (SV *scalar, STRLEN offset = 0, SV *length = &PL_sv_undef, IV advice_or_prot)
1916 ALIAS: 2031 ALIAS:
1917 mprotect = 1 2032 mprotect = 1
… …
2047 { 2162 {
2048 EXTEND (SP, 2); 2163 EXTEND (SP, 2);
2049 PUSHs (newmortalFH (fd[0], O_RDONLY)); 2164 PUSHs (newmortalFH (fd[0], O_RDONLY));
2050 PUSHs (newmortalFH (fd[1], O_WRONLY)); 2165 PUSHs (newmortalFH (fd[1], O_WRONLY));
2051 } 2166 }
2167}
2168
2169void
2170eventfd (unsigned int initval = 0, int flags = 0)
2171 PPCODE:
2172{
2173 int fd;
2174#if HAVE_EVENTFD
2175 fd = eventfd (initval, flags);
2176#else
2177 fd = (errno = ENOSYS, -1);
2178#endif
2179
2180 XPUSHs (newmortalFH (fd, O_RDWR));
2181}
2182
2183UV
2184get_fdlimit ()
2185 CODE:
2186#if HAVE_RLIMITS
2187 struct rlimit rl;
2188 if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2189 XSRETURN_UV (rl.rlim_cur == RLIM_INFINITY ? (UV)-1 : rl.rlim_cur);
2190#endif
2191 XSRETURN_UNDEF;
2192 OUTPUT:
2193 RETVAL
2194
2195void
2196min_fdlimit (UV limit = 0x7fffffffU)
2197 CODE:
2198{
2199#if HAVE_RLIMITS
2200 struct rlimit rl;
2201 rlim_t orig_rlim_max;
2202 UV bit;
2203
2204 if (0 != getrlimit (RLIMIT_NOFILE, &rl))
2205 goto fail;
2206
2207 if (rl.rlim_cur == RLIM_INFINITY)
2208 XSRETURN_YES;
2209
2210 orig_rlim_max = rl.rlim_max == RLIM_INFINITY ? ((rlim_t)0)-1 : rl.rlim_max;
2211
2212 if (rl.rlim_cur < limit)
2213 {
2214 rl.rlim_cur = limit;
2215
2216 if (rl.rlim_max < rl.rlim_cur && rl.rlim_max != RLIM_INFINITY)
2217 rl.rlim_max = rl.rlim_cur;
2218 }
2219
2220 if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2221 XSRETURN_YES;
2222
2223 if (errno == EPERM)
2224 {
2225 /* setlimit failed with EPERM - maybe we can't raise the hardlimit, or maybe */
2226 /* our limit overflows a system-wide limit */
2227 /* try an adaptive algorithm, but do not lower the hardlimit */
2228 rl.rlim_max = 0;
2229 for (bit = 0x40000000U; bit; bit >>= 1)
2230 {
2231 rl.rlim_max |= bit;
2232 rl.rlim_cur = rl.rlim_max;
2233
2234 /* nevr decrease the hard limit */
2235 if (rl.rlim_max < orig_rlim_max)
2236 break;
2237
2238 if (0 != setrlimit (RLIMIT_NOFILE, &rl))
2239 rl.rlim_max &= ~bit; /* too high, remove bit again */
2240 }
2241
2242 /* now, raise the soft limit to the max permitted */
2243 if (0 == getrlimit (RLIMIT_NOFILE, &rl))
2244 {
2245 rl.rlim_cur = rl.rlim_max;
2246 if (0 == setrlimit (RLIMIT_NOFILE, &rl))
2247 errno = EPERM;
2248 }
2249 }
2250#endif
2251 fail:
2252 XSRETURN_UNDEF;
2052} 2253}
2053 2254
2054void _on_next_submit (SV *cb) 2255void _on_next_submit (SV *cb)
2055 CODE: 2256 CODE:
2056 SvREFCNT_dec (on_next_submit); 2257 SvREFCNT_dec (on_next_submit);

Diff Legend

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