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 /* 20 * Basic idea behind the notification queue: An fsnotify group (like inotify) 21 * sends the userspace notification about events asynchronously some time after 22 * the event happened. When inotify gets an event it will need to add that 23 * event to the group notify queue. Since a single event might need to be on 24 * multiple group's notification queues we can't add the event directly to each 25 * queue and instead add a small "event_holder" to each queue. This event_holder 26 * has a pointer back to the original event. Since the majority of events are 27 * going to end up on one, and only one, notification queue we embed one 28 * event_holder into each event. This means we have a single allocation instead 29 * of always needing two. If the embedded event_holder is already in use by 30 * another group a new event_holder (from fsnotify_event_holder_cachep) will be 31 * allocated and used. 32 */ 33 34 #include <linux/fs.h> 35 #include <linux/init.h> 36 #include <linux/kernel.h> 37 #include <linux/list.h> 38 #include <linux/module.h> 39 #include <linux/mount.h> 40 #include <linux/mutex.h> 41 #include <linux/namei.h> 42 #include <linux/path.h> 43 #include <linux/slab.h> 44 #include <linux/spinlock.h> 45 46 #include <linux/atomic.h> 47 48 #include <linux/fsnotify_backend.h> 49 #include "fsnotify.h" 50 51 static atomic_t fsnotify_sync_cookie = ATOMIC_INIT(0); 52 53 /** 54 * fsnotify_get_cookie - return a unique cookie for use in synchronizing events. 55 * Called from fsnotify_move, which is inlined into filesystem modules. 56 */ 57 u32 fsnotify_get_cookie(void) 58 { 59 return atomic_inc_return(&fsnotify_sync_cookie); 60 } 61 EXPORT_SYMBOL_GPL(fsnotify_get_cookie); 62 63 /* return true if the notify queue is empty, false otherwise */ 64 bool fsnotify_notify_queue_is_empty(struct fsnotify_group *group) 65 { 66 assert_spin_locked(&group->notification_lock); 67 return list_empty(&group->notification_list) ? true : false; 68 } 69 70 void fsnotify_destroy_event(struct fsnotify_group *group, 71 struct fsnotify_event *event) 72 { 73 /* Overflow events are per-group and we don't want to free them */ 74 if (!event || event->mask == FS_Q_OVERFLOW) 75 return; 76 /* 77 * If the event is still queued, we have a problem... Do an unreliable 78 * lockless check first to avoid locking in the common case. The 79 * locking may be necessary for permission events which got removed 80 * from the list by a different CPU than the one freeing the event. 81 */ 82 if (!list_empty(&event->list)) { 83 spin_lock(&group->notification_lock); 84 WARN_ON(!list_empty(&event->list)); 85 spin_unlock(&group->notification_lock); 86 } 87 group->ops->free_event(event); 88 } 89 90 /* 91 * Add an event to the group notification queue. The group can later pull this 92 * event off the queue to deal with. The function returns 0 if the event was 93 * added to the queue, 1 if the event was merged with some other queued event, 94 * 2 if the event was not queued - either the queue of events has overflown 95 * or the group is shutting down. 96 */ 97 int fsnotify_add_event(struct fsnotify_group *group, 98 struct fsnotify_event *event, 99 int (*merge)(struct list_head *, 100 struct fsnotify_event *)) 101 { 102 int ret = 0; 103 struct list_head *list = &group->notification_list; 104 105 pr_debug("%s: group=%p event=%p\n", __func__, group, event); 106 107 spin_lock(&group->notification_lock); 108 109 if (group->shutdown) { 110 spin_unlock(&group->notification_lock); 111 return 2; 112 } 113 114 if (event == group->overflow_event || 115 group->q_len >= group->max_events) { 116 ret = 2; 117 /* Queue overflow event only if it isn't already queued */ 118 if (!list_empty(&group->overflow_event->list)) { 119 spin_unlock(&group->notification_lock); 120 return ret; 121 } 122 event = group->overflow_event; 123 goto queue; 124 } 125 126 if (!list_empty(list) && merge) { 127 ret = merge(list, event); 128 if (ret) { 129 spin_unlock(&group->notification_lock); 130 return ret; 131 } 132 } 133 134 queue: 135 group->q_len++; 136 list_add_tail(&event->list, list); 137 spin_unlock(&group->notification_lock); 138 139 wake_up(&group->notification_waitq); 140 kill_fasync(&group->fsn_fa, SIGIO, POLL_IN); 141 return ret; 142 } 143 144 /* 145 * Remove and return the first event from the notification list. It is the 146 * responsibility of the caller to destroy the obtained event 147 */ 148 struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group *group) 149 { 150 struct fsnotify_event *event; 151 152 assert_spin_locked(&group->notification_lock); 153 154 pr_debug("%s: group=%p\n", __func__, group); 155 156 event = list_first_entry(&group->notification_list, 157 struct fsnotify_event, list); 158 /* 159 * We need to init list head for the case of overflow event so that 160 * check in fsnotify_add_event() works 161 */ 162 list_del_init(&event->list); 163 group->q_len--; 164 165 return event; 166 } 167 168 /* 169 * This will not remove the event, that must be done with 170 * fsnotify_remove_first_event() 171 */ 172 struct fsnotify_event *fsnotify_peek_first_event(struct fsnotify_group *group) 173 { 174 assert_spin_locked(&group->notification_lock); 175 176 return list_first_entry(&group->notification_list, 177 struct fsnotify_event, list); 178 } 179 180 /* 181 * Called when a group is being torn down to clean up any outstanding 182 * event notifications. 183 */ 184 void fsnotify_flush_notify(struct fsnotify_group *group) 185 { 186 struct fsnotify_event *event; 187 188 spin_lock(&group->notification_lock); 189 while (!fsnotify_notify_queue_is_empty(group)) { 190 event = fsnotify_remove_first_event(group); 191 spin_unlock(&group->notification_lock); 192 fsnotify_destroy_event(group, event); 193 spin_lock(&group->notification_lock); 194 } 195 spin_unlock(&group->notification_lock); 196 } 197 198 /* 199 * fsnotify_create_event - Allocate a new event which will be sent to each 200 * group's handle_event function if the group was interested in this 201 * particular event. 202 * 203 * @inode the inode which is supposed to receive the event (sometimes a 204 * parent of the inode to which the event happened. 205 * @mask what actually happened. 206 * @data pointer to the object which was actually affected 207 * @data_type flag indication if the data is a file, path, inode, nothing... 208 * @name the filename, if available 209 */ 210 void fsnotify_init_event(struct fsnotify_event *event, struct inode *inode, 211 u32 mask) 212 { 213 INIT_LIST_HEAD(&event->list); 214 event->inode = inode; 215 event->mask = mask; 216 } 217