fanotify: Use interruptible wait when waiting for permission events

When waiting for response to fanotify permission events, we currently
use uninterruptible waits. That makes code simple however it can cause
lots of processes to end up in uninterruptible sleep with hard reboot
being the only alternative in case fanotify listener process stops
responding (e.g. due to a bug in its implementation). Uninterruptible
sleep also makes system hibernation fail if the listener gets frozen
before the process generating fanotify permission event.

Fix these problems by using interruptible sleep for waiting for response
to fanotify event. This is slightly tricky though - we have to
detect when the event got already reported to userspace as in that
case we must not free the event. Instead we push the responsibility for
freeing the event to the process that will write response to the
event.

Reported-by: Orion Poplawski <orion@nwra.com>
Reported-by: Konstantin Khlebnikov <khlebnikov@yandex-team.ru>
Reviewed-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>

diff --git a/fs/notify/fanotify/fanotify.c b/fs/notify/fanotify/fanotify.c
index 812c975df7eca4b3b11ba4dac08d9d0ed0753b3a..ff7b8a1cdfe1c7ef914c908f724be30dc48143d9 100644 (file)
--- a/fs/notify/fanotify/fanotify.c
+++ b/fs/notify/fanotify/fanotify.c
@@ -77,6 +77,13 @@ static int fanotify_merge(struct list_head *list, struct fsnotify_event *event)
        return 0;
 }
 
+/*
+ * Wait for response to permission event. The function also takes care of
+ * freeing the permission event (or offloads that in case the wait is canceled
+ * by a signal). The function returns 0 in case access got allowed by userspace,
+ * -EPERM in case userspace disallowed the access, and -ERESTARTSYS in case
+ * the wait got interrupted by a signal.
+ */
 static int fanotify_get_response(struct fsnotify_group *group,
                                 struct fanotify_perm_event *event,
                                 struct fsnotify_iter_info *iter_info)
@@ -85,8 +92,29 @@ static int fanotify_get_response(struct fsnotify_group *group,
 
        pr_debug("%s: group=%p event=%p\n", __func__, group, event);
 
-       wait_event(group->fanotify_data.access_waitq,
-                  event->state == FAN_EVENT_ANSWERED);
+       ret = wait_event_interruptible(group->fanotify_data.access_waitq,
+                                      event->state == FAN_EVENT_ANSWERED);
+       /* Signal pending? */
+       if (ret < 0) {
+               spin_lock(&group->notification_lock);
+               /* Event reported to userspace and no answer yet? */
+               if (event->state == FAN_EVENT_REPORTED) {
+                       /* Event will get freed once userspace answers to it */
+                       event->state = FAN_EVENT_CANCELED;
+                       spin_unlock(&group->notification_lock);
+                       return ret;
+               }
+               /* Event not yet reported? Just remove it. */
+               if (event->state == FAN_EVENT_INIT)
+                       fsnotify_remove_queued_event(group, &event->fae.fse);
+               /*
+                * Event may be also answered in case signal delivery raced
+                * with wakeup. In that case we have nothing to do besides
+                * freeing the event and reporting error.
+                */
+               spin_unlock(&group->notification_lock);
+               goto out;
+       }
 
        /* userspace responded, convert to something usable */
        switch (event->response & ~FAN_AUDIT) {
@@ -104,6 +132,8 @@ static int fanotify_get_response(struct fsnotify_group *group,
 
        pr_debug("%s: group=%p event=%p about to return ret=%d\n", __func__,
                 group, event, ret);
+out:
+       fsnotify_destroy_event(group, &event->fae.fse);
 
        return ret;
 }
@@ -406,7 +436,6 @@ static int fanotify_handle_event(struct fsnotify_group *group,
        } else if (fanotify_is_perm_event(mask)) {
                ret = fanotify_get_response(group, FANOTIFY_PE(fsn_event),
                                            iter_info);
-               fsnotify_destroy_event(group, fsn_event);
        }
 finish:
        if (fanotify_is_perm_event(mask))

diff --git a/fs/notify/fanotify/fanotify.h b/fs/notify/fanotify/fanotify.h
index 480f281996d4cd015ad68725b8101ae925362554..68b30504284c0c30d6bb87f7905c24dcd6f9c4e9 100644 (file)
--- a/fs/notify/fanotify/fanotify.h
+++ b/fs/notify/fanotify/fanotify.h
@@ -12,7 +12,8 @@ extern struct kmem_cache *fanotify_perm_event_cachep;
 enum {
        FAN_EVENT_INIT,
        FAN_EVENT_REPORTED,
-       FAN_EVENT_ANSWERED
+       FAN_EVENT_ANSWERED,
+       FAN_EVENT_CANCELED,
 };
 
 /*

diff --git a/fs/notify/fanotify/fanotify_user.c b/fs/notify/fanotify/fanotify_user.c
index 3c272f61d341822bfbb36f3be515176e2e0051dd..56992b32c6bbb63839bbc95a50cb83a57398d8bb 100644 (file)
--- a/fs/notify/fanotify/fanotify_user.c
+++ b/fs/notify/fanotify/fanotify_user.c
@@ -147,10 +147,17 @@ static void finish_permission_event(struct fsnotify_group *group,
                                    unsigned int response)
                                    __releases(&group->notification_lock)
 {
+       bool destroy = false;
+
        assert_spin_locked(&group->notification_lock);
        event->response = response;
-       event->state = FAN_EVENT_ANSWERED;
+       if (event->state == FAN_EVENT_CANCELED)
+               destroy = true;
+       else
+               event->state = FAN_EVENT_ANSWERED;
        spin_unlock(&group->notification_lock);
+       if (destroy)
+               fsnotify_destroy_event(group, &event->fae.fse);
 }
 
 static int process_access_response(struct fsnotify_group *group,