1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
/* Notify initiator of AIO request.
Copyright (C) 1997-2017 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <aio_misc.h>
#include <signal.h>
#ifndef aio_start_notify_thread
# define aio_start_notify_thread() do { } while (0)
#endif
struct notify_func
{
void (*func) (sigval_t);
sigval_t value;
};
static void *
notify_func_wrapper (void *arg)
{
aio_start_notify_thread ();
struct notify_func *const n = arg;
void (*func) (sigval_t) = n->func;
sigval_t value = n->value;
free (n);
(*func) (value);
return NULL;
}
int
internal_function
#ifdef BROKEN_THREAD_SIGNALS
__aio_notify_only (struct sigevent *sigev, pid_t caller_pid)
#else
__aio_notify_only (struct sigevent *sigev)
#endif
{
int result = 0;
/* Send the signal to notify about finished processing of the request. */
if (__glibc_unlikely (sigev->sigev_notify == SIGEV_THREAD))
{
/* We have to start a thread. */
pthread_t tid;
pthread_attr_t attr, *pattr;
pattr = (pthread_attr_t *) sigev->sigev_notify_attributes;
if (pattr == NULL)
{
pthread_attr_init (&attr);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
pattr = &attr;
}
/* SIGEV may be freed as soon as we return, so we cannot let the
notification thread use that pointer. Even though a sigval_t is
only one word and the same size as a void *, we cannot just pass
the value through pthread_create as the argument and have the new
thread run the user's function directly, because on some machines
the calling convention for a union like sigval_t is different from
that for a pointer type like void *. */
struct notify_func *nf = malloc (sizeof *nf);
if (nf == NULL)
result = -1;
else
{
nf->func = sigev->sigev_notify_function;
nf->value = sigev->sigev_value;
if (pthread_create (&tid, pattr, notify_func_wrapper, nf) < 0)
{
free (nf);
result = -1;
}
}
}
else if (sigev->sigev_notify == SIGEV_SIGNAL)
{
/* We have to send a signal. */
#if _POSIX_REALTIME_SIGNALS > 0
/* Note that the standard gives us the option of using a plain
non-queuing signal here when SA_SIGINFO is not set for the signal. */
# ifdef BROKEN_THREAD_SIGNALS
if (__aio_sigqueue (sigev->sigev_signo, sigev->sigev_value, caller_pid)
< 0)
result = -1;
# else
if (__aio_sigqueue (sigev->sigev_signo, sigev->sigev_value, getpid ())
< 0)
result = -1;
# endif
#else
/* There are no queued signals on this system at all. */
result = raise (sigev->sigev_signo);
#endif
}
return result;
}
void
internal_function
__aio_notify (struct requestlist *req)
{
struct waitlist *waitlist;
struct aiocb *aiocbp = &req->aiocbp->aiocb;
#ifdef BROKEN_THREAD_SIGNALS
if (__aio_notify_only (&aiocbp->aio_sigevent, req->caller_pid) != 0)
#else
if (__aio_notify_only (&aiocbp->aio_sigevent) != 0)
#endif
{
/* XXX What shall we do if already an error is set by
read/write/fsync? */
aiocbp->__error_code = errno;
aiocbp->__return_value = -1;
}
/* Now also notify possibly waiting threads. */
waitlist = req->waiting;
while (waitlist != NULL)
{
struct waitlist *next = waitlist->next;
if (waitlist->sigevp == NULL)
{
if (waitlist->result != NULL && aiocbp->__return_value == -1)
*waitlist->result = -1;
#ifdef DONT_NEED_AIO_MISC_COND
AIO_MISC_NOTIFY (waitlist);
#else
/* Decrement the counter. */
--*waitlist->counterp;
pthread_cond_signal (waitlist->cond);
#endif
}
else
/* This is part of an asynchronous `lio_listio' operation. If
this request is the last one, send the signal. */
if (--*waitlist->counterp == 0)
{
#ifdef BROKEN_THREAD_SIGNALS
__aio_notify_only (waitlist->sigevp, waitlist->caller_pid);
#else
__aio_notify_only (waitlist->sigevp);
#endif
/* This is tricky. See lio_listio.c for the reason why
this works. */
free ((void *) waitlist->counterp);
}
waitlist = next;
}
}
|
