nsz Git - musl/blob - src/aio/aio_readwrite.c

   1 #include <aio.h>
   2 #include <fcntl.h>
   3 #include <errno.h>
   4 #include <unistd.h>
   5 #include <limits.h>
   6 #include "pthread_impl.h"
   7
   8 static void dummy(void)
   9 {
  10 }
  11
  12 weak_alias(dummy, __aio_wake);
  13
  14 static void notify_signal(struct sigevent *sev)
  15 {
  16         siginfo_t si = {
  17                 .si_signo = sev->sigev_signo,
  18                 .si_value = sev->sigev_value,
  19                 .si_code = SI_ASYNCIO,
  20                 .si_pid = __pthread_self()->pid,
  21                 .si_uid = getuid()
  22         };
  23         __syscall(SYS_rt_sigqueueinfo, si.si_pid, si.si_signo, &si);
  24 }
  25
  26 static void *io_thread(void *p)
  27 {
  28         struct aiocb *cb = p;
  29         int fd = cb->aio_fildes;
  30         void *buf = (void *)cb->aio_buf;
  31         size_t len = cb->aio_nbytes;
  32         off_t off = cb->aio_offset;
  33         int op = cb->aio_lio_opcode;
  34         struct sigevent sev = cb->aio_sigevent;
  35         ssize_t ret;
  36
  37         if (op == LIO_WRITE) {
  38                 if (  (fcntl(fd, F_GETFL) & O_APPEND)
  39                     ||((ret = pwrite(fd, buf, len, off))<0 && errno==ESPIPE) )
  40                         ret = write(fd, buf, len);
  41         } else if (op == LIO_READ) {
  42                 if ( (ret = pread(fd, buf, len, off))<0 && errno==ESPIPE )
  43                         ret = read(fd, buf, len);
  44         } else {
  45                 ret = 0;
  46         }
  47         cb->__ret = ret;
  48
  49         if (ret < 0) a_store(&cb->__err, errno);
  50         else a_store(&cb->__err, 0);
  51
  52         __aio_wake();
  53
  54         switch (cb->aio_sigevent.sigev_notify) {
  55         case SIGEV_SIGNAL:
  56                 notify_signal(&sev);
  57                 break;
  58         case SIGEV_THREAD:
  59                 sev.sigev_notify_function(sev.sigev_value);
  60                 break;
  61         }
  62
  63         return 0;
  64 }
  65
  66 static int new_req(struct aiocb *cb)
  67 {
  68         int ret = 0;
  69         pthread_attr_t a;
  70         sigset_t set;
  71         pthread_t td;
  72
  73         if (cb->aio_sigevent.sigev_notify == SIGEV_THREAD) {
  74                 if (cb->aio_sigevent.sigev_notify_attributes)
  75                         a = *cb->aio_sigevent.sigev_notify_attributes;
  76                 else
  77                         pthread_attr_init(&a);
  78         } else {
  79                 pthread_attr_init(&a);
  80                 pthread_attr_setstacksize(&a, PAGE_SIZE);
  81                 pthread_attr_setguardsize(&a, 0);
  82         }
  83         pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED);
  84         sigfillset(&set);
  85         pthread_sigmask(SIG_BLOCK, &set, &set);
  86         cb->__err = EINPROGRESS;
  87         if (pthread_create(&td, &a, io_thread, cb)) {
  88                 errno = EAGAIN;
  89                 ret = -1;
  90         }
  91         pthread_sigmask(SIG_SETMASK, &set, 0);
  92         cb->__td = td;
  93
  94         return ret;
  95 }
  96
  97 int aio_read(struct aiocb *cb)
  98 {
  99         cb->aio_lio_opcode = LIO_READ;
 100         return new_req(cb);
 101 }
 102
 103 int aio_write(struct aiocb *cb)
 104 {
 105         cb->aio_lio_opcode = LIO_WRITE;
 106         return new_req(cb);
 107 }