LXR linux/fs/notify/group.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
   4 */
   5
   6#include <linux/list.h>
   7#include <linux/mutex.h>
   8#include <linux/slab.h>
   9#include <linux/srcu.h>
  10#include <linux/rculist.h>
  11#include <linux/wait.h>
  12#include <linux/memcontrol.h>
  13
  14#include <linux/fsnotify_backend.h>
  15#include "fsnotify.h"
  16
  17#include <linux/atomic.h>
  18
  19/*
  20 * Final freeing of a group
  21 */
  22static void fsnotify_final_destroy_group(struct fsnotify_group *group)
  23{
  24        if (group->ops->free_group_priv)
  25                group->ops->free_group_priv(group);
  26
  27        mem_cgroup_put(group->memcg);
  28
  29        kfree(group);
  30}
  31
  32/*
  33 * Stop queueing new events for this group. Once this function returns
  34 * fsnotify_add_event() will not add any new events to the group's queue.
  35 */
  36void fsnotify_group_stop_queueing(struct fsnotify_group *group)
  37{
  38        spin_lock(&group->notification_lock);
  39        group->shutdown = true;
  40        spin_unlock(&group->notification_lock);
  41}
  42
  43/*
  44 * Trying to get rid of a group. Remove all marks, flush all events and release
  45 * the group reference.
  46 * Note that another thread calling fsnotify_clear_marks_by_group() may still
  47 * hold a ref to the group.
  48 */
  49void fsnotify_destroy_group(struct fsnotify_group *group)
  50{
  51        /*
  52         * Stop queueing new events. The code below is careful enough to not
  53         * require this but fanotify needs to stop queuing events even before
  54         * fsnotify_destroy_group() is called and this makes the other callers
  55         * of fsnotify_destroy_group() to see the same behavior.
  56         */
  57        fsnotify_group_stop_queueing(group);
  58
  59        /* Clear all marks for this group and queue them for destruction */
  60        fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_ALL_TYPES_MASK);
  61
  62        /*
  63         * Some marks can still be pinned when waiting for response from
  64         * userspace. Wait for those now. fsnotify_prepare_user_wait() will
  65         * not succeed now so this wait is race-free.
  66         */
  67        wait_event(group->notification_waitq, !atomic_read(&group->user_waits));
  68
  69        /*
  70         * Wait until all marks get really destroyed. We could actually destroy
  71         * them ourselves instead of waiting for worker to do it, however that
  72         * would be racy as worker can already be processing some marks before
  73         * we even entered fsnotify_destroy_group().
  74         */
  75        fsnotify_wait_marks_destroyed();
  76
  77        /*
  78         * Since we have waited for fsnotify_mark_srcu in
  79         * fsnotify_mark_destroy_list() there can be no outstanding event
  80         * notification against this group. So clearing the notification queue
  81         * of all events is reliable now.
  82         */
  83        fsnotify_flush_notify(group);
  84
  85        /*
  86         * Destroy overflow event (we cannot use fsnotify_destroy_event() as
  87         * that deliberately ignores overflow events.
  88         */
  89        if (group->overflow_event)
  90                group->ops->free_event(group->overflow_event);
  91
  92        fsnotify_put_group(group);
  93}
  94
  95/*
  96 * Get reference to a group.
  97 */
  98void fsnotify_get_group(struct fsnotify_group *group)
  99{
 100        refcount_inc(&group->refcnt);
 101}
 102
 103/*
 104 * Drop a reference to a group.  Free it if it's through.
 105 */
 106void fsnotify_put_group(struct fsnotify_group *group)
 107{
 108        if (refcount_dec_and_test(&group->refcnt))
 109                fsnotify_final_destroy_group(group);
 110}
 111
 112/*
 113 * Create a new fsnotify_group and hold a reference for the group returned.
 114 */
 115struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops)
 116{
 117        struct fsnotify_group *group;
 118
 119        group = kzalloc(sizeof(struct fsnotify_group), GFP_KERNEL);
 120        if (!group)
 121                return ERR_PTR(-ENOMEM);
 122
 123        /* set to 0 when there a no external references to this group */
 124        refcount_set(&group->refcnt, 1);
 125        atomic_set(&group->num_marks, 0);
 126        atomic_set(&group->user_waits, 0);
 127
 128        spin_lock_init(&group->notification_lock);
 129        INIT_LIST_HEAD(&group->notification_list);
 130        init_waitqueue_head(&group->notification_waitq);
 131        group->max_events = UINT_MAX;
 132
 133        mutex_init(&group->mark_mutex);
 134        INIT_LIST_HEAD(&group->marks_list);
 135
 136        group->ops = ops;
 137
 138        return group;
 139}
 140
 141int fsnotify_fasync(int fd, struct file *file, int on)
 142{
 143        struct fsnotify_group *group = file->private_data;
 144
 145        return fasync_helper(fd, file, on, &group->fsn_fa) >= 0 ? 0 : -EIO;
 146}
 147