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 struct signalfd_ctx { 34 sigset_t sigmask; 35 }; 36 37 static int signalfd_release(struct inode *inode, struct file *file) 38 { 39 kfree(file->private_data); 40 return 0; 41 } 42 43 static 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, ¤t->sighand->signalfd_wqh, wait); 49 50 spin_lock_irq(¤t->sighand->siglock); 51 if (next_signal(¤t->pending, &ctx->sigmask) || 52 next_signal(¤t->signal->shared_pending, 53 &ctx->sigmask)) 54 events |= POLLIN; 55 spin_unlock_irq(¤t->sighand->siglock); 56 57 return events; 58 } 59 60 /* 61 * Copied from copy_siginfo_to_user() in kernel/signal.c 62 */ 63 static 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 #ifdef BUS_MCEERR_AO 103 /* 104 * Other callers might not initialize the si_lsb field, 105 * so check explicitly for the right codes here. 106 */ 107 if (kinfo->si_code == BUS_MCEERR_AR || 108 kinfo->si_code == BUS_MCEERR_AO) 109 err |= __put_user((short) kinfo->si_addr_lsb, 110 &uinfo->ssi_addr_lsb); 111 #endif 112 break; 113 case __SI_CHLD: 114 err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid); 115 err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid); 116 err |= __put_user(kinfo->si_status, &uinfo->ssi_status); 117 err |= __put_user(kinfo->si_utime, &uinfo->ssi_utime); 118 err |= __put_user(kinfo->si_stime, &uinfo->ssi_stime); 119 break; 120 case __SI_RT: /* This is not generated by the kernel as of now. */ 121 case __SI_MESGQ: /* But this is */ 122 err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid); 123 err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid); 124 err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr); 125 err |= __put_user(kinfo->si_int, &uinfo->ssi_int); 126 break; 127 default: 128 /* 129 * This case catches also the signals queued by sigqueue(). 130 */ 131 err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid); 132 err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid); 133 err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr); 134 err |= __put_user(kinfo->si_int, &uinfo->ssi_int); 135 break; 136 } 137 138 return err ? -EFAULT: sizeof(*uinfo); 139 } 140 141 static ssize_t signalfd_dequeue(struct signalfd_ctx *ctx, siginfo_t *info, 142 int nonblock) 143 { 144 ssize_t ret; 145 DECLARE_WAITQUEUE(wait, current); 146 147 spin_lock_irq(¤t->sighand->siglock); 148 ret = dequeue_signal(current, &ctx->sigmask, info); 149 switch (ret) { 150 case 0: 151 if (!nonblock) 152 break; 153 ret = -EAGAIN; 154 default: 155 spin_unlock_irq(¤t->sighand->siglock); 156 return ret; 157 } 158 159 add_wait_queue(¤t->sighand->signalfd_wqh, &wait); 160 for (;;) { 161 set_current_state(TASK_INTERRUPTIBLE); 162 ret = dequeue_signal(current, &ctx->sigmask, info); 163 if (ret != 0) 164 break; 165 if (signal_pending(current)) { 166 ret = -ERESTARTSYS; 167 break; 168 } 169 spin_unlock_irq(¤t->sighand->siglock); 170 schedule(); 171 spin_lock_irq(¤t->sighand->siglock); 172 } 173 spin_unlock_irq(¤t->sighand->siglock); 174 175 remove_wait_queue(¤t->sighand->signalfd_wqh, &wait); 176 __set_current_state(TASK_RUNNING); 177 178 return ret; 179 } 180 181 /* 182 * Returns a multiple of the size of a "struct signalfd_siginfo", or a negative 183 * error code. The "count" parameter must be at least the size of a 184 * "struct signalfd_siginfo". 185 */ 186 static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count, 187 loff_t *ppos) 188 { 189 struct signalfd_ctx *ctx = file->private_data; 190 struct signalfd_siginfo __user *siginfo; 191 int nonblock = file->f_flags & O_NONBLOCK; 192 ssize_t ret, total = 0; 193 siginfo_t info; 194 195 count /= sizeof(struct signalfd_siginfo); 196 if (!count) 197 return -EINVAL; 198 199 siginfo = (struct signalfd_siginfo __user *) buf; 200 do { 201 ret = signalfd_dequeue(ctx, &info, nonblock); 202 if (unlikely(ret <= 0)) 203 break; 204 ret = signalfd_copyinfo(siginfo, &info); 205 if (ret < 0) 206 break; 207 siginfo++; 208 total += ret; 209 nonblock = 1; 210 } while (--count); 211 212 return total ? total: ret; 213 } 214 215 static const struct file_operations signalfd_fops = { 216 .release = signalfd_release, 217 .poll = signalfd_poll, 218 .read = signalfd_read, 219 .llseek = noop_llseek, 220 }; 221 222 SYSCALL_DEFINE4(signalfd4, int, ufd, sigset_t __user *, user_mask, 223 size_t, sizemask, int, flags) 224 { 225 sigset_t sigmask; 226 struct signalfd_ctx *ctx; 227 228 /* Check the SFD_* constants for consistency. */ 229 BUILD_BUG_ON(SFD_CLOEXEC != O_CLOEXEC); 230 BUILD_BUG_ON(SFD_NONBLOCK != O_NONBLOCK); 231 232 if (flags & ~(SFD_CLOEXEC | SFD_NONBLOCK)) 233 return -EINVAL; 234 235 if (sizemask != sizeof(sigset_t) || 236 copy_from_user(&sigmask, user_mask, sizeof(sigmask))) 237 return -EINVAL; 238 sigdelsetmask(&sigmask, sigmask(SIGKILL) | sigmask(SIGSTOP)); 239 signotset(&sigmask); 240 241 if (ufd == -1) { 242 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); 243 if (!ctx) 244 return -ENOMEM; 245 246 ctx->sigmask = sigmask; 247 248 /* 249 * When we call this, the initialization must be complete, since 250 * anon_inode_getfd() will install the fd. 251 */ 252 ufd = anon_inode_getfd("[signalfd]", &signalfd_fops, ctx, 253 O_RDWR | (flags & (O_CLOEXEC | O_NONBLOCK))); 254 if (ufd < 0) 255 kfree(ctx); 256 } else { 257 struct file *file = fget(ufd); 258 if (!file) 259 return -EBADF; 260 ctx = file->private_data; 261 if (file->f_op != &signalfd_fops) { 262 fput(file); 263 return -EINVAL; 264 } 265 spin_lock_irq(¤t->sighand->siglock); 266 ctx->sigmask = sigmask; 267 spin_unlock_irq(¤t->sighand->siglock); 268 269 wake_up(¤t->sighand->signalfd_wqh); 270 fput(file); 271 } 272 273 return ufd; 274 } 275 276 SYSCALL_DEFINE3(signalfd, int, ufd, sigset_t __user *, user_mask, 277 size_t, sizemask) 278 { 279 return sys_signalfd4(ufd, user_mask, sizemask, 0); 280 } 281