Btrfs: fix space leak when we fail to reserve metadata space
[linux-2.6.git] / fs / signalfd.c
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
33 void signalfd_cleanup(struct sighand_struct *sighand)
34 {
35         wait_queue_head_t *wqh = &sighand->signalfd_wqh;
36         /*
37          * The lockless check can race with remove_wait_queue() in progress,
38          * but in this case its caller should run under rcu_read_lock() and
39          * sighand_cachep is SLAB_DESTROY_BY_RCU, we can safely return.
40          */
41         if (likely(!waitqueue_active(wqh)))
42                 return;
43
44         /* wait_queue_t->func(POLLFREE) should do remove_wait_queue() */
45         wake_up_poll(wqh, POLLHUP | POLLFREE);
46 }
47
48 struct signalfd_ctx {
49         sigset_t sigmask;
50 };
51
52 static int signalfd_release(struct inode *inode, struct file *file)
53 {
54         kfree(file->private_data);
55         return 0;
56 }
57
58 static 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, &current->sighand->signalfd_wqh, wait);
64
65         spin_lock_irq(&current->sighand->siglock);
66         if (next_signal(&current->pending, &ctx->sigmask) ||
67             next_signal(&current->signal->shared_pending,
68                         &ctx->sigmask))
69                 events |= POLLIN;
70         spin_unlock_irq(&current->sighand->siglock);
71
72         return events;
73 }
74
75 /*
76  * Copied from copy_siginfo_to_user() in kernel/signal.c
77  */
78 static 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          * Unused members should be zero ...
87          */
88         err = __clear_user(uinfo, sizeof(*uinfo));
89
90         /*
91          * If you change siginfo_t structure, please be sure
92          * this code is fixed accordingly.
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                  * Other callers might not initialize the si_lsb field,
120                  * so check explicitly for the right codes here.
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: /* This is not generated by the kernel as of now. */
136         case __SI_MESGQ: /* But this is */
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                  * This case catches also the signals queued by sigqueue().
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
156 static 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(&current->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(&current->sighand->siglock);
171                 return ret;
172         }
173
174         add_wait_queue(&current->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(&current->sighand->siglock);
185                 schedule();
186                 spin_lock_irq(&current->sighand->siglock);
187         }
188         spin_unlock_irq(&current->sighand->siglock);
189
190         remove_wait_queue(&current->sighand->signalfd_wqh, &wait);
191         __set_current_state(TASK_RUNNING);
192
193         return ret;
194 }
195
196 /*
197  * Returns a multiple of the size of a "struct signalfd_siginfo", or a negative
198  * error code. The "count" parameter must be at least the size of a
199  * "struct signalfd_siginfo".
200  */
201 static 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
230 static const struct file_operations signalfd_fops = {
231         .release        = signalfd_release,
232         .poll           = signalfd_poll,
233         .read           = signalfd_read,
234         .llseek         = noop_llseek,
235 };
236
237 SYSCALL_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         /* Check the SFD_* constants for consistency.  */
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                  * When we call this, the initialization must be complete, since
265                  * anon_inode_getfd() will install the fd.
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 file *file = fget(ufd);
273                 if (!file)
274                         return -EBADF;
275                 ctx = file->private_data;
276                 if (file->f_op != &signalfd_fops) {
277                         fput(file);
278                         return -EINVAL;
279                 }
280                 spin_lock_irq(&current->sighand->siglock);
281                 ctx->sigmask = sigmask;
282                 spin_unlock_irq(&current->sighand->siglock);
283
284                 wake_up(&current->sighand->signalfd_wqh);
285                 fput(file);
286         }
287
288         return ufd;
289 }
290
291 SYSCALL_DEFINE3(signalfd, int, ufd, sigset_t __user *, user_mask,
292                 size_t, sizemask)
293 {
294         return sys_signalfd4(ufd, user_mask, sizemask, 0);
295 }