fuse: Freeze client on suspend when request sent to userspace
[linux-3.10.git] / fs / eventpoll.c
index ca30007..deecc72 100644 (file)
 #include <linux/bitops.h>
 #include <linux/mutex.h>
 #include <linux/anon_inodes.h>
+#include <linux/device.h>
 #include <asm/uaccess.h>
-#include <asm/system.h>
 #include <asm/io.h>
 #include <asm/mman.h>
 #include <linux/atomic.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <linux/compat.h>
 
 /*
  * LOCKING:
@@ -88,7 +91,7 @@
  */
 
 /* Epoll private bits inside the event mask */
-#define EP_PRIVATE_BITS (EPOLLONESHOT | EPOLLET)
+#define EP_PRIVATE_BITS (EPOLLWAKEUP | EPOLLONESHOT | EPOLLET)
 
 /* Maximum number of nesting allowed inside epoll sets */
 #define EP_MAX_NESTS 4
 struct epoll_filefd {
        struct file *file;
        int fd;
-};
+} __packed;
 
 /*
  * Structure used to track possible nested calls, for too deep recursions
@@ -126,6 +129,8 @@ struct nested_calls {
 /*
  * Each file descriptor added to the eventpoll interface will
  * have an entry of this type linked to the "rbr" RB tree.
+ * Avoid increasing the size of this struct, there can be many thousands
+ * of these on a server and we do not want this to take another cache line.
  */
 struct epitem {
        /* RB tree node used to link this structure to the eventpoll RB tree */
@@ -155,6 +160,9 @@ struct epitem {
        /* List header used to link this item to the "struct file" items list */
        struct list_head fllink;
 
+       /* wakeup_source used when EPOLLWAKEUP is set */
+       struct wakeup_source __rcu *ws;
+
        /* The structure that describe the interested events and the source fd */
        struct epoll_event event;
 };
@@ -195,6 +203,9 @@ struct eventpoll {
         */
        struct epitem *ovflist;
 
+       /* wakeup_source used when ep_scan_ready_list is running */
+       struct wakeup_source *ws;
+
        /* The user that created the eventpoll descriptor */
        struct user_struct *user;
 
@@ -427,6 +438,31 @@ out_unlock:
        return error;
 }
 
+/*
+ * As described in commit 0ccf831cb lockdep: annotate epoll
+ * the use of wait queues used by epoll is done in a very controlled
+ * manner. Wake ups can nest inside each other, but are never done
+ * with the same locking. For example:
+ *
+ *   dfd = socket(...);
+ *   efd1 = epoll_create();
+ *   efd2 = epoll_create();
+ *   epoll_ctl(efd1, EPOLL_CTL_ADD, dfd, ...);
+ *   epoll_ctl(efd2, EPOLL_CTL_ADD, efd1, ...);
+ *
+ * When a packet arrives to the device underneath "dfd", the net code will
+ * issue a wake_up() on its poll wake list. Epoll (efd1) has installed a
+ * callback wakeup entry on that queue, and the wake_up() performed by the
+ * "dfd" net code will end up in ep_poll_callback(). At this point epoll
+ * (efd1) notices that it may have some event ready, so it needs to wake up
+ * the waiters on its poll wait list (efd2). So it calls ep_poll_safewake()
+ * that ends up in another wake_up(), after having checked about the
+ * recursion constraints. That are, no more than EP_MAX_POLLWAKE_NESTS, to
+ * avoid stack blasting.
+ *
+ * When CONFIG_DEBUG_LOCK_ALLOC is enabled, make sure lockdep can handle
+ * this special case of epoll.
+ */
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 static inline void ep_wake_up_nested(wait_queue_head_t *wqueue,
                                     unsigned long events, int subclass)
@@ -503,6 +539,38 @@ static void ep_unregister_pollwait(struct eventpoll *ep, struct epitem *epi)
        }
 }
 
+/* call only when ep->mtx is held */
+static inline struct wakeup_source *ep_wakeup_source(struct epitem *epi)
+{
+       return rcu_dereference_check(epi->ws, lockdep_is_held(&epi->ep->mtx));
+}
+
+/* call only when ep->mtx is held */
+static inline void ep_pm_stay_awake(struct epitem *epi)
+{
+       struct wakeup_source *ws = ep_wakeup_source(epi);
+
+       if (ws)
+               __pm_stay_awake(ws);
+}
+
+static inline bool ep_has_wakeup_source(struct epitem *epi)
+{
+       return rcu_access_pointer(epi->ws) ? true : false;
+}
+
+/* call when ep->mtx cannot be held (ep_poll_callback) */
+static inline void ep_pm_stay_awake_rcu(struct epitem *epi)
+{
+       struct wakeup_source *ws;
+
+       rcu_read_lock();
+       ws = rcu_dereference(epi->ws);
+       if (ws)
+               __pm_stay_awake(ws);
+       rcu_read_unlock();
+}
+
 /**
  * ep_scan_ready_list - Scans the ready list in a way that makes possible for
  *                      the scan code, to call f_op->poll(). Also allows for
@@ -564,8 +632,10 @@ static int ep_scan_ready_list(struct eventpoll *ep,
                 * queued into ->ovflist but the "txlist" might already
                 * contain them, and the list_splice() below takes care of them.
                 */
-               if (!ep_is_linked(&epi->rdllink))
+               if (!ep_is_linked(&epi->rdllink)) {
                        list_add_tail(&epi->rdllink, &ep->rdllist);
+                       ep_pm_stay_awake(epi);
+               }
        }
        /*
         * We need to set back ep->ovflist to EP_UNACTIVE_PTR, so that after
@@ -578,6 +648,7 @@ static int ep_scan_ready_list(struct eventpoll *ep,
         * Quickly re-inject items left on "txlist".
         */
        list_splice(&txlist, &ep->rdllist);
+       __pm_relax(ep->ws);
 
        if (!list_empty(&ep->rdllist)) {
                /*
@@ -632,6 +703,8 @@ static int ep_remove(struct eventpoll *ep, struct epitem *epi)
                list_del_init(&epi->rdllink);
        spin_unlock_irqrestore(&ep->lock, flags);
 
+       wakeup_source_unregister(ep_wakeup_source(epi));
+
        /* At this point it is safe to free the eventpoll item */
        kmem_cache_free(epi_cache, epi);
 
@@ -673,15 +746,20 @@ static void ep_free(struct eventpoll *ep)
         * point we are sure no poll callbacks will be lingering around, and also by
         * holding "epmutex" we can be sure that no file cleanup code will hit
         * us during this operation. So we can avoid the lock on "ep->lock".
+        * We do not need to lock ep->mtx, either, we only do it to prevent
+        * a lockdep warning.
         */
+       mutex_lock(&ep->mtx);
        while ((rbp = rb_first(&ep->rbr)) != NULL) {
                epi = rb_entry(rbp, struct epitem, rbn);
                ep_remove(ep, epi);
        }
+       mutex_unlock(&ep->mtx);
 
        mutex_unlock(&epmutex);
        mutex_destroy(&ep->mtx);
        free_uid(ep->user);
+       wakeup_source_unregister(ep->ws);
        kfree(ep);
 }
 
@@ -695,6 +773,13 @@ static int ep_eventpoll_release(struct inode *inode, struct file *file)
        return 0;
 }
 
+static inline unsigned int ep_item_poll(struct epitem *epi, poll_table *pt)
+{
+       pt->_key = epi->event.events;
+
+       return epi->ffd.file->f_op->poll(epi->ffd.file, pt) & epi->event.events;
+}
+
 static int ep_read_events_proc(struct eventpoll *ep, struct list_head *head,
                               void *priv)
 {
@@ -702,10 +787,9 @@ static int ep_read_events_proc(struct eventpoll *ep, struct list_head *head,
        poll_table pt;
 
        init_poll_funcptr(&pt, NULL);
+
        list_for_each_entry_safe(epi, tmp, head, rdllink) {
-               pt._key = epi->event.events;
-               if (epi->ffd.file->f_op->poll(epi->ffd.file, &pt) &
-                   epi->event.events)
+               if (ep_item_poll(epi, &pt))
                        return POLLIN | POLLRDNORM;
                else {
                        /*
@@ -713,6 +797,7 @@ static int ep_read_events_proc(struct eventpoll *ep, struct list_head *head,
                         * callback, but it's not actually ready, as far as
                         * caller requested events goes. We can remove it here.
                         */
+                       __pm_relax(ep_wakeup_source(epi));
                        list_del_init(&epi->rdllink);
                }
        }
@@ -745,8 +830,34 @@ static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait)
        return pollflags != -1 ? pollflags : 0;
 }
 
+#ifdef CONFIG_PROC_FS
+static int ep_show_fdinfo(struct seq_file *m, struct file *f)
+{
+       struct eventpoll *ep = f->private_data;
+       struct rb_node *rbp;
+       int ret = 0;
+
+       mutex_lock(&ep->mtx);
+       for (rbp = rb_first(&ep->rbr); rbp; rbp = rb_next(rbp)) {
+               struct epitem *epi = rb_entry(rbp, struct epitem, rbn);
+
+               ret = seq_printf(m, "tfd: %8d events: %8x data: %16llx\n",
+                                epi->ffd.fd, epi->event.events,
+                                (long long)epi->event.data);
+               if (ret)
+                       break;
+       }
+       mutex_unlock(&ep->mtx);
+
+       return ret;
+}
+#endif
+
 /* File callbacks that implement the eventpoll file behaviour */
 static const struct file_operations eventpoll_fops = {
+#ifdef CONFIG_PROC_FS
+       .show_fdinfo    = ep_show_fdinfo,
+#endif
        .release        = ep_eventpoll_release,
        .poll           = ep_eventpoll_poll,
        .llseek         = noop_llseek,
@@ -903,13 +1014,23 @@ static int ep_poll_callback(wait_queue_t *wait, unsigned mode, int sync, void *k
                if (epi->next == EP_UNACTIVE_PTR) {
                        epi->next = ep->ovflist;
                        ep->ovflist = epi;
+                       if (epi->ws) {
+                               /*
+                                * Activate ep->ws since epi->ws may get
+                                * deactivated at any time.
+                                */
+                               __pm_stay_awake(ep->ws);
+                       }
+
                }
                goto out_unlock;
        }
 
        /* If this file is already in the ready list we exit soon */
-       if (!ep_is_linked(&epi->rdllink))
+       if (!ep_is_linked(&epi->rdllink)) {
                list_add_tail(&epi->rdllink, &ep->rdllist);
+               ep_pm_stay_awake_rcu(epi);
+       }
 
        /*
         * Wake up ( if active ) both the eventpoll wait list and the ->poll()
@@ -1052,13 +1173,11 @@ static int reverse_path_check_proc(void *priv, void *cookie, int call_nests)
  */
 static int reverse_path_check(void)
 {
-       int length = 0;
        int error = 0;
        struct file *current_file;
 
        /* let's call this for all tfiles */
        list_for_each_entry(current_file, &tfile_check_list, f_tfile_llink) {
-               length++;
                path_count_init();
                error = ep_call_nested(&poll_loop_ncalls, EP_MAX_NESTS,
                                        reverse_path_check_proc, current_file,
@@ -1069,6 +1188,43 @@ static int reverse_path_check(void)
        return error;
 }
 
+static int ep_create_wakeup_source(struct epitem *epi)
+{
+       const char *name;
+       struct wakeup_source *ws;
+
+       if (!epi->ep->ws) {
+               epi->ep->ws = wakeup_source_register("eventpoll");
+               if (!epi->ep->ws)
+                       return -ENOMEM;
+       }
+
+       name = epi->ffd.file->f_path.dentry->d_name.name;
+       ws = wakeup_source_register(name);
+
+       if (!ws)
+               return -ENOMEM;
+       rcu_assign_pointer(epi->ws, ws);
+
+       return 0;
+}
+
+/* rare code path, only used when EPOLL_CTL_MOD removes a wakeup source */
+static noinline void ep_destroy_wakeup_source(struct epitem *epi)
+{
+       struct wakeup_source *ws = ep_wakeup_source(epi);
+
+       RCU_INIT_POINTER(epi->ws, NULL);
+
+       /*
+        * wait for ep_pm_stay_awake_rcu to finish, synchronize_rcu is
+        * used internally by wakeup_source_remove, too (called by
+        * wakeup_source_unregister), so we cannot use call_rcu
+        */
+       synchronize_rcu();
+       wakeup_source_unregister(ws);
+}
+
 /*
  * Must be called with "mtx" held.
  */
@@ -1096,11 +1252,17 @@ static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
        epi->event = *event;
        epi->nwait = 0;
        epi->next = EP_UNACTIVE_PTR;
+       if (epi->event.events & EPOLLWAKEUP) {
+               error = ep_create_wakeup_source(epi);
+               if (error)
+                       goto error_create_wakeup_source;
+       } else {
+               RCU_INIT_POINTER(epi->ws, NULL);
+       }
 
        /* Initialize the poll table using the queue callback */
        epq.epi = epi;
        init_poll_funcptr(&epq.pt, ep_ptable_queue_proc);
-       epq.pt._key = event->events;
 
        /*
         * Attach the item to the poll hooks and get current event bits.
@@ -1109,7 +1271,7 @@ static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
         * this operation completes, the poll callback can start hitting
         * the new item.
         */
-       revents = tfile->f_op->poll(tfile, &epq.pt);
+       revents = ep_item_poll(epi, &epq.pt);
 
        /*
         * We have to check if something went wrong during the poll wait queue
@@ -1142,6 +1304,7 @@ static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
        /* If the file is already "ready" we drop it inside the ready list */
        if ((revents & event->events) && !ep_is_linked(&epi->rdllink)) {
                list_add_tail(&epi->rdllink, &ep->rdllist);
+               ep_pm_stay_awake(epi);
 
                /* Notify waiting tasks that events are available */
                if (waitqueue_active(&ep->wq))
@@ -1182,6 +1345,9 @@ error_unregister:
                list_del_init(&epi->rdllink);
        spin_unlock_irqrestore(&ep->lock, flags);
 
+       wakeup_source_unregister(ep_wakeup_source(epi));
+
+error_create_wakeup_source:
        kmem_cache_free(epi_cache, epi);
 
        return error;
@@ -1204,15 +1370,40 @@ static int ep_modify(struct eventpoll *ep, struct epitem *epi, struct epoll_even
         * otherwise we might miss an event that happens between the
         * f_op->poll() call and the new event set registering.
         */
-       epi->event.events = event->events;
-       pt._key = event->events;
+       epi->event.events = event->events; /* need barrier below */
        epi->event.data = event->data; /* protected by mtx */
+       if (epi->event.events & EPOLLWAKEUP) {
+               if (!ep_has_wakeup_source(epi))
+                       ep_create_wakeup_source(epi);
+       } else if (ep_has_wakeup_source(epi)) {
+               ep_destroy_wakeup_source(epi);
+       }
+
+       /*
+        * The following barrier has two effects:
+        *
+        * 1) Flush epi changes above to other CPUs.  This ensures
+        *    we do not miss events from ep_poll_callback if an
+        *    event occurs immediately after we call f_op->poll().
+        *    We need this because we did not take ep->lock while
+        *    changing epi above (but ep_poll_callback does take
+        *    ep->lock).
+        *
+        * 2) We also need to ensure we do not miss _past_ events
+        *    when calling f_op->poll().  This barrier also
+        *    pairs with the barrier in wq_has_sleeper (see
+        *    comments for wq_has_sleeper).
+        *
+        * This barrier will now guarantee ep_poll_callback or f_op->poll
+        * (or both) will notice the readiness of an item.
+        */
+       smp_mb();
 
        /*
         * Get current event bits. We can safely use the file* here because
         * its usage count has been increased by the caller of this function.
         */
-       revents = epi->ffd.file->f_op->poll(epi->ffd.file, &pt);
+       revents = ep_item_poll(epi, &pt);
 
        /*
         * If the item is "hot" and it is not registered inside the ready
@@ -1222,6 +1413,7 @@ static int ep_modify(struct eventpoll *ep, struct epitem *epi, struct epoll_even
                spin_lock_irq(&ep->lock);
                if (!ep_is_linked(&epi->rdllink)) {
                        list_add_tail(&epi->rdllink, &ep->rdllist);
+                       ep_pm_stay_awake(epi);
 
                        /* Notify waiting tasks that events are available */
                        if (waitqueue_active(&ep->wq))
@@ -1247,6 +1439,7 @@ static int ep_send_events_proc(struct eventpoll *ep, struct list_head *head,
        unsigned int revents;
        struct epitem *epi;
        struct epoll_event __user *uevent;
+       struct wakeup_source *ws;
        poll_table pt;
 
        init_poll_funcptr(&pt, NULL);
@@ -1260,11 +1453,25 @@ static int ep_send_events_proc(struct eventpoll *ep, struct list_head *head,
             !list_empty(head) && eventcnt < esed->maxevents;) {
                epi = list_first_entry(head, struct epitem, rdllink);
 
+               /*
+                * Activate ep->ws before deactivating epi->ws to prevent
+                * triggering auto-suspend here (in case we reactive epi->ws
+                * below).
+                *
+                * This could be rearranged to delay the deactivation of epi->ws
+                * instead, but then epi->ws would temporarily be out of sync
+                * with ep_is_linked().
+                */
+               ws = ep_wakeup_source(epi);
+               if (ws) {
+                       if (ws->active)
+                               __pm_stay_awake(ep->ws);
+                       __pm_relax(ws);
+               }
+
                list_del_init(&epi->rdllink);
 
-               pt._key = epi->event.events;
-               revents = epi->ffd.file->f_op->poll(epi->ffd.file, &pt) &
-                       epi->event.events;
+               revents = ep_item_poll(epi, &pt);
 
                /*
                 * If the event mask intersect the caller-requested one,
@@ -1276,6 +1483,7 @@ static int ep_send_events_proc(struct eventpoll *ep, struct list_head *head,
                        if (__put_user(revents, &uevent->events) ||
                            __put_user(epi->event.data, &uevent->data)) {
                                list_add(&epi->rdllink, head);
+                               ep_pm_stay_awake(epi);
                                return eventcnt ? eventcnt : -EFAULT;
                        }
                        eventcnt++;
@@ -1295,6 +1503,7 @@ static int ep_send_events_proc(struct eventpoll *ep, struct list_head *head,
                                 * poll callback will queue them in ep->ovflist.
                                 */
                                list_add_tail(&epi->rdllink, &ep->rdllist);
+                               ep_pm_stay_awake(epi);
                        }
                }
        }
@@ -1552,8 +1761,8 @@ SYSCALL_DEFINE1(epoll_create1, int, flags)
                error = PTR_ERR(file);
                goto out_free_fd;
        }
-       fd_install(fd, file);
        ep->file = file;
+       fd_install(fd, file);
        return fd;
 
 out_free_fd:
@@ -1607,6 +1816,10 @@ SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
        if (!tfile->f_op || !tfile->f_op->poll)
                goto error_tgt_fput;
 
+       /* Check if EPOLLWAKEUP is allowed */
+       if ((epds.events & EPOLLWAKEUP) && !capable(CAP_BLOCK_SUSPEND))
+               epds.events &= ~EPOLLWAKEUP;
+
        /*
         * We have to check that the file structure underneath the file descriptor
         * the user passed to us _is_ an eventpoll file. And also we do not permit
@@ -1641,8 +1854,10 @@ SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
        if (op == EPOLL_CTL_ADD) {
                if (is_file_epoll(tfile)) {
                        error = -ELOOP;
-                       if (ep_loop_check(ep, tfile) != 0)
+                       if (ep_loop_check(ep, tfile) != 0) {
+                               clear_tfile_check_list();
                                goto error_tgt_fput;
+                       }
                } else
                        list_add(&tfile->f_tfile_llink, &tfile_check_list);
        }
@@ -1702,7 +1917,7 @@ SYSCALL_DEFINE4(epoll_wait, int, epfd, struct epoll_event __user *, events,
                int, maxevents, int, timeout)
 {
        int error;
-       struct file *file;
+       struct fd f;
        struct eventpoll *ep;
 
        /* The maximum number of event must be greater than zero */
@@ -1710,43 +1925,36 @@ SYSCALL_DEFINE4(epoll_wait, int, epfd, struct epoll_event __user *, events,
                return -EINVAL;
 
        /* Verify that the area passed by the user is writeable */
-       if (!access_ok(VERIFY_WRITE, events, maxevents * sizeof(struct epoll_event))) {
-               error = -EFAULT;
-               goto error_return;
-       }
+       if (!access_ok(VERIFY_WRITE, events, maxevents * sizeof(struct epoll_event)))
+               return -EFAULT;
 
        /* Get the "struct file *" for the eventpoll file */
-       error = -EBADF;
-       file = fget(epfd);
-       if (!file)
-               goto error_return;
+       f = fdget(epfd);
+       if (!f.file)
+               return -EBADF;
 
        /*
         * We have to check that the file structure underneath the fd
         * the user passed to us _is_ an eventpoll file.
         */
        error = -EINVAL;
-       if (!is_file_epoll(file))
+       if (!is_file_epoll(f.file))
                goto error_fput;
 
        /*
         * At this point it is safe to assume that the "private_data" contains
         * our own data structure.
         */
-       ep = file->private_data;
+       ep = f.file->private_data;
 
        /* Time to fish for events ... */
        error = ep_poll(ep, events, maxevents, timeout);
 
 error_fput:
-       fput(file);
-error_return:
-
+       fdput(f);
        return error;
 }
 
-#ifdef HAVE_SET_RESTORE_SIGMASK
-
 /*
  * Implement the event wait interface for the eventpoll file. It is the kernel
  * part of the user space epoll_pwait(2).
@@ -1791,7 +1999,51 @@ SYSCALL_DEFINE6(epoll_pwait, int, epfd, struct epoll_event __user *, events,
        return error;
 }
 
-#endif /* HAVE_SET_RESTORE_SIGMASK */
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE6(epoll_pwait, int, epfd,
+                       struct epoll_event __user *, events,
+                       int, maxevents, int, timeout,
+                       const compat_sigset_t __user *, sigmask,
+                       compat_size_t, sigsetsize)
+{
+       long err;
+       compat_sigset_t csigmask;
+       sigset_t ksigmask, sigsaved;
+
+       /*
+        * If the caller wants a certain signal mask to be set during the wait,
+        * we apply it here.
+        */
+       if (sigmask) {
+               if (sigsetsize != sizeof(compat_sigset_t))
+                       return -EINVAL;
+               if (copy_from_user(&csigmask, sigmask, sizeof(csigmask)))
+                       return -EFAULT;
+               sigset_from_compat(&ksigmask, &csigmask);
+               sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
+               sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
+       }
+
+       err = sys_epoll_wait(epfd, events, maxevents, timeout);
+
+       /*
+        * If we changed the signal mask, we need to restore the original one.
+        * In case we've got a signal while waiting, we do not restore the
+        * signal mask yet, and we allow do_signal() to deliver the signal on
+        * the way back to userspace, before the signal mask is restored.
+        */
+       if (sigmask) {
+               if (err == -EINTR) {
+                       memcpy(&current->saved_sigmask, &sigsaved,
+                              sizeof(sigsaved));
+                       set_restore_sigmask();
+               } else
+                       sigprocmask(SIG_SETMASK, &sigsaved, NULL);
+       }
+
+       return err;
+}
+#endif
 
 static int __init eventpoll_init(void)
 {
@@ -1817,6 +2069,12 @@ static int __init eventpoll_init(void)
        /* Initialize the structure used to perform file's f_op->poll() calls */
        ep_nested_calls_init(&poll_readywalk_ncalls);
 
+       /*
+        * We can have many thousands of epitems, so prevent this from
+        * using an extra cache line on 64-bit (and smaller) CPUs
+        */
+       BUILD_BUG_ON(sizeof(void *) <= 8 && sizeof(struct epitem) > 128);
+
        /* Allocates slab cache used to allocate "struct epitem" items */
        epi_cache = kmem_cache_create("eventpoll_epi", sizeof(struct epitem),
                        0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);