1/* Cancel requests associated with given file descriptor.
2 Copyright (C) 1997-2020 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
19
20
21/* We use an UGLY hack to prevent gcc from finding us cheating. The
22 implementation of aio_cancel and aio_cancel64 are identical and so
23 we want to avoid code duplication by using aliases. But gcc sees
24 the different parameter lists and prints a warning. We define here
25 a function so that aio_cancel64 has no prototype. */
26#ifndef aio_cancel
27#define aio_cancel64 XXX
28#include <aio.h>
29/* And undo the hack. */
30#undef aio_cancel64
31#endif
32
33#include <assert.h>
34#include <errno.h>
35#include <fcntl.h>
36
37#include <aio_misc.h>
38
39
40int
41aio_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
155#ifndef aio_cancel
156weak_alias (aio_cancel, aio_cancel64)
157#endif
158