fsnotify: parent event notification
[kernel.git] / fs / notify / inode_mark.c
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  * fsnotify inode mark locking/lifetime/and refcnting
21  *
22  * REFCNT:
23  * The mark->refcnt tells how many "things" in the kernel currently are
24  * referencing this object.  The object typically will live inside the kernel
25  * with a refcnt of 2, one for each list it is on (i_list, g_list).  Any task
26  * which can find this object holding the appropriete locks, can take a reference
27  * and the object itself is guarenteed to survive until the reference is dropped.
28  *
29  * LOCKING:
30  * There are 3 spinlocks involved with fsnotify inode marks and they MUST
31  * be taken in order as follows:
32  *
33  * entry->lock
34  * group->mark_lock
35  * inode->i_lock
36  *
37  * entry->lock protects 2 things, entry->group and entry->inode.  You must hold
38  * that lock to dereference either of these things (they could be NULL even with
39  * the lock)
40  *
41  * group->mark_lock protects the mark_entries list anchored inside a given group
42  * and each entry is hooked via the g_list.  It also sorta protects the
43  * free_g_list, which when used is anchored by a private list on the stack of the
44  * task which held the group->mark_lock.
45  *
46  * inode->i_lock protects the i_fsnotify_mark_entries list anchored inside a
47  * given inode and each entry is hooked via the i_list. (and sorta the
48  * free_i_list)
49  *
50  *
51  * LIFETIME:
52  * Inode marks survive between when they are added to an inode and when their
53  * refcnt==0.
54  *
55  * The inode mark can be cleared for a number of different reasons including:
56  * - The inode is unlinked for the last time.  (fsnotify_inode_remove)
57  * - The inode is being evicted from cache. (fsnotify_inode_delete)
58  * - The fs the inode is on is unmounted.  (fsnotify_inode_delete/fsnotify_unmount_inodes)
59  * - Something explicitly requests that it be removed.  (fsnotify_destroy_mark_by_entry)
60  * - The fsnotify_group associated with the mark is going away and all such marks
61  *   need to be cleaned up. (fsnotify_clear_marks_by_group)
62  *
63  * Worst case we are given an inode and need to clean up all the marks on that
64  * inode.  We take i_lock and walk the i_fsnotify_mark_entries safely.  For each
65  * mark on the list we take a reference (so the mark can't disappear under us).
66  * We remove that mark form the inode's list of marks and we add this mark to a
67  * private list anchored on the stack using i_free_list;  At this point we no
68  * longer fear anything finding the mark using the inode's list of marks.
69  *
70  * We can safely and locklessly run the private list on the stack of everything
71  * we just unattached from the original inode.  For each mark on the private list
72  * we grab the mark-> and can thus dereference mark->group and mark->inode.  If
73  * we see the group and inode are not NULL we take those locks.  Now holding all
74  * 3 locks we can completely remove the mark from other tasks finding it in the
75  * future.  Remember, 10 things might already be referencing this mark, but they
76  * better be holding a ref.  We drop our reference we took before we unhooked it
77  * from the inode.  When the ref hits 0 we can free the mark.
78  *
79  * Very similarly for freeing by group, except we use free_g_list.
80  *
81  * This has the very interesting property of being able to run concurrently with
82  * any (or all) other directions.
83  */
84
85 #include <linux/fs.h>
86 #include <linux/init.h>
87 #include <linux/kernel.h>
88 #include <linux/module.h>
89 #include <linux/mutex.h>
90 #include <linux/slab.h>
91 #include <linux/spinlock.h>
92
93 #include <asm/atomic.h>
94
95 #include <linux/fsnotify_backend.h>
96 #include "fsnotify.h"
97
98 void fsnotify_get_mark(struct fsnotify_mark_entry *entry)
99 {
100         atomic_inc(&entry->refcnt);
101 }
102
103 void fsnotify_put_mark(struct fsnotify_mark_entry *entry)
104 {
105         if (atomic_dec_and_test(&entry->refcnt))
106                 entry->free_mark(entry);
107 }
108
109 /*
110  * Recalculate the mask of events relevant to a given inode locked.
111  */
112 static void fsnotify_recalc_inode_mask_locked(struct inode *inode)
113 {
114         struct fsnotify_mark_entry *entry;
115         struct hlist_node *pos;
116         __u32 new_mask = 0;
117
118         assert_spin_locked(&inode->i_lock);
119
120         hlist_for_each_entry(entry, pos, &inode->i_fsnotify_mark_entries, i_list)
121                 new_mask |= entry->mask;
122         inode->i_fsnotify_mask = new_mask;
123 }
124
125 /*
126  * Recalculate the inode->i_fsnotify_mask, or the mask of all FS_* event types
127  * any notifier is interested in hearing for this inode.
128  */
129 void fsnotify_recalc_inode_mask(struct inode *inode)
130 {
131         spin_lock(&inode->i_lock);
132         fsnotify_recalc_inode_mask_locked(inode);
133         spin_unlock(&inode->i_lock);
134
135         __fsnotify_update_child_dentry_flags(inode);
136 }
137
138 /*
139  * Any time a mark is getting freed we end up here.
140  * The caller had better be holding a reference to this mark so we don't actually
141  * do the final put under the entry->lock
142  */
143 void fsnotify_destroy_mark_by_entry(struct fsnotify_mark_entry *entry)
144 {
145         struct fsnotify_group *group;
146         struct inode *inode;
147
148         spin_lock(&entry->lock);
149
150         group = entry->group;
151         inode = entry->inode;
152
153         BUG_ON(group && !inode);
154         BUG_ON(!group && inode);
155
156         /* if !group something else already marked this to die */
157         if (!group) {
158                 spin_unlock(&entry->lock);
159                 return;
160         }
161
162         /* 1 from caller and 1 for being on i_list/g_list */
163         BUG_ON(atomic_read(&entry->refcnt) < 2);
164
165         spin_lock(&group->mark_lock);
166         spin_lock(&inode->i_lock);
167
168         hlist_del_init(&entry->i_list);
169         entry->inode = NULL;
170
171         list_del_init(&entry->g_list);
172         entry->group = NULL;
173
174         fsnotify_put_mark(entry); /* for i_list and g_list */
175
176         /*
177          * this mark is now off the inode->i_fsnotify_mark_entries list and we
178          * hold the inode->i_lock, so this is the perfect time to update the
179          * inode->i_fsnotify_mask
180          */
181         fsnotify_recalc_inode_mask_locked(inode);
182
183         spin_unlock(&inode->i_lock);
184         spin_unlock(&group->mark_lock);
185         spin_unlock(&entry->lock);
186
187         /*
188          * Some groups like to know that marks are being freed.  This is a
189          * callback to the group function to let it know that this entry
190          * is being freed.
191          */
192         group->ops->freeing_mark(entry, group);
193
194         /*
195          * __fsnotify_update_child_dentry_flags(inode);
196          *
197          * I really want to call that, but we can't, we have no idea if the inode
198          * still exists the second we drop the entry->lock.
199          *
200          * The next time an event arrive to this inode from one of it's children
201          * __fsnotify_parent will see that the inode doesn't care about it's
202          * children and will update all of these flags then.  So really this
203          * is just a lazy update (and could be a perf win...)
204          */
205
206
207         /*
208          * it's possible that this group tried to destroy itself, but this
209          * this mark was simultaneously being freed by inode.  If that's the
210          * case, we finish freeing the group here.
211          */
212         if (unlikely(atomic_dec_and_test(&group->num_marks)))
213                 fsnotify_final_destroy_group(group);
214 }
215
216 /*
217  * Given a group, destroy all of the marks associated with that group.
218  */
219 void fsnotify_clear_marks_by_group(struct fsnotify_group *group)
220 {
221         struct fsnotify_mark_entry *lentry, *entry;
222         LIST_HEAD(free_list);
223
224         spin_lock(&group->mark_lock);
225         list_for_each_entry_safe(entry, lentry, &group->mark_entries, g_list) {
226                 list_add(&entry->free_g_list, &free_list);
227                 list_del_init(&entry->g_list);
228                 fsnotify_get_mark(entry);
229         }
230         spin_unlock(&group->mark_lock);
231
232         list_for_each_entry_safe(entry, lentry, &free_list, free_g_list) {
233                 fsnotify_destroy_mark_by_entry(entry);
234                 fsnotify_put_mark(entry);
235         }
236 }
237
238 /*
239  * Given an inode, destroy all of the marks associated with that inode.
240  */
241 void fsnotify_clear_marks_by_inode(struct inode *inode)
242 {
243         struct fsnotify_mark_entry *entry, *lentry;
244         struct hlist_node *pos, *n;
245         LIST_HEAD(free_list);
246
247         spin_lock(&inode->i_lock);
248         hlist_for_each_entry_safe(entry, pos, n, &inode->i_fsnotify_mark_entries, i_list) {
249                 list_add(&entry->free_i_list, &free_list);
250                 hlist_del_init(&entry->i_list);
251                 fsnotify_get_mark(entry);
252         }
253         spin_unlock(&inode->i_lock);
254
255         list_for_each_entry_safe(entry, lentry, &free_list, free_i_list) {
256                 fsnotify_destroy_mark_by_entry(entry);
257                 fsnotify_put_mark(entry);
258         }
259 }
260
261 /*
262  * given a group and inode, find the mark associated with that combination.
263  * if found take a reference to that mark and return it, else return NULL
264  */
265 struct fsnotify_mark_entry *fsnotify_find_mark_entry(struct fsnotify_group *group,
266                                                      struct inode *inode)
267 {
268         struct fsnotify_mark_entry *entry;
269         struct hlist_node *pos;
270
271         assert_spin_locked(&inode->i_lock);
272
273         hlist_for_each_entry(entry, pos, &inode->i_fsnotify_mark_entries, i_list) {
274                 if (entry->group == group) {
275                         fsnotify_get_mark(entry);
276                         return entry;
277                 }
278         }
279         return NULL;
280 }
281
282 /*
283  * Nothing fancy, just initialize lists and locks and counters.
284  */
285 void fsnotify_init_mark(struct fsnotify_mark_entry *entry,
286                         void (*free_mark)(struct fsnotify_mark_entry *entry))
287
288 {
289         spin_lock_init(&entry->lock);
290         atomic_set(&entry->refcnt, 1);
291         INIT_HLIST_NODE(&entry->i_list);
292         entry->group = NULL;
293         entry->mask = 0;
294         entry->inode = NULL;
295         entry->free_mark = free_mark;
296 }
297
298 /*
299  * Attach an initialized mark entry to a given group and inode.
300  * These marks may be used for the fsnotify backend to determine which
301  * event types should be delivered to which group and for which inodes.
302  */
303 int fsnotify_add_mark(struct fsnotify_mark_entry *entry,
304                       struct fsnotify_group *group, struct inode *inode)
305 {
306         struct fsnotify_mark_entry *lentry;
307         int ret = 0;
308
309         /*
310          * LOCKING ORDER!!!!
311          * entry->lock
312          * group->mark_lock
313          * inode->i_lock
314          */
315         spin_lock(&entry->lock);
316         spin_lock(&group->mark_lock);
317         spin_lock(&inode->i_lock);
318
319         entry->group = group;
320         entry->inode = inode;
321
322         lentry = fsnotify_find_mark_entry(group, inode);
323         if (!lentry) {
324                 hlist_add_head(&entry->i_list, &inode->i_fsnotify_mark_entries);
325                 list_add(&entry->g_list, &group->mark_entries);
326
327                 fsnotify_get_mark(entry); /* for i_list and g_list */
328
329                 atomic_inc(&group->num_marks);
330
331                 fsnotify_recalc_inode_mask_locked(inode);
332         }
333
334         spin_unlock(&inode->i_lock);
335         spin_unlock(&group->mark_lock);
336         spin_unlock(&entry->lock);
337
338         if (lentry) {
339                 ret = -EEXIST;
340                 fsnotify_put_mark(lentry);
341         } else {
342                 __fsnotify_update_child_dentry_flags(inode);
343         }
344
345         return ret;
346 }