rtkaio/sysdeps/unix/sysv/linux/klio_listio.c

   1 /* Enqueue and list of read or write requests.
   2    Copyright (C) 1997,1998,1999,2000,2001,2002,2003,2005,2006
   3    Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
   6
   7    The GNU C Library is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU Lesser General Public
   9    License as published by the Free Software Foundation; either
  10    version 2.1 of the License, or (at your option) any later version.
  11
  12    The GNU C Library is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Lesser General Public License for more details.
  16
  17    You should have received a copy of the GNU Lesser General Public
  18    License along with the GNU C Library; if not, write to the Free
  19    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  20    02111-1307 USA.  */
  21
  22 #include <kaio_misc.h>
  23
  24 #ifndef USE_KAIO
  25 #include <lio_listio.c>
  26 #else
  27
  28 #ifndef lio_listio
  29 #include <aio.h>
  30 #include <assert.h>
  31 #include <errno.h>
  32 #include <stdlib.h>
  33 #include <unistd.h>
  34
  35 #define LIO_OPCODE_BASE 0
  36 #endif
  37
  38 #include <shlib-compat.h>
  39
  40
  41 /* We need this special structure to handle asynchronous I/O.  */
  42 struct async_waitlist
  43   {
  44     int counter;
  45     struct sigevent sigev;
  46     struct waitlist list[0];
  47   };
  48
  49
  50 /* The code in glibc 2.1 to glibc 2.4 issued only one event when all
  51    requests submitted with lio_listio finished.  The existing practice
  52    is to issue events for the individual requests as well.  This is
  53    what the new code does.  */
  54 #if SHLIB_COMPAT (librt, GLIBC_2_1, GLIBC_2_4)
  55 # define LIO_MODE(mode) ((mode) & 127)
  56 # define NO_INDIVIDUAL_EVENT_P(mode) ((mode) & 128)
  57 #else
  58 # define LIO_MODE(mode) mode
  59 # define NO_INDIVIDUAL_EVENT_P(mode) 0
  60 #endif
  61
  62
  63 static int
  64 lio_listio_internal (int mode, struct aiocb *const list[], int nent,
  65                      struct sigevent *sig)
  66 {
  67   struct sigevent defsigev;
  68   struct requestlist *requests[nent];
  69   int cnt;
  70   volatile int total = 0;
  71   int result = 0, op = 0;
  72   kctx_t kctx = KCTX_NONE;
  73
  74   if (sig == NULL)
  75     {
  76       defsigev.sigev_notify = SIGEV_NONE;
  77       sig = &defsigev;
  78     }
  79
  80   /* Request the mutex.  */
  81   pthread_mutex_lock (&__aio_requests_mutex);
  82
  83   if (LIO_MODE (mode) == LIO_WAIT && ! __have_no_kernel_aio && nent > 0)
  84     {
  85       int res;
  86       INTERNAL_SYSCALL_DECL (err);
  87
  88       kctx = 0;
  89       do
  90         res = INTERNAL_SYSCALL (io_setup, err, 2, nent, &kctx);
  91       while (INTERNAL_SYSCALL_ERROR_P (res, err)
  92              && INTERNAL_SYSCALL_ERRNO (res, err) == EINTR);
  93       if (INTERNAL_SYSCALL_ERROR_P (res, err))
  94         {
  95           kctx = KCTX_NONE;
  96           if (INTERNAL_SYSCALL_ERRNO (res, err) == ENOSYS)
  97             __have_no_kernel_aio = 1;
  98         }
  99     }
 100   else if (LIO_MODE (mode) == LIO_NOWAIT)
 101     {
 102       op = LIO_KTHREAD;
 103       if (sig->sigev_notify != SIGEV_NONE)
 104         op = LIO_KTHREAD | LIO_KTHREAD_REQUIRED;
 105     }
 106   op |= LIO_OPCODE_BASE;
 107
 108   /* Now we can enqueue all requests.  Since we already acquired the
 109      mutex the enqueue function need not do this.  */
 110   for (cnt = 0; cnt < nent; ++cnt)
 111     if (list[cnt] != NULL && list[cnt]->aio_lio_opcode != LIO_NOP)
 112       {
 113         if (NO_INDIVIDUAL_EVENT_P (mode))
 114           list[cnt]->aio_sigevent.sigev_notify = SIGEV_NONE;
 115         requests[cnt]
 116           = __aio_enqueue_request_ctx ((aiocb_union *) list[cnt],
 117                                        list[cnt]->aio_lio_opcode | op,
 118                                        kctx);
 119
 120         if (requests[cnt] != NULL)
 121           /* Successfully enqueued.  */
 122           ++total;
 123         else
 124           /* Signal that we've seen an error.  `errno' and the error code
 125              of the aiocb will tell more.  */
 126           result = -1;
 127       }
 128     else
 129       requests[cnt] = NULL;
 130
 131   if (total == 0)
 132     {
 133       /* We don't have anything to do except signalling if we work
 134          asynchronously.  */
 135
 136       if (kctx != KCTX_NONE)
 137         {
 138           INTERNAL_SYSCALL_DECL (err);
 139           INTERNAL_SYSCALL (io_destroy, err, 1, kctx);
 140         }
 141
 142       /* Release the mutex.  We do this before raising a signal since the
 143          signal handler might do a `siglongjmp' and then the mutex is
 144          locked forever.  */
 145       pthread_mutex_unlock (&__aio_requests_mutex);
 146
 147       if (LIO_MODE (mode) == LIO_NOWAIT)
 148         {
 149 #ifdef BROKEN_THREAD_SIGNALS
 150           __aio_notify_only (sig,
 151                              sig->sigev_notify == SIGEV_SIGNAL ? getpid () : 0);
 152 #else
 153           __aio_notify_only (sig);
 154 #endif
 155         }
 156
 157       return result;
 158     }
 159   else if (LIO_MODE (mode) == LIO_WAIT)
 160     {
 161 #ifndef DONT_NEED_AIO_MISC_COND
 162       pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
 163       int oldstate;
 164 #endif
 165       struct waitlist waitlist[nent];
 166       volatile int ktotal = 0;
 167
 168       total = 0;
 169       for (cnt = 0; cnt < nent; ++cnt)
 170         {
 171           assert (requests[cnt] == NULL || list[cnt] != NULL);
 172
 173           if (requests[cnt] != NULL && list[cnt]->aio_lio_opcode != LIO_NOP)
 174             {
 175               if (requests[cnt]->kioctx != KCTX_NONE)
 176                 {
 177                   assert (requests[cnt]->kioctx == kctx);
 178                   waitlist[cnt].counterp = &ktotal;
 179                   ++ktotal;
 180                 }
 181               else
 182                 {
 183                   waitlist[cnt].counterp = &total;
 184                   ++total;
 185                 }
 186 #ifndef DONT_NEED_AIO_MISC_COND
 187               waitlist[cnt].cond = &cond;
 188 #endif
 189               waitlist[cnt].result = &result;
 190               waitlist[cnt].next = requests[cnt]->waiting;
 191               waitlist[cnt].sigevp = NULL;
 192 #ifdef BROKEN_THREAD_SIGNALS
 193               waitlist[cnt].caller_pid = 0;     /* Not needed.  */
 194 #endif
 195               requests[cnt]->waiting = &waitlist[cnt];
 196             }
 197         }
 198
 199       while (ktotal > 0)
 200         __aio_wait_for_events (kctx, NULL);
 201 #ifdef DONT_NEED_AIO_MISC_COND
 202       AIO_MISC_WAIT (result, total, NULL, 0);
 203 #else
 204       /* Since `pthread_cond_wait'/`pthread_cond_timedwait' are cancellation
 205          points we must be careful.  We added entries to the waiting lists
 206          which we must remove.  So defer cancellation for now.  */
 207       pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &oldstate);
 208
 209       while (total > 0)
 210         pthread_cond_wait (&cond, &__aio_requests_mutex);
 211
 212       /* Now it's time to restore the cancellation state.  */
 213       pthread_setcancelstate (oldstate, NULL);
 214
 215       /* Release the conditional variable.  */
 216       if (pthread_cond_destroy (&cond) != 0)
 217         /* This must never happen.  */
 218         abort ();
 219 #endif
 220
 221       if (kctx != KCTX_NONE)
 222         {
 223           INTERNAL_SYSCALL_DECL (err);
 224           INTERNAL_SYSCALL (io_destroy, err, 1, kctx);
 225         }
 226
 227       /* If any of the I/O requests failed, return -1 and set errno.  */
 228       if (result != 0)
 229         {
 230           __set_errno (result == EINTR ? EINTR : EIO);
 231           result = -1;
 232         }
 233     }
 234   else if (sig->sigev_notify != SIGEV_NONE)
 235     {
 236       struct async_waitlist *waitlist;
 237
 238       waitlist = (struct async_waitlist *)
 239         malloc (sizeof (struct async_waitlist)
 240                 + (nent * sizeof (struct waitlist)));
 241
 242       if (waitlist == NULL)
 243         {
 244           __set_errno (EAGAIN);
 245           result = -1;
 246         }
 247       else
 248         {
 249 #ifdef BROKEN_THREAD_SIGNALS
 250           pid_t caller_pid = sig->sigev_notify == SIGEV_SIGNAL ? getpid () : 0;
 251 #endif
 252           total = 0;
 253
 254           for (cnt = 0; cnt < nent; ++cnt)
 255             {
 256               assert (requests[cnt] == NULL || list[cnt] != NULL);
 257
 258               if (requests[cnt] != NULL
 259                   && list[cnt]->aio_lio_opcode != LIO_NOP)
 260                 {
 261 #ifndef DONT_NEED_AIO_MISC_COND
 262                   waitlist->list[cnt].cond = NULL;
 263 #endif
 264                   waitlist->list[cnt].result = NULL;
 265                   waitlist->list[cnt].next = requests[cnt]->waiting;
 266                   waitlist->list[cnt].counterp = &waitlist->counter;
 267                   waitlist->list[cnt].sigevp = &waitlist->sigev;
 268 #ifdef BROKEN_THREAD_SIGNALS
 269                   waitlist->list[cnt].caller_pid = caller_pid;
 270 #endif
 271                   requests[cnt]->waiting = &waitlist->list[cnt];
 272                   ++total;
 273                 }
 274             }
 275
 276           waitlist->counter = total;
 277           waitlist->sigev = *sig;
 278         }
 279     }
 280
 281   /* Release the mutex.  */
 282   pthread_mutex_unlock (&__aio_requests_mutex);
 283
 284   return result;
 285 }
 286
 287
 288 #if SHLIB_COMPAT (librt, GLIBC_2_1, GLIBC_2_4)
 289 int
 290 attribute_compat_text_section
 291 __lio_listio_21 (int mode, struct aiocb *const list[], int nent,
 292                  struct sigevent *sig)
 293 {
 294   /* Check arguments.  */
 295   if (mode != LIO_WAIT && mode != LIO_NOWAIT)
 296     {
 297       __set_errno (EINVAL);
 298       return -1;
 299     }
 300
 301   return lio_listio_internal (mode | LIO_NO_INDIVIDUAL_EVENT, list, nent, sig);
 302 }
 303 compat_symbol (librt, __lio_listio_21, lio_listio, GLIBC_2_1);
 304 #endif
 305
 306
 307 int
 308 __lio_listio_item_notify (int mode, struct aiocb *const list[], int nent,
 309                           struct sigevent *sig)
 310 {
 311     /* Check arguments.  */
 312   if (mode != LIO_WAIT && mode != LIO_NOWAIT)
 313     {
 314       __set_errno (EINVAL);
 315       return -1;
 316     }
 317
 318   return lio_listio_internal (mode, list, nent, sig);
 319 }
 320 versioned_symbol (librt, __lio_listio_item_notify, lio_listio, GLIBC_2_4);
 321
 322 #endif