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