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