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  */
  15
  16 #include <linux/file.h>
  17 #include <linux/poll.h>
  18 #include <linux/init.h>
  19 #include <linux/fs.h>
  20 #include <linux/sched.h>
  21 #include <linux/kernel.h>
  22 #include <linux/signal.h>
  23 #include <linux/list.h>
  24 #include <linux/anon_inodes.h>
  25 #include <linux/signalfd.h>
  26
  27 struct signalfd_ctx {
  28         struct list_head lnk;
  29         wait_queue_head_t wqh;
  30         sigset_t sigmask;
  31         struct task_struct *tsk;
  32 };
  33
  34 struct signalfd_lockctx {
  35         struct task_struct *tsk;
  36         unsigned long flags;
  37 };
  38
  39 /*
  40  * Tries to acquire the sighand lock. We do not increment the sighand
  41  * use count, and we do not even pin the task struct, so we need to
  42  * do it inside an RCU read lock, and we must be prepared for the
  43  * ctx->tsk going to NULL (in signalfd_deliver()), and for the sighand
  44  * being detached. We return 0 if the sighand has been detached, or
  45  * 1 if we were able to pin the sighand lock.
  46  */
  47 static int signalfd_lock(struct signalfd_ctx *ctx, struct signalfd_lockctx *lk)
  48 {
  49         struct sighand_struct *sighand = NULL;
  50
  51         rcu_read_lock();
  52         lk->tsk = rcu_dereference(ctx->tsk);
  53         if (likely(lk->tsk != NULL))
  54                 sighand = lock_task_sighand(lk->tsk, &lk->flags);
  55         rcu_read_unlock();
  56
  57         if (sighand && !ctx->tsk) {
  58                 unlock_task_sighand(lk->tsk, &lk->flags);
  59                 sighand = NULL;
  60         }
  61
  62         return sighand != NULL;
  63 }
  64
  65 static void signalfd_unlock(struct signalfd_lockctx *lk)
  66 {
  67         unlock_task_sighand(lk->tsk, &lk->flags);
  68 }
  69
  70 /*
  71  * This must be called with the sighand lock held.
  72  */
  73 void signalfd_deliver(struct task_struct *tsk, int sig)
  74 {
  75         struct sighand_struct *sighand = tsk->sighand;
  76         struct signalfd_ctx *ctx, *tmp;
  77
  78         BUG_ON(!sig);
  79         list_for_each_entry_safe(ctx, tmp, &sighand->signalfd_list, lnk) {
  80                 /*
  81                  * We use a negative signal value as a way to broadcast that the
  82                  * sighand has been orphaned, so that we can notify all the
  83                  * listeners about this. Remember the ctx->sigmask is inverted,
  84                  * so if the user is interested in a signal, that corresponding
  85                  * bit will be zero.
  86                  */
  87                 if (sig < 0) {
  88                         if (ctx->tsk == tsk) {
  89                                 ctx->tsk = NULL;
  90                                 list_del_init(&ctx->lnk);
  91                                 wake_up(&ctx->wqh);
  92                         }
  93                 } else {
  94                         if (!sigismember(&ctx->sigmask, sig))
  95                                 wake_up(&ctx->wqh);
  96                 }
  97         }
  98 }
  99
 100 static void signalfd_cleanup(struct signalfd_ctx *ctx)
 101 {
 102         struct signalfd_lockctx lk;
 103
 104         /*
 105          * This is tricky. If the sighand is gone, we do not need to remove
 106          * context from the list, the list itself won't be there anymore.
 107          */
 108         if (signalfd_lock(ctx, &lk)) {
 109                 list_del(&ctx->lnk);
 110                 signalfd_unlock(&lk);
 111         }
 112         kfree(ctx);
 113 }
 114
 115 static int signalfd_release(struct inode *inode, struct file *file)
 116 {
 117         signalfd_cleanup(file->private_data);
 118         return 0;
 119 }
 120
 121 static unsigned int signalfd_poll(struct file *file, poll_table *wait)
 122 {
 123         struct signalfd_ctx *ctx = file->private_data;
 124         unsigned int events = 0;
 125         struct signalfd_lockctx lk;
 126
 127         poll_wait(file, &ctx->wqh, wait);
 128
 129         /*
 130          * Let the caller get a POLLIN in this case, ala socket recv() when
 131          * the peer disconnects.
 132          */
 133         if (signalfd_lock(ctx, &lk)) {
 134                 if (next_signal(&lk.tsk->pending, &ctx->sigmask) > 0 ||
 135                     next_signal(&lk.tsk->signal->shared_pending,
 136                                 &ctx->sigmask) > 0)
 137                         events |= POLLIN;
 138                 signalfd_unlock(&lk);
 139         } else
 140                 events |= POLLIN;
 141
 142         return events;
 143 }
 144
 145 /*
 146  * Copied from copy_siginfo_to_user() in kernel/signal.c
 147  */
 148 static int signalfd_copyinfo(struct signalfd_siginfo __user *uinfo,
 149                              siginfo_t const *kinfo)
 150 {
 151         long err;
 152
 153         BUILD_BUG_ON(sizeof(struct signalfd_siginfo) != 128);
 154
 155         /*
 156          * Unused memebers should be zero ...
 157          */
 158         err = __clear_user(uinfo, sizeof(*uinfo));
 159
 160         /*
 161          * If you change siginfo_t structure, please be sure
 162          * this code is fixed accordingly.
 163          */
 164         err |= __put_user(kinfo->si_signo, &uinfo->signo);
 165         err |= __put_user(kinfo->si_errno, &uinfo->err);
 166         err |= __put_user((short)kinfo->si_code, &uinfo->code);
 167         switch (kinfo->si_code & __SI_MASK) {
 168         case __SI_KILL:
 169                 err |= __put_user(kinfo->si_pid, &uinfo->pid);
 170                 err |= __put_user(kinfo->si_uid, &uinfo->uid);
 171                 break;
 172         case __SI_TIMER:
 173                  err |= __put_user(kinfo->si_tid, &uinfo->tid);
 174                  err |= __put_user(kinfo->si_overrun, &uinfo->overrun);
 175                  err |= __put_user((long)kinfo->si_ptr, &uinfo->svptr);
 176                 break;
 177         case __SI_POLL:
 178                 err |= __put_user(kinfo->si_band, &uinfo->band);
 179                 err |= __put_user(kinfo->si_fd, &uinfo->fd);
 180                 break;
 181         case __SI_FAULT:
 182                 err |= __put_user((long)kinfo->si_addr, &uinfo->addr);
 183 #ifdef __ARCH_SI_TRAPNO
 184                 err |= __put_user(kinfo->si_trapno, &uinfo->trapno);
 185 #endif
 186                 break;
 187         case __SI_CHLD:
 188                 err |= __put_user(kinfo->si_pid, &uinfo->pid);
 189                 err |= __put_user(kinfo->si_uid, &uinfo->uid);
 190                 err |= __put_user(kinfo->si_status, &uinfo->status);
 191                 err |= __put_user(kinfo->si_utime, &uinfo->utime);
 192                 err |= __put_user(kinfo->si_stime, &uinfo->stime);
 193                 break;
 194         case __SI_RT: /* This is not generated by the kernel as of now. */
 195         case __SI_MESGQ: /* But this is */
 196                 err |= __put_user(kinfo->si_pid, &uinfo->pid);
 197                 err |= __put_user(kinfo->si_uid, &uinfo->uid);
 198                 err |= __put_user((long)kinfo->si_ptr, &uinfo->svptr);
 199                 break;
 200         default: /* this is just in case for now ... */
 201                 err |= __put_user(kinfo->si_pid, &uinfo->pid);
 202                 err |= __put_user(kinfo->si_uid, &uinfo->uid);
 203                 break;
 204         }
 205
 206         return err ? -EFAULT: sizeof(*uinfo);
 207 }
 208
 209 /*
 210  * Returns either the size of a "struct signalfd_siginfo", or zero if the
 211  * sighand we are attached to, has been orphaned. The "count" parameter
 212  * must be at least the size of a "struct signalfd_siginfo".
 213  */
 214 static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
 215                              loff_t *ppos)
 216 {
 217         struct signalfd_ctx *ctx = file->private_data;
 218         ssize_t res = 0;
 219         int locked, signo;
 220         siginfo_t info;
 221         struct signalfd_lockctx lk;
 222         DECLARE_WAITQUEUE(wait, current);
 223
 224         if (count < sizeof(struct signalfd_siginfo))
 225                 return -EINVAL;
 226         locked = signalfd_lock(ctx, &lk);
 227         if (!locked)
 228                 return 0;
 229         res = -EAGAIN;
 230         signo = dequeue_signal(lk.tsk, &ctx->sigmask, &info);
 231         if (signo == 0 && !(file->f_flags & O_NONBLOCK)) {
 232                 add_wait_queue(&ctx->wqh, &wait);
 233                 for (;;) {
 234                         set_current_state(TASK_INTERRUPTIBLE);
 235                         signo = dequeue_signal(lk.tsk, &ctx->sigmask, &info);
 236                         if (signo != 0)
 237                                 break;
 238                         if (signal_pending(current)) {
 239                                 res = -ERESTARTSYS;
 240                                 break;
 241                         }
 242                         signalfd_unlock(&lk);
 243                         schedule();
 244                         locked = signalfd_lock(ctx, &lk);
 245                         if (unlikely(!locked)) {
 246                                 /*
 247                                  * Let the caller read zero byte, ala socket
 248                                  * recv() when the peer disconnect. This test
 249                                  * must be done before doing a dequeue_signal(),
 250                                  * because if the sighand has been orphaned,
 251                                  * the dequeue_signal() call is going to crash.
 252                                  */
 253                                 res = 0;
 254                                 break;
 255                         }
 256                 }
 257                 remove_wait_queue(&ctx->wqh, &wait);
 258                 __set_current_state(TASK_RUNNING);
 259         }
 260         if (likely(locked))
 261                 signalfd_unlock(&lk);
 262         if (likely(signo))
 263                 res = signalfd_copyinfo((struct signalfd_siginfo __user *) buf,
 264                                         &info);
 265
 266         return res;
 267 }
 268
 269 static const struct file_operations signalfd_fops = {
 270         .release        = signalfd_release,
 271         .poll           = signalfd_poll,
 272         .read           = signalfd_read,
 273 };
 274
 275 /*
 276  * Create a file descriptor that is associated with our signal
 277  * state. We can pass it around to others if we want to, but
 278  * it will always be _our_ signal state.
 279  */
 280 asmlinkage long sys_signalfd(int ufd, sigset_t __user *user_mask, size_t sizemask)
 281 {
 282         int error;
 283         sigset_t sigmask;
 284         struct signalfd_ctx *ctx;
 285         struct sighand_struct *sighand;
 286         struct file *file;
 287         struct inode *inode;
 288         struct signalfd_lockctx lk;
 289
 290         if (sizemask != sizeof(sigset_t) ||
 291             copy_from_user(&sigmask, user_mask, sizeof(sigmask)))
 292                 return error = -EINVAL;
 293         sigdelsetmask(&sigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
 294         signotset(&sigmask);
 295
 296         if (ufd == -1) {
 297                 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
 298                 if (!ctx)
 299                         return -ENOMEM;
 300
 301                 init_waitqueue_head(&ctx->wqh);
 302                 ctx->sigmask = sigmask;
 303                 ctx->tsk = current;
 304
 305                 sighand = current->sighand;
 306                 /*
 307                  * Add this fd to the list of signal listeners.
 308                  */
 309                 spin_lock_irq(&sighand->siglock);
 310                 list_add_tail(&ctx->lnk, &sighand->signalfd_list);
 311                 spin_unlock_irq(&sighand->siglock);
 312
 313                 /*
 314                  * When we call this, the initialization must be complete, since
 315                  * anon_inode_getfd() will install the fd.
 316                  */
 317                 error = anon_inode_getfd(&ufd, &inode, &file, "[signalfd]",
 318                                          &signalfd_fops, ctx);
 319                 if (error)
 320                         goto err_fdalloc;
 321         } else {
 322                 file = fget(ufd);
 323                 if (!file)
 324                         return -EBADF;
 325                 ctx = file->private_data;
 326                 if (file->f_op != &signalfd_fops) {
 327                         fput(file);
 328                         return -EINVAL;
 329                 }
 330                 /*
 331                  * We need to be prepared of the fact that the sighand this fd
 332                  * is attached to, has been detched. In that case signalfd_lock()
 333                  * will return 0, and we'll just skip setting the new mask.
 334                  */
 335                 if (signalfd_lock(ctx, &lk)) {
 336                         ctx->sigmask = sigmask;
 337                         signalfd_unlock(&lk);
 338                 }
 339                 wake_up(&ctx->wqh);
 340                 fput(file);
 341         }
 342
 343         return ufd;
 344
 345 err_fdalloc:
 346         signalfd_cleanup(ctx);
 347         return error;
 348 }
 349