Branch data Line data Source code
1 : : /*
2 : : * fs/signalfd.c
3 : : *
4 : : * Copyright (C) 2003 Linus Torvalds
5 : : *
6 : : * Mon Mar 5, 2007: Davide Libenzi <davidel@xmailserver.org>
7 : : * Changed ->read() to return a siginfo strcture instead of signal number.
8 : : * Fixed locking in ->poll().
9 : : * Added sighand-detach notification.
10 : : * Added fd re-use in sys_signalfd() syscall.
11 : : * Now using anonymous inode source.
12 : : * Thanks to Oleg Nesterov for useful code review and suggestions.
13 : : * More comments and suggestions from Arnd Bergmann.
14 : : * Sat May 19, 2007: Davi E. M. Arnaut <davi@haxent.com.br>
15 : : * Retrieve multiple signals with one read() call
16 : : * Sun Jul 15, 2007: Davide Libenzi <davidel@xmailserver.org>
17 : : * Attach to the sighand only during read() and poll().
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 : : #include <linux/proc_fs.h>
33 : : #include <linux/compat.h>
34 : :
35 : 0 : void signalfd_cleanup(struct sighand_struct *sighand)
36 : : {
37 : 1101981 : wait_queue_head_t *wqh = &sighand->signalfd_wqh;
38 : : /*
39 : : * The lockless check can race with remove_wait_queue() in progress,
40 : : * but in this case its caller should run under rcu_read_lock() and
41 : : * sighand_cachep is SLAB_DESTROY_BY_RCU, we can safely return.
42 : : */
43 [ - + ]: 1101981 : if (likely(!waitqueue_active(wqh)))
44 : 0 : return;
45 : :
46 : : /* wait_queue_t->func(POLLFREE) should do remove_wait_queue() */
47 : 0 : wake_up_poll(wqh, POLLHUP | POLLFREE);
48 : : }
49 : :
50 : : struct signalfd_ctx {
51 : : sigset_t sigmask;
52 : : };
53 : :
54 : 0 : static int signalfd_release(struct inode *inode, struct file *file)
55 : : {
56 : 5 : kfree(file->private_data);
57 : 5 : return 0;
58 : : }
59 : :
60 : 0 : static unsigned int signalfd_poll(struct file *file, poll_table *wait)
61 : : {
62 : 56 : struct signalfd_ctx *ctx = file->private_data;
63 : : unsigned int events = 0;
64 : :
65 : 56 : poll_wait(file, ¤t->sighand->signalfd_wqh, wait);
66 : :
67 : 56 : spin_lock_irq(¤t->sighand->siglock);
68 [ + - + + ]: 112 : if (next_signal(¤t->pending, &ctx->sigmask) ||
69 : 56 : next_signal(¤t->signal->shared_pending,
70 : : &ctx->sigmask))
71 : : events |= POLLIN;
72 : 56 : spin_unlock_irq(¤t->sighand->siglock);
73 : :
74 : 56 : return events;
75 : : }
76 : :
77 : : /*
78 : : * Copied from copy_siginfo_to_user() in kernel/signal.c
79 : : */
80 : 0 : static int signalfd_copyinfo(struct signalfd_siginfo __user *uinfo,
81 : : siginfo_t const *kinfo)
82 : : {
83 : : long err;
84 : :
85 : : BUILD_BUG_ON(sizeof(struct signalfd_siginfo) != 128);
86 : :
87 : : /*
88 : : * Unused members should be zero ...
89 : : */
90 : 29 : err = __clear_user(uinfo, sizeof(*uinfo));
91 : :
92 : : /*
93 : : * If you change siginfo_t structure, please be sure
94 : : * this code is fixed accordingly.
95 : : */
96 : 29 : err |= __put_user(kinfo->si_signo, &uinfo->ssi_signo);
97 : 29 : err |= __put_user(kinfo->si_errno, &uinfo->ssi_errno);
98 : 29 : err |= __put_user((short) kinfo->si_code, &uinfo->ssi_code);
99 [ + - - - : 29 : switch (kinfo->si_code & __SI_MASK) {
+ - - ]
100 : : case __SI_KILL:
101 : 2 : err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
102 : 2 : err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
103 : 2 : break;
104 : : case __SI_TIMER:
105 : 0 : err |= __put_user(kinfo->si_tid, &uinfo->ssi_tid);
106 : 0 : err |= __put_user(kinfo->si_overrun, &uinfo->ssi_overrun);
107 : 0 : err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
108 : 0 : err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
109 : 0 : break;
110 : : case __SI_POLL:
111 : 0 : err |= __put_user(kinfo->si_band, &uinfo->ssi_band);
112 : 0 : err |= __put_user(kinfo->si_fd, &uinfo->ssi_fd);
113 : 0 : break;
114 : : case __SI_FAULT:
115 : 0 : err |= __put_user((long) kinfo->si_addr, &uinfo->ssi_addr);
116 : : #ifdef __ARCH_SI_TRAPNO
117 : : err |= __put_user(kinfo->si_trapno, &uinfo->ssi_trapno);
118 : : #endif
119 : : #ifdef BUS_MCEERR_AO
120 : : /*
121 : : * Other callers might not initialize the si_lsb field,
122 : : * so check explicitly for the right codes here.
123 : : */
124 [ # # ]: 0 : if (kinfo->si_code == BUS_MCEERR_AR ||
125 : : kinfo->si_code == BUS_MCEERR_AO)
126 : 0 : err |= __put_user((short) kinfo->si_addr_lsb,
127 : : &uinfo->ssi_addr_lsb);
128 : : #endif
129 : : break;
130 : : case __SI_CHLD:
131 : 27 : err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
132 : 27 : err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
133 : 27 : err |= __put_user(kinfo->si_status, &uinfo->ssi_status);
134 : 27 : err |= __put_user(kinfo->si_utime, &uinfo->ssi_utime);
135 : 27 : err |= __put_user(kinfo->si_stime, &uinfo->ssi_stime);
136 : 27 : break;
137 : : case __SI_RT: /* This is not generated by the kernel as of now. */
138 : : case __SI_MESGQ: /* But this is */
139 : 0 : err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
140 : 0 : err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
141 : 0 : err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
142 : 0 : err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
143 : 0 : break;
144 : : default:
145 : : /*
146 : : * This case catches also the signals queued by sigqueue().
147 : : */
148 : 0 : err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
149 : 0 : err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
150 : 0 : err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
151 : 0 : err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
152 : 0 : break;
153 : : }
154 : :
155 [ + - ]: 29 : return err ? -EFAULT: sizeof(*uinfo);
156 : : }
157 : :
158 : 0 : static ssize_t signalfd_dequeue(struct signalfd_ctx *ctx, siginfo_t *info,
159 : : int nonblock)
160 : : {
161 : : ssize_t ret;
162 : 58 : DECLARE_WAITQUEUE(wait, current);
163 : :
164 : 29 : spin_lock_irq(¤t->sighand->siglock);
165 : 29 : ret = dequeue_signal(current, &ctx->sigmask, info);
166 [ - + ]: 29 : switch (ret) {
167 : : case 0:
168 [ # # ]: 0 : if (!nonblock)
169 : : break;
170 : : ret = -EAGAIN;
171 : : default:
172 : 29 : spin_unlock_irq(¤t->sighand->siglock);
173 : 29 : return ret;
174 : : }
175 : :
176 : 0 : add_wait_queue(¤t->sighand->signalfd_wqh, &wait);
177 : : for (;;) {
178 : 0 : set_current_state(TASK_INTERRUPTIBLE);
179 : 0 : ret = dequeue_signal(current, &ctx->sigmask, info);
180 [ # # ]: 0 : if (ret != 0)
181 : : break;
182 [ # # ]: 0 : if (signal_pending(current)) {
183 : : ret = -ERESTARTSYS;
184 : : break;
185 : : }
186 : 0 : spin_unlock_irq(¤t->sighand->siglock);
187 : 0 : schedule();
188 : 0 : spin_lock_irq(¤t->sighand->siglock);
189 : : }
190 : 0 : spin_unlock_irq(¤t->sighand->siglock);
191 : :
192 : 0 : remove_wait_queue(¤t->sighand->signalfd_wqh, &wait);
193 : 0 : __set_current_state(TASK_RUNNING);
194 : :
195 : 0 : return ret;
196 : : }
197 : :
198 : : /*
199 : : * Returns a multiple of the size of a "struct signalfd_siginfo", or a negative
200 : : * error code. The "count" parameter must be at least the size of a
201 : : * "struct signalfd_siginfo".
202 : : */
203 : 0 : static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
204 : : loff_t *ppos)
205 : : {
206 : 29 : struct signalfd_ctx *ctx = file->private_data;
207 : : struct signalfd_siginfo __user *siginfo;
208 : 29 : int nonblock = file->f_flags & O_NONBLOCK;
209 : : ssize_t ret, total = 0;
210 : : siginfo_t info;
211 : :
212 : 29 : count /= sizeof(struct signalfd_siginfo);
213 [ + - ]: 29 : if (!count)
214 : : return -EINVAL;
215 : :
216 : : siginfo = (struct signalfd_siginfo __user *) buf;
217 : : do {
218 : 29 : ret = signalfd_dequeue(ctx, &info, nonblock);
219 [ + - ]: 29 : if (unlikely(ret <= 0))
220 : : break;
221 : 29 : ret = signalfd_copyinfo(siginfo, &info);
222 [ + - ]: 29 : if (ret < 0)
223 : : break;
224 : 29 : siginfo++;
225 : 29 : total += ret;
226 : : nonblock = 1;
227 [ - + ]: 29 : } while (--count);
228 : :
229 [ - + ]: 29 : return total ? total: ret;
230 : : }
231 : :
232 : : #ifdef CONFIG_PROC_FS
233 : 0 : static int signalfd_show_fdinfo(struct seq_file *m, struct file *f)
234 : : {
235 : 12 : struct signalfd_ctx *ctx = f->private_data;
236 : : sigset_t sigmask;
237 : :
238 : 12 : sigmask = ctx->sigmask;
239 : : signotset(&sigmask);
240 : 12 : render_sigset_t(m, "sigmask:\t", &sigmask);
241 : :
242 : 12 : return 0;
243 : : }
244 : : #endif
245 : :
246 : : static const struct file_operations signalfd_fops = {
247 : : #ifdef CONFIG_PROC_FS
248 : : .show_fdinfo = signalfd_show_fdinfo,
249 : : #endif
250 : : .release = signalfd_release,
251 : : .poll = signalfd_poll,
252 : : .read = signalfd_read,
253 : : .llseek = noop_llseek,
254 : : };
255 : :
256 : 0 : SYSCALL_DEFINE4(signalfd4, int, ufd, sigset_t __user *, user_mask,
257 : : size_t, sizemask, int, flags)
258 : : {
259 : : sigset_t sigmask;
260 : : struct signalfd_ctx *ctx;
261 : :
262 : : /* Check the SFD_* constants for consistency. */
263 : : BUILD_BUG_ON(SFD_CLOEXEC != O_CLOEXEC);
264 : : BUILD_BUG_ON(SFD_NONBLOCK != O_NONBLOCK);
265 : :
266 [ + - ]: 6 : if (flags & ~(SFD_CLOEXEC | SFD_NONBLOCK))
267 : : return -EINVAL;
268 : :
269 [ + - ][ + - ]: 12 : if (sizemask != sizeof(sigset_t) ||
270 : : copy_from_user(&sigmask, user_mask, sizeof(sigmask)))
271 : : return -EINVAL;
272 : : sigdelsetmask(&sigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
273 : : signotset(&sigmask);
274 : :
275 [ + + ]: 6 : if (ufd == -1) {
276 : : ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
277 [ + - ]: 5 : if (!ctx)
278 : : return -ENOMEM;
279 : :
280 : 5 : ctx->sigmask = sigmask;
281 : :
282 : : /*
283 : : * When we call this, the initialization must be complete, since
284 : : * anon_inode_getfd() will install the fd.
285 : : */
286 : 5 : ufd = anon_inode_getfd("[signalfd]", &signalfd_fops, ctx,
287 : 5 : O_RDWR | (flags & (O_CLOEXEC | O_NONBLOCK)));
288 [ - + ]: 5 : if (ufd < 0)
289 : 0 : kfree(ctx);
290 : : } else {
291 : 1 : struct fd f = fdget(ufd);
292 [ + - ]: 1 : if (!f.file)
293 : : return -EBADF;
294 : 1 : ctx = f.file->private_data;
295 [ - + ]: 1 : if (f.file->f_op != &signalfd_fops) {
296 : : fdput(f);
297 : : return -EINVAL;
298 : : }
299 : 1 : spin_lock_irq(¤t->sighand->siglock);
300 : 1 : ctx->sigmask = sigmask;
301 : 1 : spin_unlock_irq(¤t->sighand->siglock);
302 : :
303 : 1 : wake_up(¤t->sighand->signalfd_wqh);
304 : : fdput(f);
305 : : }
306 : :
307 : : return ufd;
308 : : }
309 : :
310 : 0 : SYSCALL_DEFINE3(signalfd, int, ufd, sigset_t __user *, user_mask,
311 : : size_t, sizemask)
312 : : {
313 : 0 : return sys_signalfd4(ufd, user_mask, sizemask, 0);
314 : : }
315 : :
316 : : #ifdef CONFIG_COMPAT
317 : : COMPAT_SYSCALL_DEFINE4(signalfd4, int, ufd,
318 : : const compat_sigset_t __user *,sigmask,
319 : : compat_size_t, sigsetsize,
320 : : int, flags)
321 : : {
322 : : compat_sigset_t ss32;
323 : : sigset_t tmp;
324 : : sigset_t __user *ksigmask;
325 : :
326 : : if (sigsetsize != sizeof(compat_sigset_t))
327 : : return -EINVAL;
328 : : if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
329 : : return -EFAULT;
330 : : sigset_from_compat(&tmp, &ss32);
331 : : ksigmask = compat_alloc_user_space(sizeof(sigset_t));
332 : : if (copy_to_user(ksigmask, &tmp, sizeof(sigset_t)))
333 : : return -EFAULT;
334 : :
335 : : return sys_signalfd4(ufd, ksigmask, sizeof(sigset_t), flags);
336 : : }
337 : :
338 : : COMPAT_SYSCALL_DEFINE3(signalfd, int, ufd,
339 : : const compat_sigset_t __user *,sigmask,
340 : : compat_size_t, sigsetsize)
341 : : {
342 : : return compat_sys_signalfd4(ufd, sigmask, sigsetsize, 0);
343 : : }
344 : : #endif
|
