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, ¤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 * 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(¤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 * 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 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 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 } 296