|
|
1 | #define _REENTRANT 1 |
|
|
2 | #include <errno.h> |
|
|
3 | |
1 | #include "EXTERN.h" |
4 | #include "EXTERN.h" |
2 | #include "perl.h" |
5 | #include "perl.h" |
3 | #include "XSUB.h" |
6 | #include "XSUB.h" |
4 | |
7 | |
5 | #include "autoconf/config.h" |
8 | #include "autoconf/config.h" |
… | |
… | |
230 | req->type = REQ_QUIT; |
233 | req->type = REQ_QUIT; |
231 | |
234 | |
232 | send_req (req); |
235 | send_req (req); |
233 | } |
236 | } |
234 | |
237 | |
|
|
238 | /* work around various missing functions */ |
|
|
239 | |
|
|
240 | #if !HAVE_PREADWRITE |
|
|
241 | # define pread aio_pread |
|
|
242 | # define pwrite aio_pwrite |
|
|
243 | |
|
|
244 | /* |
|
|
245 | * make our pread/pwrite safe against themselves, but not against |
|
|
246 | * normal read/write by using a mutex. slows down execution a lot, |
|
|
247 | * but that's your problem, not mine. |
|
|
248 | */ |
|
|
249 | static pthread_mutex_t iolock = PTHREAD_MUTEX_INITIALIZER; |
|
|
250 | |
|
|
251 | static ssize_t |
|
|
252 | pread (int fd, void *buf, size_t count, off_t offset) |
|
|
253 | { |
|
|
254 | ssize_t res; |
|
|
255 | off_t ooffset; |
|
|
256 | |
|
|
257 | pthread_mutex_lock (&iolock); |
|
|
258 | ooffset = lseek (fd, 0, SEEK_CUR); |
|
|
259 | lseek (fd, offset, SEEK_SET); |
|
|
260 | res = read (fd, buf, count); |
|
|
261 | lseek (fd, ooffset, SEEK_SET); |
|
|
262 | pthread_mutex_unlock (&iolock); |
|
|
263 | |
|
|
264 | return res; |
|
|
265 | } |
|
|
266 | |
|
|
267 | static ssize_t |
|
|
268 | pwrite (int fd, void *buf, size_t count, off_t offset) |
|
|
269 | { |
|
|
270 | ssize_t res; |
|
|
271 | off_t ooffset; |
|
|
272 | |
|
|
273 | pthread_mutex_lock (&iolock); |
|
|
274 | ooffset = lseek (fd, 0, SEEK_CUR); |
|
|
275 | lseek (fd, offset, SEEK_SET); |
|
|
276 | res = write (fd, buf, count); |
|
|
277 | lseek (fd, offset, SEEK_SET); |
|
|
278 | pthread_mutex_unlock (&iolock); |
|
|
279 | |
|
|
280 | return res; |
|
|
281 | } |
|
|
282 | #endif |
|
|
283 | |
|
|
284 | #if !HAVE_FDATASYNC |
|
|
285 | # define fdatasync fsync |
|
|
286 | #endif |
|
|
287 | |
|
|
288 | #if !HAVE_READAHEAD |
|
|
289 | # define readahead aio_readahead |
|
|
290 | |
|
|
291 | static char readahead_buf[4096]; |
|
|
292 | |
|
|
293 | static ssize_t |
|
|
294 | readahead (int fd, off_t offset, size_t count) |
|
|
295 | { |
|
|
296 | while (count > 0) |
|
|
297 | { |
|
|
298 | size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf); |
|
|
299 | |
|
|
300 | pread (fd, readahead_buf, len, offset); |
|
|
301 | offset += len; |
|
|
302 | count -= len; |
|
|
303 | } |
|
|
304 | |
|
|
305 | errno = 0; |
|
|
306 | } |
|
|
307 | #endif |
|
|
308 | |
235 | static void * |
309 | static void * |
236 | aio_proc (void *thr_arg) |
310 | aio_proc (void *thr_arg) |
237 | { |
311 | { |
238 | aio_req req; |
312 | aio_req req; |
239 | int type; |
313 | int type; |
… | |
… | |
264 | |
338 | |
265 | type = req->type; |
339 | type = req->type; |
266 | |
340 | |
267 | switch (type) |
341 | switch (type) |
268 | { |
342 | { |
269 | #if HAVE_PREADWRITE |
|
|
270 | case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break; |
343 | case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break; |
271 | case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break; |
344 | case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break; |
272 | #else |
|
|
273 | # error "pread/pwrite cannot be emulated, fix your os" |
|
|
274 | #endif |
|
|
275 | |
345 | |
276 | #if HAVE_READAHEAD |
|
|
277 | case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break; |
346 | case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break; |
278 | #else |
|
|
279 | // TODO: emulate |
|
|
280 | case REQ_READAHEAD: req->result = -1; errno = ENOSYS; break; |
|
|
281 | #endif |
|
|
282 | |
347 | |
283 | case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break; |
348 | case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break; |
284 | case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break; |
349 | case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break; |
285 | case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break; |
350 | case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break; |
286 | |
351 | |
287 | case REQ_OPEN: req->result = open (req->dataptr, req->fd, req->mode); break; |
352 | case REQ_OPEN: req->result = open (req->dataptr, req->fd, req->mode); break; |
288 | case REQ_CLOSE: req->result = close (req->fd); break; |
353 | case REQ_CLOSE: req->result = close (req->fd); break; |
289 | case REQ_UNLINK: req->result = unlink (req->dataptr); break; |
354 | case REQ_UNLINK: req->result = unlink (req->dataptr); break; |
290 | |
355 | |
291 | case REQ_FDATASYNC: |
356 | case REQ_FDATASYNC: req->result = fdatasync (req->fd); break; |
292 | #if HAVE_FDATASYNC |
|
|
293 | req->result = fdatasync (req->fd); break; |
|
|
294 | #endif |
|
|
295 | case REQ_FSYNC: req->result = fsync (req->fd); break; |
357 | case REQ_FSYNC: req->result = fsync (req->fd); break; |
296 | |
358 | |
297 | case REQ_QUIT: |
359 | case REQ_QUIT: |
298 | break; |
360 | break; |
299 | |
361 | |
… | |
… | |
446 | PROTOTYPE: $$$$$;$ |
508 | PROTOTYPE: $$$$$;$ |
447 | CODE: |
509 | CODE: |
448 | { |
510 | { |
449 | aio_req req; |
511 | aio_req req; |
450 | STRLEN svlen; |
512 | STRLEN svlen; |
451 | char *svptr = SvPV (data, svlen); |
513 | char *svptr = SvPVbyte (data, svlen); |
452 | |
514 | |
453 | SvUPGRADE (data, SVt_PV); |
515 | SvUPGRADE (data, SVt_PV); |
454 | SvPOK_on (data); |
516 | SvPOK_on (data); |
455 | |
517 | |
456 | if (dataoffset < 0) |
518 | if (dataoffset < 0) |