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
33struct signalfd_ctx {
34	sigset_t sigmask;
35};
36
37static int signalfd_release(struct inode *inode, struct file *file)
38{
39	kfree(file->private_data);
40	return 0;
41}
42
43static unsigned int signalfd_poll(struct file *file, poll_table *wait)
44{
45	struct signalfd_ctx *ctx = file->private_data;
46	unsigned int events = 0;
47
48	poll_wait(file, &current->sighand->signalfd_wqh, wait);
49
50	spin_lock_irq(&current->sighand->siglock);
51	if (next_signal(&current->pending, &ctx->sigmask) ||
52	    next_signal(&current->signal->shared_pending,
53			&ctx->sigmask))
54		events |= POLLIN;
55	spin_unlock_irq(&current->sighand->siglock);
56
57	return events;
58}
59
60/*
61 * Copied from copy_siginfo_to_user() in kernel/signal.c
62 */
63static int signalfd_copyinfo(struct signalfd_siginfo __user *uinfo,
64			     siginfo_t const *kinfo)
65{
66	long err;
67
68	BUILD_BUG_ON(sizeof(struct signalfd_siginfo) != 128);
69
70	/*
71	 * Unused members should be zero ...
72	 */
73	err = __clear_user(uinfo, sizeof(*uinfo));
74
75	/*
76	 * If you change siginfo_t structure, please be sure
77	 * this code is fixed accordingly.
78	 */
79	err |= __put_user(kinfo->si_signo, &uinfo->ssi_signo);
80	err |= __put_user(kinfo->si_errno, &uinfo->ssi_errno);
81	err |= __put_user((short) kinfo->si_code, &uinfo->ssi_code);
82	switch (kinfo->si_code & __SI_MASK) {
83	case __SI_KILL:
84		err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
85		err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
86		break;
87	case __SI_TIMER:
88		 err |= __put_user(kinfo->si_tid, &uinfo->ssi_tid);
89		 err |= __put_user(kinfo->si_overrun, &uinfo->ssi_overrun);
90		 err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
91		 err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
92		break;
93	case __SI_POLL:
94		err |= __put_user(kinfo->si_band, &uinfo->ssi_band);
95		err |= __put_user(kinfo->si_fd, &uinfo->ssi_fd);
96		break;
97	case __SI_FAULT:
98		err |= __put_user((long) kinfo->si_addr, &uinfo->ssi_addr);
99#ifdef __ARCH_SI_TRAPNO
100		err |= __put_user(kinfo->si_trapno, &uinfo->ssi_trapno);
101#endif
102		break;
103	case __SI_CHLD:
104		err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
105		err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
106		err |= __put_user(kinfo->si_status, &uinfo->ssi_status);
107		err |= __put_user(kinfo->si_utime, &uinfo->ssi_utime);
108		err |= __put_user(kinfo->si_stime, &uinfo->ssi_stime);
109		break;
110	case __SI_RT: /* This is not generated by the kernel as of now. */
111	case __SI_MESGQ: /* But this is */
112		err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
113		err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
114		err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
115		err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
116		break;
117	default:
118		/*
119		 * This case catches also the signals queued by sigqueue().
120		 */
121		err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
122		err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
123		err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
124		err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
125		break;
126	}
127
128	return err ? -EFAULT: sizeof(*uinfo);
129}
130
131static ssize_t signalfd_dequeue(struct signalfd_ctx *ctx, siginfo_t *info,
132				int nonblock)
133{
134	ssize_t ret;
135	DECLARE_WAITQUEUE(wait, current);
136
137	spin_lock_irq(&current->sighand->siglock);
138	ret = dequeue_signal(current, &ctx->sigmask, info);
139	switch (ret) {
140	case 0:
141		if (!nonblock)
142			break;
143		ret = -EAGAIN;
144	default:
145		spin_unlock_irq(&current->sighand->siglock);
146		return ret;
147	}
148
149	add_wait_queue(&current->sighand->signalfd_wqh, &wait);
150	for (;;) {
151		set_current_state(TASK_INTERRUPTIBLE);
152		ret = dequeue_signal(current, &ctx->sigmask, info);
153		if (ret != 0)
154			break;
155		if (signal_pending(current)) {
156			ret = -ERESTARTSYS;
157			break;
158		}
159		spin_unlock_irq(&current->sighand->siglock);
160		schedule();
161		spin_lock_irq(&current->sighand->siglock);
162	}
163	spin_unlock_irq(&current->sighand->siglock);
164
165	remove_wait_queue(&current->sighand->signalfd_wqh, &wait);
166	__set_current_state(TASK_RUNNING);
167
168	return ret;
169}
170
171/*
172 * Returns a multiple of the size of a "struct signalfd_siginfo", or a negative
173 * error code. The "count" parameter must be at least the size of a
174 * "struct signalfd_siginfo".
175 */
176static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
177			     loff_t *ppos)
178{
179	struct signalfd_ctx *ctx = file->private_data;
180	struct signalfd_siginfo __user *siginfo;
181	int nonblock = file->f_flags & O_NONBLOCK;
182	ssize_t ret, total = 0;
183	siginfo_t info;
184
185	count /= sizeof(struct signalfd_siginfo);
186	if (!count)
187		return -EINVAL;
188
189	siginfo = (struct signalfd_siginfo __user *) buf;
190	do {
191		ret = signalfd_dequeue(ctx, &info, nonblock);
192		if (unlikely(ret <= 0))
193			break;
194		ret = signalfd_copyinfo(siginfo, &info);
195		if (ret < 0)
196			break;
197		siginfo++;
198		total += ret;
199		nonblock = 1;
200	} while (--count);
201
202	return total ? total: ret;
203}
204
205static const struct file_operations signalfd_fops = {
206	.release	= signalfd_release,
207	.poll		= signalfd_poll,
208	.read		= signalfd_read,
209};
210
211SYSCALL_DEFINE4(signalfd4, int, ufd, sigset_t __user *, user_mask,
212		size_t, sizemask, int, flags)
213{
214	sigset_t sigmask;
215	struct signalfd_ctx *ctx;
216
217	/* Check the SFD_* constants for consistency.  */
218	BUILD_BUG_ON(SFD_CLOEXEC != O_CLOEXEC);
219	BUILD_BUG_ON(SFD_NONBLOCK != O_NONBLOCK);
220
221	if (flags & ~(SFD_CLOEXEC | SFD_NONBLOCK))
222		return -EINVAL;
223
224	if (sizemask != sizeof(sigset_t) ||
225	    copy_from_user(&sigmask, user_mask, sizeof(sigmask)))
226		return -EINVAL;
227	sigdelsetmask(&sigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
228	signotset(&sigmask);
229
230	if (ufd == -1) {
231		ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
232		if (!ctx)
233			return -ENOMEM;
234
235		ctx->sigmask = sigmask;
236
237		/*
238		 * When we call this, the initialization must be complete, since
239		 * anon_inode_getfd() will install the fd.
240		 */
241		ufd = anon_inode_getfd("[signalfd]", &signalfd_fops, ctx,
242				       O_RDWR | (flags & (O_CLOEXEC | O_NONBLOCK)));
243		if (ufd < 0)
244			kfree(ctx);
245	} else {
246		struct file *file = fget(ufd);
247		if (!file)
248			return -EBADF;
249		ctx = file->private_data;
250		if (file->f_op != &signalfd_fops) {
251			fput(file);
252			return -EINVAL;
253		}
254		spin_lock_irq(&current->sighand->siglock);
255		ctx->sigmask = sigmask;
256		spin_unlock_irq(&current->sighand->siglock);
257
258		wake_up(&current->sighand->signalfd_wqh);
259		fput(file);
260	}
261
262	return ufd;
263}
264
265SYSCALL_DEFINE3(signalfd, int, ufd, sigset_t __user *, user_mask,
266		size_t, sizemask)
267{
268	return sys_signalfd4(ufd, user_mask, sizemask, 0);
269}
270