2 * Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
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)
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.
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.
20 * Basic idea behind the notification queue: An fsnotify group (like inotify)
21 * sends the userspace notification about events asyncronously 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
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>
46 #include <asm/atomic.h>
48 #include <linux/fsnotify_backend.h>
51 static struct kmem_cache
*fsnotify_event_cachep
;
52 static struct kmem_cache
*fsnotify_event_holder_cachep
;
54 * This is a magic event we send when the q is too full. Since it doesn't
55 * hold real event information we just keep one system wide and use it any time
56 * it is needed. It's refcnt is set 1 at kernel init time and will never
57 * get set to 0 so it will never get 'freed'
59 static struct fsnotify_event
*q_overflow_event
;
60 static atomic_t fsnotify_sync_cookie
= ATOMIC_INIT(0);
63 * fsnotify_get_cookie - return a unique cookie for use in synchronizing events.
64 * Called from fsnotify_move, which is inlined into filesystem modules.
66 u32
fsnotify_get_cookie(void)
68 return atomic_inc_return(&fsnotify_sync_cookie
);
70 EXPORT_SYMBOL_GPL(fsnotify_get_cookie
);
72 /* return true if the notify queue is empty, false otherwise */
73 bool fsnotify_notify_queue_is_empty(struct fsnotify_group
*group
)
75 BUG_ON(!mutex_is_locked(&group
->notification_mutex
));
76 return list_empty(&group
->notification_list
) ? true : false;
79 void fsnotify_get_event(struct fsnotify_event
*event
)
81 atomic_inc(&event
->refcnt
);
84 void fsnotify_put_event(struct fsnotify_event
*event
)
89 if (atomic_dec_and_test(&event
->refcnt
)) {
90 if (event
->data_type
== FSNOTIFY_EVENT_PATH
)
91 path_put(&event
->path
);
93 BUG_ON(!list_empty(&event
->private_data_list
));
95 kfree(event
->file_name
);
97 kmem_cache_free(fsnotify_event_cachep
, event
);
101 struct fsnotify_event_holder
*fsnotify_alloc_event_holder(void)
103 return kmem_cache_alloc(fsnotify_event_holder_cachep
, GFP_KERNEL
);
106 void fsnotify_destroy_event_holder(struct fsnotify_event_holder
*holder
)
109 kmem_cache_free(fsnotify_event_holder_cachep
, holder
);
113 * Find the private data that the group previously attached to this event when
114 * the group added the event to the notification queue (fsnotify_add_notify_event)
116 struct fsnotify_event_private_data
*fsnotify_remove_priv_from_event(struct fsnotify_group
*group
, struct fsnotify_event
*event
)
118 struct fsnotify_event_private_data
*lpriv
;
119 struct fsnotify_event_private_data
*priv
= NULL
;
121 assert_spin_locked(&event
->lock
);
123 list_for_each_entry(lpriv
, &event
->private_data_list
, event_list
) {
124 if (lpriv
->group
== group
) {
126 list_del(&priv
->event_list
);
134 * Add an event to the group notification queue. The group can later pull this
135 * event off the queue to deal with. If the event is successfully added to the
136 * group's notification queue, a reference is taken on event.
138 int fsnotify_add_notify_event(struct fsnotify_group
*group
, struct fsnotify_event
*event
,
139 struct fsnotify_event_private_data
*priv
,
140 int (*merge
)(struct list_head
*, struct fsnotify_event
*))
142 struct fsnotify_event_holder
*holder
= NULL
;
143 struct list_head
*list
= &group
->notification_list
;
147 * There is one fsnotify_event_holder embedded inside each fsnotify_event.
148 * Check if we expect to be able to use that holder. If not alloc a new
150 * For the overflow event it's possible that something will use the in
151 * event holder before we get the lock so we may need to jump back and
152 * alloc a new holder, this can't happen for most events...
154 if (!list_empty(&event
->holder
.event_list
)) {
156 holder
= fsnotify_alloc_event_holder();
161 mutex_lock(&group
->notification_mutex
);
163 if (group
->q_len
>= group
->max_events
) {
164 event
= q_overflow_event
;
166 /* sorry, no private data on the overflow event */
170 if (!list_empty(list
) && merge
) {
173 ret
= merge(list
, event
);
175 mutex_unlock(&group
->notification_mutex
);
176 if (holder
!= &event
->holder
)
177 fsnotify_destroy_event_holder(holder
);
182 spin_lock(&event
->lock
);
184 if (list_empty(&event
->holder
.event_list
)) {
185 if (unlikely(holder
))
186 fsnotify_destroy_event_holder(holder
);
187 holder
= &event
->holder
;
188 } else if (unlikely(!holder
)) {
189 /* between the time we checked above and got the lock the in
190 * event holder was used, go back and get a new one */
191 spin_unlock(&event
->lock
);
192 mutex_unlock(&group
->notification_mutex
);
197 holder
->event
= event
;
199 fsnotify_get_event(event
);
200 list_add_tail(&holder
->event_list
, list
);
202 list_add_tail(&priv
->event_list
, &event
->private_data_list
);
203 spin_unlock(&event
->lock
);
204 mutex_unlock(&group
->notification_mutex
);
206 wake_up(&group
->notification_waitq
);
211 * Remove and return the first event from the notification list. There is a
212 * reference held on this event since it was on the list. It is the responsibility
213 * of the caller to drop this reference.
215 struct fsnotify_event
*fsnotify_remove_notify_event(struct fsnotify_group
*group
)
217 struct fsnotify_event
*event
;
218 struct fsnotify_event_holder
*holder
;
220 BUG_ON(!mutex_is_locked(&group
->notification_mutex
));
222 holder
= list_first_entry(&group
->notification_list
, struct fsnotify_event_holder
, event_list
);
224 event
= holder
->event
;
226 spin_lock(&event
->lock
);
227 holder
->event
= NULL
;
228 list_del_init(&holder
->event_list
);
229 spin_unlock(&event
->lock
);
231 /* event == holder means we are referenced through the in event holder */
232 if (holder
!= &event
->holder
)
233 fsnotify_destroy_event_holder(holder
);
241 * This will not remove the event, that must be done with fsnotify_remove_notify_event()
243 struct fsnotify_event
*fsnotify_peek_notify_event(struct fsnotify_group
*group
)
245 struct fsnotify_event
*event
;
246 struct fsnotify_event_holder
*holder
;
248 BUG_ON(!mutex_is_locked(&group
->notification_mutex
));
250 holder
= list_first_entry(&group
->notification_list
, struct fsnotify_event_holder
, event_list
);
251 event
= holder
->event
;
257 * Called when a group is being torn down to clean up any outstanding
258 * event notifications.
260 void fsnotify_flush_notify(struct fsnotify_group
*group
)
262 struct fsnotify_event
*event
;
263 struct fsnotify_event_private_data
*priv
;
265 mutex_lock(&group
->notification_mutex
);
266 while (!fsnotify_notify_queue_is_empty(group
)) {
267 event
= fsnotify_remove_notify_event(group
);
268 /* if they don't implement free_event_priv they better not have attached any */
269 if (group
->ops
->free_event_priv
) {
270 spin_lock(&event
->lock
);
271 priv
= fsnotify_remove_priv_from_event(group
, event
);
272 spin_unlock(&event
->lock
);
274 group
->ops
->free_event_priv(priv
);
276 fsnotify_put_event(event
); /* matches fsnotify_add_notify_event */
278 mutex_unlock(&group
->notification_mutex
);
281 static void initialize_event(struct fsnotify_event
*event
)
283 INIT_LIST_HEAD(&event
->holder
.event_list
);
284 atomic_set(&event
->refcnt
, 1);
286 spin_lock_init(&event
->lock
);
288 INIT_LIST_HEAD(&event
->private_data_list
);
292 * Caller damn well better be holding whatever mutex is protecting the
293 * old_holder->event_list and the new_event must be a clean event which
294 * cannot be found anywhere else in the kernel.
296 int fsnotify_replace_event(struct fsnotify_event_holder
*old_holder
,
297 struct fsnotify_event
*new_event
)
299 struct fsnotify_event
*old_event
= old_holder
->event
;
300 struct fsnotify_event_holder
*new_holder
= &new_event
->holder
;
302 enum event_spinlock_class
{
308 * if the new_event's embedded holder is in use someone
309 * screwed up and didn't give us a clean new event.
311 BUG_ON(!list_empty(&new_holder
->event_list
));
313 spin_lock_nested(&old_event
->lock
, SPINLOCK_OLD
);
314 spin_lock_nested(&new_event
->lock
, SPINLOCK_NEW
);
316 new_holder
->event
= new_event
;
317 list_replace_init(&old_holder
->event_list
, &new_holder
->event_list
);
319 spin_unlock(&new_event
->lock
);
320 spin_unlock(&old_event
->lock
);
322 /* event == holder means we are referenced through the in event holder */
323 if (old_holder
!= &old_event
->holder
)
324 fsnotify_destroy_event_holder(old_holder
);
326 fsnotify_get_event(new_event
); /* on the list take reference */
327 fsnotify_put_event(old_event
); /* off the list, drop reference */
332 struct fsnotify_event
*fsnotify_clone_event(struct fsnotify_event
*old_event
)
334 struct fsnotify_event
*event
;
336 event
= kmem_cache_alloc(fsnotify_event_cachep
, GFP_KERNEL
);
340 memcpy(event
, old_event
, sizeof(*event
));
341 initialize_event(event
);
343 if (event
->name_len
) {
344 event
->file_name
= kstrdup(old_event
->file_name
, GFP_KERNEL
);
345 if (!event
->file_name
) {
346 kmem_cache_free(fsnotify_event_cachep
, event
);
350 event
->tgid
= get_pid(old_event
->tgid
);
351 if (event
->data_type
== FSNOTIFY_EVENT_PATH
)
352 path_get(&event
->path
);
358 * fsnotify_create_event - Allocate a new event which will be sent to each
359 * group's handle_event function if the group was interested in this
362 * @to_tell the inode which is supposed to receive the event (sometimes a
363 * parent of the inode to which the event happened.
364 * @mask what actually happened.
365 * @data pointer to the object which was actually affected
366 * @data_type flag indication if the data is a file, path, inode, nothing...
367 * @name the filename, if available
369 struct fsnotify_event
*fsnotify_create_event(struct inode
*to_tell
, __u32 mask
, void *data
,
370 int data_type
, const char *name
, u32 cookie
,
373 struct fsnotify_event
*event
;
375 event
= kmem_cache_zalloc(fsnotify_event_cachep
, gfp
);
379 initialize_event(event
);
382 event
->file_name
= kstrdup(name
, gfp
);
383 if (!event
->file_name
) {
384 kmem_cache_free(fsnotify_event_cachep
, event
);
387 event
->name_len
= strlen(event
->file_name
);
390 event
->tgid
= get_pid(task_tgid(current
));
391 event
->sync_cookie
= cookie
;
392 event
->to_tell
= to_tell
;
393 event
->data_type
= data_type
;
396 case FSNOTIFY_EVENT_PATH
: {
397 struct path
*path
= data
;
398 event
->path
.dentry
= path
->dentry
;
399 event
->path
.mnt
= path
->mnt
;
400 path_get(&event
->path
);
403 case FSNOTIFY_EVENT_INODE
:
406 case FSNOTIFY_EVENT_NONE
:
408 event
->path
.dentry
= NULL
;
409 event
->path
.mnt
= NULL
;
420 __init
int fsnotify_notification_init(void)
422 fsnotify_event_cachep
= KMEM_CACHE(fsnotify_event
, SLAB_PANIC
);
423 fsnotify_event_holder_cachep
= KMEM_CACHE(fsnotify_event_holder
, SLAB_PANIC
);
425 q_overflow_event
= fsnotify_create_event(NULL
, FS_Q_OVERFLOW
, NULL
,
426 FSNOTIFY_EVENT_NONE
, NULL
, 0,
428 if (!q_overflow_event
)
429 panic("unable to allocate fsnotify q_overflow_event\n");
433 subsys_initcall(fsnotify_notification_init
);