1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/file.h>
21#include <linux/poll.h>
22#include <linux/init.h>
23#include <linux/fs.h>
24#include <linux/sched.h>
25#include <linux/slab.h>
26#include <linux/kernel.h>
27#include <linux/signal.h>
28#include <linux/list.h>
29#include <linux/anon_inodes.h>
30#include <linux/signalfd.h>
31#include <linux/syscalls.h>
32
33void signalfd_cleanup(struct sighand_struct *sighand)
34{
35 wait_queue_head_t *wqh = &sighand->signalfd_wqh;
36
37
38
39
40
41 if (likely(!waitqueue_active(wqh)))
42 return;
43
44
45 wake_up_poll(wqh, POLLHUP | POLLFREE);
46}
47
48struct signalfd_ctx {
49 sigset_t sigmask;
50};
51
52static int signalfd_release(struct inode *inode, struct file *file)
53{
54 kfree(file->private_data);
55 return 0;
56}
57
58static unsigned int signalfd_poll(struct file *file, poll_table *wait)
59{
60 struct signalfd_ctx *ctx = file->private_data;
61 unsigned int events = 0;
62
63 poll_wait(file, ¤t->sighand->signalfd_wqh, wait);
64
65 spin_lock_irq(¤t->sighand->siglock);
66 if (next_signal(¤t->pending, &ctx->sigmask) ||
67 next_signal(¤t->signal->shared_pending,
68 &ctx->sigmask))
69 events |= POLLIN;
70 spin_unlock_irq(¤t->sighand->siglock);
71
72 return events;
73}
74
75
76
77
78static int signalfd_copyinfo(struct signalfd_siginfo __user *uinfo,
79 siginfo_t const *kinfo)
80{
81 long err;
82
83 BUILD_BUG_ON(sizeof(struct signalfd_siginfo) != 128);
84
85
86
87
88 err = __clear_user(uinfo, sizeof(*uinfo));
89
90
91
92
93
94 err |= __put_user(kinfo->si_signo, &uinfo->ssi_signo);
95 err |= __put_user(kinfo->si_errno, &uinfo->ssi_errno);
96 err |= __put_user((short) kinfo->si_code, &uinfo->ssi_code);
97 switch (kinfo->si_code & __SI_MASK) {
98 case __SI_KILL:
99 err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
100 err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
101 break;
102 case __SI_TIMER:
103 err |= __put_user(kinfo->si_tid, &uinfo->ssi_tid);
104 err |= __put_user(kinfo->si_overrun, &uinfo->ssi_overrun);
105 err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
106 err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
107 break;
108 case __SI_POLL:
109 err |= __put_user(kinfo->si_band, &uinfo->ssi_band);
110 err |= __put_user(kinfo->si_fd, &uinfo->ssi_fd);
111 break;
112 case __SI_FAULT:
113 err |= __put_user((long) kinfo->si_addr, &uinfo->ssi_addr);
114#ifdef __ARCH_SI_TRAPNO
115 err |= __put_user(kinfo->si_trapno, &uinfo->ssi_trapno);
116#endif
117#ifdef BUS_MCEERR_AO
118
119
120
121
122 if (kinfo->si_code == BUS_MCEERR_AR ||
123 kinfo->si_code == BUS_MCEERR_AO)
124 err |= __put_user((short) kinfo->si_addr_lsb,
125 &uinfo->ssi_addr_lsb);
126#endif
127 break;
128 case __SI_CHLD:
129 err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
130 err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
131 err |= __put_user(kinfo->si_status, &uinfo->ssi_status);
132 err |= __put_user(kinfo->si_utime, &uinfo->ssi_utime);
133 err |= __put_user(kinfo->si_stime, &uinfo->ssi_stime);
134 break;
135 case __SI_RT:
136 case __SI_MESGQ:
137 err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
138 err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
139 err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
140 err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
141 break;
142 default:
143
144
145
146 err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
147 err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
148 err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
149 err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
150 break;
151 }
152
153 return err ? -EFAULT: sizeof(*uinfo);
154}
155
156static ssize_t signalfd_dequeue(struct signalfd_ctx *ctx, siginfo_t *info,
157 int nonblock)
158{
159 ssize_t ret;
160 DECLARE_WAITQUEUE(wait, current);
161
162 spin_lock_irq(¤t->sighand->siglock);
163 ret = dequeue_signal(current, &ctx->sigmask, info);
164 switch (ret) {
165 case 0:
166 if (!nonblock)
167 break;
168 ret = -EAGAIN;
169 default:
170 spin_unlock_irq(¤t->sighand->siglock);
171 return ret;
172 }
173
174 add_wait_queue(¤t->sighand->signalfd_wqh, &wait);
175 for (;;) {
176 set_current_state(TASK_INTERRUPTIBLE);
177 ret = dequeue_signal(current, &ctx->sigmask, info);
178 if (ret != 0)
179 break;
180 if (signal_pending(current)) {
181 ret = -ERESTARTSYS;
182 break;
183 }
184 spin_unlock_irq(¤t->sighand->siglock);
185 schedule();
186 spin_lock_irq(¤t->sighand->siglock);
187 }
188 spin_unlock_irq(¤t->sighand->siglock);
189
190 remove_wait_queue(¤t->sighand->signalfd_wqh, &wait);
191 __set_current_state(TASK_RUNNING);
192
193 return ret;
194}
195
196
197
198
199
200
201static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
202 loff_t *ppos)
203{
204 struct signalfd_ctx *ctx = file->private_data;
205 struct signalfd_siginfo __user *siginfo;
206 int nonblock = file->f_flags & O_NONBLOCK;
207 ssize_t ret, total = 0;
208 siginfo_t info;
209
210 count /= sizeof(struct signalfd_siginfo);
211 if (!count)
212 return -EINVAL;
213
214 siginfo = (struct signalfd_siginfo __user *) buf;
215 do {
216 ret = signalfd_dequeue(ctx, &info, nonblock);
217 if (unlikely(ret <= 0))
218 break;
219 ret = signalfd_copyinfo(siginfo, &info);
220 if (ret < 0)
221 break;
222 siginfo++;
223 total += ret;
224 nonblock = 1;
225 } while (--count);
226
227 return total ? total: ret;
228}
229
230static const struct file_operations signalfd_fops = {
231 .release = signalfd_release,
232 .poll = signalfd_poll,
233 .read = signalfd_read,
234 .llseek = noop_llseek,
235};
236
237SYSCALL_DEFINE4(signalfd4, int, ufd, sigset_t __user *, user_mask,
238 size_t, sizemask, int, flags)
239{
240 sigset_t sigmask;
241 struct signalfd_ctx *ctx;
242
243
244 BUILD_BUG_ON(SFD_CLOEXEC != O_CLOEXEC);
245 BUILD_BUG_ON(SFD_NONBLOCK != O_NONBLOCK);
246
247 if (flags & ~(SFD_CLOEXEC | SFD_NONBLOCK))
248 return -EINVAL;
249
250 if (sizemask != sizeof(sigset_t) ||
251 copy_from_user(&sigmask, user_mask, sizeof(sigmask)))
252 return -EINVAL;
253 sigdelsetmask(&sigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
254 signotset(&sigmask);
255
256 if (ufd == -1) {
257 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
258 if (!ctx)
259 return -ENOMEM;
260
261 ctx->sigmask = sigmask;
262
263
264
265
266
267 ufd = anon_inode_getfd("[signalfd]", &signalfd_fops, ctx,
268 O_RDWR | (flags & (O_CLOEXEC | O_NONBLOCK)));
269 if (ufd < 0)
270 kfree(ctx);
271 } else {
272 struct fd f = fdget(ufd);
273 if (!f.file)
274 return -EBADF;
275 ctx = f.file->private_data;
276 if (f.file->f_op != &signalfd_fops) {
277 fdput(f);
278 return -EINVAL;
279 }
280 spin_lock_irq(¤t->sighand->siglock);
281 ctx->sigmask = sigmask;
282 spin_unlock_irq(¤t->sighand->siglock);
283
284 wake_up(¤t->sighand->signalfd_wqh);
285 fdput(f);
286 }
287
288 return ufd;
289}
290
291SYSCALL_DEFINE3(signalfd, int, ufd, sigset_t __user *, user_mask,
292 size_t, sizemask)
293{
294 return sys_signalfd4(ufd, user_mask, sizemask, 0);
295}
296