rt/aio_cancel.c

   1 /* Cancel requests associated with given file descriptor.
   2    Copyright (C) 1997-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19
  20 /* We use an UGLY hack to prevent gcc from finding us cheating.  The
  21    implementation of aio_cancel and aio_cancel64 are identical and so
  22    we want to avoid code duplication by using aliases.  But gcc sees
  23    the different parameter lists and prints a warning.  We define here
  24    a function so that aio_cancel64 has no prototype.  */
  25 #ifndef aio_cancel
  26 #define aio_cancel64 XXX
  27 #include <aio.h>
  28 /* And undo the hack.  */
  29 #undef aio_cancel64
  30 #endif
  31
  32 #include <assert.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35
  36 #include <aio_misc.h>
  37 #include <pthreadP.h>
  38
  39
  40 int
  41 __aio_cancel (int fildes, struct aiocb *aiocbp)
  42 {
  43   struct requestlist *req = NULL;
  44   int result = AIO_ALLDONE;
  45
  46   /* If fildes is invalid, error. */
  47   if (__fcntl (fildes, F_GETFL) < 0)
  48     {
  49       __set_errno (EBADF);
  50       return -1;
  51     }
  52
  53   /* Request the mutex.  */
  54   __pthread_mutex_lock (&__aio_requests_mutex);
  55
  56   /* We are asked to cancel a specific AIO request.  */
  57   if (aiocbp != NULL)
  58     {
  59       /* If the AIO request is not for this descriptor it has no value
  60          to look for the request block.  */
  61       if (aiocbp->aio_fildes != fildes)
  62         {
  63           __pthread_mutex_unlock (&__aio_requests_mutex);
  64           __set_errno (EINVAL);
  65           return -1;
  66         }
  67       else if (aiocbp->__error_code == EINPROGRESS)
  68         {
  69           struct requestlist *last = NULL;
  70
  71           req = __aio_find_req_fd (fildes);
  72
  73           if (req == NULL)
  74             {
  75             not_found:
  76               __pthread_mutex_unlock (&__aio_requests_mutex);
  77               __set_errno (EINVAL);
  78               return -1;
  79             }
  80
  81           while (req->aiocbp != (aiocb_union *) aiocbp)
  82             {
  83               last = req;
  84               req = req->next_prio;
  85               if (req == NULL)
  86                 goto not_found;
  87             }
  88
  89           /* Don't remove the entry if a thread is already working on it.  */
  90           if (req->running == allocated)
  91             {
  92               result = AIO_NOTCANCELED;
  93               req = NULL;
  94             }
  95           else
  96             {
  97               /* We can remove the entry.  */
  98               __aio_remove_request (last, req, 0);
  99
 100               result = AIO_CANCELED;
 101
 102               req->next_prio = NULL;
 103             }
 104         }
 105     }
 106   else
 107     {
 108       /* Find the beginning of the list of all requests for this
 109          desriptor.  */
 110       req = __aio_find_req_fd (fildes);
 111
 112       /* If any request is worked on by a thread it must be the first.
 113          So either we can delete all requests or all but the first.  */
 114       if (req != NULL)
 115         {
 116           if (req->running == allocated)
 117             {
 118               struct requestlist *old = req;
 119               req = req->next_prio;
 120               old->next_prio = NULL;
 121
 122               result = AIO_NOTCANCELED;
 123
 124               if (req != NULL)
 125                 __aio_remove_request (old, req, 1);
 126             }
 127           else
 128             {
 129               result = AIO_CANCELED;
 130
 131               /* We can remove the entry.  */
 132               __aio_remove_request (NULL, req, 1);
 133             }
 134         }
 135     }
 136
 137   /* Mark requests as canceled and send signal.  */
 138   while (req != NULL)
 139     {
 140       struct requestlist *old = req;
 141       assert (req->running == yes || req->running == queued);
 142       req->aiocbp->aiocb.__error_code = ECANCELED;
 143       req->aiocbp->aiocb.__return_value = -1;
 144       __aio_notify (req);
 145       req = req->next_prio;
 146       __aio_free_request (old);
 147     }
 148
 149   /* Release the mutex.  */
 150   __pthread_mutex_unlock (&__aio_requests_mutex);
 151
 152   return result;
 153 }
 154 #if PTHREAD_IN_LIBC
 155 # ifndef __aio_cancel
 156 versioned_symbol (libc, __aio_cancel, aio_cancel, GLIBC_2_34);
 157 versioned_symbol (libc, __aio_cancel, aio_cancel64, GLIBC_2_34);
 158 #  if OTHER_SHLIB_COMPAT (librt, GLIBC_2_1, GLIBC_2_34)
 159 compat_symbol (librt, __aio_cancel, aio_cancel, GLIBC_2_1);
 160 compat_symbol (librt, __aio_cancel, aio_cancel64, GLIBC_2_1);
 161 #  endif
 162 # endif /* __aio_cancel */
 163 #else /* !PTHREAD_IN_LIBC */
 164 strong_alias (__aio_cancel, aio_cancel)
 165 weak_alias (__aio_cancel, aio_cancel64)
 166 #endif