lib/librt/aio.c

   1 /*-
   2  * Copyright (c) 2011 Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  */
  15
  16 /*
  17  * This file contains support for the POSIX 1003.1B AIO/LIO facility.
  18  *
  19  * This version of AIO is aimed at standards compliance; it is not aimed
  20  * at either reasonability or performance. It merely wraps synchronous I/O
  21  * routines.
  22  *
  23  * This version cannot perform asynchronous notification of I/O completion
  24  * on DragonFly via SIGEV_SIGNAL.
  25  *
  26  *    2) SIGEV_SIGNAL code is present, but if-ed out under 'notyet'; Dfly
  27  *       does not support sigqueue(), so we cannot control the payload to
  28  *       a SIGINFO-signal from userspace. Programs using AIO signals use
  29  *       the payload field to carry pointers to the completed AIO structure,
  30  *       which is not yet possible here.
  31  *
  32  * It would be possible for this version to support SIGEV_KEVENT.
  33  */
  34
  35 #include <stdlib.h>
  36 #include <sys/types.h>
  37 #include <sys/time.h>
  38 #include <sys/signal.h>
  39 #include <sys/queue.h>
  40 #include <sys/stat.h>
  41 #include <unistd.h>
  42 #include <errno.h>
  43 #include <sys/aio.h>
  44 #include <pthread.h>
  45
  46 static void     *_aio_thr_start(void *);
  47
  48 static void
  49 _aio_notify(struct sigevent *sigevp)
  50 {
  51 #if 0 /* not yet */
  52         int sig;
  53         union sigval sv;
  54         pid_t pid;
  55 #endif
  56         pthread_t thr;
  57
  58         switch (sigevp->sigev_notify) {
  59         case SIGEV_NONE:
  60                 return;
  61
  62         case SIGEV_THREAD:
  63                 pthread_create(&thr,
  64                                sigevp->sigev_notify_attributes,
  65                                _aio_thr_start,
  66                                sigevp);
  67                 break;
  68
  69         case SIGEV_SIGNAL:
  70 #if 0 /* not yet */
  71                 pid = getpid();
  72                 sig = sigevp->sigev_signo;
  73                 sv = sigevp->sigev_value;
  74                 sigqueue(pid, sig, sv);
  75 #endif
  76                 break;
  77
  78         case SIGEV_KEVENT:
  79                 /* not yet */
  80                 break;
  81         }
  82 }
  83
  84 static void *
  85 _aio_thr_start(void *vsigevp)
  86 {
  87         struct sigevent *sigevp = vsigevp;
  88         sigevp->sigev_notify_function(sigevp->sigev_value);
  89         return (NULL);
  90 }
  91
  92 /*
  93  * aio_read()
  94  *
  95  *      Asynchronously read from a file
  96  */
  97 int
  98 aio_read(struct aiocb *ap)
  99 {
 100 #ifndef notyet
 101         if ((ap->aio_sigevent.sigev_notify != SIGEV_NONE) &&
 102             (ap->aio_sigevent.sigev_notify != SIGEV_THREAD))
 103                 return (ENOSYS);
 104 #endif
 105
 106         ap->_aio_val = pread(ap->aio_fildes,
 107                              (void *) ap->aio_buf,
 108                              ap->aio_nbytes,
 109                              ap->aio_offset);
 110         ap->_aio_err = errno;
 111
 112         _aio_notify(&ap->aio_sigevent);
 113
 114         return (0);
 115 }
 116
 117 int
 118 aio_write(struct aiocb *ap)
 119 {
 120 #ifndef notyet
 121         if ((ap->aio_sigevent.sigev_notify != SIGEV_NONE) &&
 122             (ap->aio_sigevent.sigev_notify != SIGEV_THREAD))
 123                 return (ENOSYS);
 124 #endif
 125
 126         ap->_aio_val = pwrite(ap->aio_fildes,
 127                               (void *) ap->aio_buf,
 128                               ap->aio_nbytes,
 129                               ap->aio_offset);
 130         ap->_aio_err = errno;
 131
 132         _aio_notify(&ap->aio_sigevent);
 133
 134         return (0);
 135 }
 136
 137 int
 138 aio_fsync(int op, struct aiocb *ap)
 139 {
 140 #ifndef notyet
 141         if ((ap->aio_sigevent.sigev_notify != SIGEV_NONE) &&
 142             (ap->aio_sigevent.sigev_notify != SIGEV_THREAD))
 143                 return (ENOSYS);
 144 #endif
 145
 146         ap->_aio_val = fsync(ap->aio_fildes);
 147         ap->_aio_err = errno;
 148
 149         _aio_notify(&ap->aio_sigevent);
 150
 151         return(0);
 152 }
 153
 154 int
 155 lio_listio(int mode, struct aiocb *const apv[], int nent,
 156            struct sigevent *sigevp)
 157 {
 158         int i;
 159
 160 #ifndef notyet
 161         if (sigevp &&
 162             (sigevp->sigev_notify != SIGEV_NONE) &&
 163             (sigevp->sigev_notify != SIGEV_THREAD))
 164                 return (ENOSYS);
 165 #endif
 166
 167         for (i = 0; i < nent; i++)
 168                 switch (apv[i]->aio_lio_opcode) {
 169                 case LIO_READ:
 170                         aio_read(apv[i]);
 171                         break;
 172                 case LIO_WRITE:
 173                         aio_write(apv[i]);
 174                         break;
 175                 case LIO_NOP:
 176                         break;
 177                 }
 178
 179         if (sigevp &&
 180             (mode == LIO_NOWAIT)
 181            ) {
 182                 _aio_notify(sigevp);
 183         }
 184
 185         return (0);
 186 }
 187
 188 /*
 189  * aio_error()
 190  *
 191  *      Get I/O completion status
 192  *
 193  *      Returns EINPROGRESS until I/O is complete. Returns ECANCELED if
 194  *      I/O is canceled. Returns I/O status if operation completed.
 195  *
 196  *      This routine does not block.
 197  */
 198 int
 199 aio_error(const struct aiocb *ap)
 200 {
 201         return (ap->_aio_err);
 202 }
 203
 204 /*
 205  * aio_return()
 206  *
 207  *      Finish up I/O, releasing I/O resources and returns the value
 208  *      that would have been associated with a synchronous request.
 209  */
 210 ssize_t
 211 aio_return(struct aiocb *ap)
 212 {
 213         return (ap->_aio_val);
 214 }
 215
 216 int
 217 aio_cancel(int fildes, struct aiocb *aiocbp)
 218 {
 219         struct stat sb;
 220
 221         /* must be a valid file descriptor */
 222         if (fstat(fildes, &sb)) {
 223                 errno = EBADF;
 224                 return -1;
 225         }
 226         return (AIO_ALLDONE);
 227 }
 228
 229 int
 230 aio_suspend(const struct aiocb *const list[], int nent, const struct timespec *timo)
 231 {
 232         return (0);
 233 }
 234