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 <unistd.h>
  41 #include <errno.h>
  42 #include <sys/aio.h>
  43 #include <pthread.h>
  44
  45 static void     *_aio_thr_start(void *);
  46
  47 static void
  48 _aio_notify(struct sigevent *sigevp)
  49 {
  50         int sig;
  51         union sigval sv;
  52         pid_t pid;
  53         pthread_t thr;
  54
  55         switch (sigevp->sigev_notify) {
  56         case SIGEV_NONE:
  57                 return;
  58
  59         case SIGEV_THREAD:
  60                 pthread_create(&thr,
  61                                sigevp->sigev_notify_attributes,
  62                                _aio_thr_start,
  63                                sigevp);
  64                 break;
  65
  66         case SIGEV_SIGNAL:
  67 #ifdef notyet
  68                 pid = getpid();
  69                 sig = sigevp->sigev_signo;
  70                 sv = sigevp->sigev_value;
  71                 sigqueue(pid, sig, sv);
  72 #endif
  73                 break;
  74
  75         case SIGEV_KEVENT:
  76 #ifdef notyet
  77 #endif
  78                 break;
  79         }
  80 }
  81
  82 static void *
  83 _aio_thr_start(void *vsigevp)
  84 {
  85         struct sigevent *sigevp = vsigevp;
  86         sigevp->sigev_notify_function(sigevp->sigev_value);
  87         return (NULL);
  88 }
  89
  90 /*
  91  * aio_read()
  92  *
  93  *      Asynchronously read from a file
  94  */
  95 int
  96 aio_read(struct aiocb *ap)
  97 {
  98 #ifndef notyet
  99         if ((ap->aio_sigevent.sigev_notify != SIGEV_NONE) &&
 100             (ap->aio_sigevent.sigev_notify != SIGEV_THREAD))
 101                 return (ENOSYS);
 102 #endif
 103
 104         ap->_aio_val = pread(ap->aio_fildes,
 105                              (void *) ap->aio_buf,
 106                              ap->aio_nbytes,
 107                              ap->aio_offset);
 108         ap->_aio_err = errno;
 109
 110         _aio_notify(&ap->aio_sigevent);
 111
 112         return (0);
 113 }
 114
 115 int
 116 aio_write(struct aiocb *ap)
 117 {
 118 #ifndef notyet
 119         if ((ap->aio_sigevent.sigev_notify != SIGEV_NONE) &&
 120             (ap->aio_sigevent.sigev_notify != SIGEV_THREAD))
 121                 return (ENOSYS);
 122 #endif
 123
 124         ap->_aio_val = pwrite(ap->aio_fildes,
 125                               (void *) ap->aio_buf,
 126                               ap->aio_nbytes,
 127                               ap->aio_offset);
 128         ap->_aio_err = errno;
 129
 130         _aio_notify(&ap->aio_sigevent);
 131
 132         return (0);
 133 }
 134
 135 int
 136 aio_fsync(int op, struct aiocb *ap)
 137 {
 138 #ifndef notyet
 139         if ((ap->aio_sigevent.sigev_notify != SIGEV_NONE) &&
 140             (ap->aio_sigevent.sigev_notify != SIGEV_THREAD))
 141                 return (ENOSYS);
 142 #endif
 143
 144         ap->_aio_val = fsync(ap->aio_fildes);
 145         ap->_aio_err = errno;
 146
 147         _aio_notify(&ap->aio_sigevent);
 148
 149         return(0);
 150 }
 151
 152 int
 153 lio_listio(int mode, struct aiocb *const apv[], int nent,
 154            struct sigevent *sigevp)
 155 {
 156         int i;
 157
 158 #ifndef notyet
 159         if ((sigevp->sigev_notify != SIGEV_NONE) &&
 160             (sigevp->sigev_notify != SIGEV_THREAD))
 161                 return (ENOSYS);
 162 #endif
 163
 164         for (i = 0; i < nent; i++)
 165                 switch (apv[i]->aio_lio_opcode) {
 166                 case LIO_READ:
 167                         aio_read(apv[i]);
 168                         break;
 169                 case LIO_WRITE:
 170                         aio_write(apv[i]);
 171                         break;
 172                 case LIO_NOP:
 173                         break;
 174                 }
 175
 176         if (sigevp &&
 177             (mode == LIO_NOWAIT)
 178            ) {
 179                 _aio_notify(sigevp);
 180         }
 181
 182         return (0);
 183 }
 184
 185 /*
 186  * aio_error()
 187  *
 188  *      Get I/O completion status
 189  *
 190  *      Returns EINPROGRESS until I/O is complete. Returns ECANCELED if
 191  *      I/O is canceled. Returns I/O status if operation completed.
 192  *
 193  *      This routine does not block.
 194  */
 195 int
 196 aio_error(const struct aiocb *ap)
 197 {
 198         return (ap->_aio_err);
 199 }
 200
 201 /*
 202  * aio_return()
 203  *
 204  *      Finish up I/O, releasing I/O resources and returns the value
 205  *      that would have been associated with a synchronous request.
 206  */
 207 ssize_t
 208 aio_return(struct aiocb *ap)
 209 {
 210         return (ap->_aio_val);
 211 }
 212
 213 int
 214 aio_cancel(int fildes, struct aiocb *aiocbp)
 215 {
 216         return (AIO_ALLDONE);
 217 }
 218
 219 int
 220 aio_suspend(const struct aiocb *const list[], int nent, const struct timespec *timo)
 221 {
 222         return (0);
 223 }
 224