fsnotify: rename fsnotify_find_mark_entry to fsnotify_find_mark
[linux-2.6.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 marks_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_marks 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)
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_marks 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/spinlock.h>
91 #include <linux/writeback.h> /* for inode_lock */
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)
99 {
100         atomic_inc(&entry->refcnt);
101 }
102
103 void fsnotify_put_mark(struct fsnotify_mark *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;
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_marks, i.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(struct fsnotify_mark *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->i.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.i_list);
169         entry->i.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_marks 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         if (group->ops->freeing_mark)
193                 group->ops->freeing_mark(entry, group);
194
195         /*
196          * __fsnotify_update_child_dentry_flags(inode);
197          *
198          * I really want to call that, but we can't, we have no idea if the inode
199          * still exists the second we drop the entry->lock.
200          *
201          * The next time an event arrive to this inode from one of it's children
202          * __fsnotify_parent will see that the inode doesn't care about it's
203          * children and will update all of these flags then.  So really this
204          * is just a lazy update (and could be a perf win...)
205          */
206
207
208         iput(inode);
209
210         /*
211          * it's possible that this group tried to destroy itself, but this
212          * this mark was simultaneously being freed by inode.  If that's the
213          * case, we finish freeing the group here.
214          */
215         if (unlikely(atomic_dec_and_test(&group->num_marks)))
216                 fsnotify_final_destroy_group(group);
217 }
218
219 /*
220  * Given a group, destroy all of the marks associated with that group.
221  */
222 void fsnotify_clear_marks_by_group(struct fsnotify_group *group)
223 {
224         struct fsnotify_mark *lentry, *entry;
225         LIST_HEAD(free_list);
226
227         spin_lock(&group->mark_lock);
228         list_for_each_entry_safe(entry, lentry, &group->marks_list, g_list) {
229                 list_add(&entry->free_g_list, &free_list);
230                 list_del_init(&entry->g_list);
231                 fsnotify_get_mark(entry);
232         }
233         spin_unlock(&group->mark_lock);
234
235         list_for_each_entry_safe(entry, lentry, &free_list, free_g_list) {
236                 fsnotify_destroy_mark(entry);
237                 fsnotify_put_mark(entry);
238         }
239 }
240
241 /*
242  * Given an inode, destroy all of the marks associated with that inode.
243  */
244 void fsnotify_clear_marks_by_inode(struct inode *inode)
245 {
246         struct fsnotify_mark *entry, *lentry;
247         struct hlist_node *pos, *n;
248         LIST_HEAD(free_list);
249
250         spin_lock(&inode->i_lock);
251         hlist_for_each_entry_safe(entry, pos, n, &inode->i_fsnotify_marks, i.i_list) {
252                 list_add(&entry->i.free_i_list, &free_list);
253                 hlist_del_init(&entry->i.i_list);
254                 fsnotify_get_mark(entry);
255         }
256         spin_unlock(&inode->i_lock);
257
258         list_for_each_entry_safe(entry, lentry, &free_list, i.free_i_list) {
259                 fsnotify_destroy_mark(entry);
260                 fsnotify_put_mark(entry);
261         }
262 }
263
264 /*
265  * given a group and inode, find the mark associated with that combination.
266  * if found take a reference to that mark and return it, else return NULL
267  */
268 struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_group *group,
269                                          struct inode *inode)
270 {
271         struct fsnotify_mark *entry;
272         struct hlist_node *pos;
273
274         assert_spin_locked(&inode->i_lock);
275
276         hlist_for_each_entry(entry, pos, &inode->i_fsnotify_marks, i.i_list) {
277                 if (entry->group == group) {
278                         fsnotify_get_mark(entry);
279                         return entry;
280                 }
281         }
282         return NULL;
283 }
284
285 void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old)
286 {
287         assert_spin_locked(&old->lock);
288         new->i.inode = old->i.inode;
289         new->group = old->group;
290         new->mask = old->mask;
291         new->free_mark = old->free_mark;
292 }
293
294 /*
295  * Nothing fancy, just initialize lists and locks and counters.
296  */
297 void fsnotify_init_mark(struct fsnotify_mark *entry,
298                         void (*free_mark)(struct fsnotify_mark *entry))
299 {
300         spin_lock_init(&entry->lock);
301         atomic_set(&entry->refcnt, 1);
302         INIT_HLIST_NODE(&entry->i.i_list);
303         entry->group = NULL;
304         entry->mask = 0;
305         entry->i.inode = NULL;
306         entry->free_mark = free_mark;
307 }
308
309 /*
310  * Attach an initialized mark entry to a given group and inode.
311  * These marks may be used for the fsnotify backend to determine which
312  * event types should be delivered to which group and for which inodes.
313  */
314 int fsnotify_add_mark(struct fsnotify_mark *entry,
315                       struct fsnotify_group *group, struct inode *inode,
316                       int allow_dups)
317 {
318         struct fsnotify_mark *lentry = NULL;
319         int ret = 0;
320
321         inode = igrab(inode);
322         if (unlikely(!inode))
323                 return -EINVAL;
324
325         entry->flags = FSNOTIFY_MARK_FLAG_INODE;
326
327         /*
328          * if this group isn't being testing for inode type events we need
329          * to start testing
330          */
331         if (unlikely(list_empty(&group->inode_group_list)))
332                 fsnotify_add_inode_group(group);
333         /*
334          * XXX This is where we could also do the fsnotify_add_vfsmount_group
335          * if we are setting and vfsmount mark....
336
337         if (unlikely(list_empty(&group->vfsmount_group_list)))
338                 fsnotify_add_vfsmount_group(group);
339          */
340
341         /*
342          * LOCKING ORDER!!!!
343          * entry->lock
344          * group->mark_lock
345          * inode->i_lock
346          */
347         spin_lock(&entry->lock);
348         spin_lock(&group->mark_lock);
349         spin_lock(&inode->i_lock);
350
351         if (!allow_dups)
352                 lentry = fsnotify_find_mark(group, inode);
353         if (!lentry) {
354                 entry->group = group;
355                 entry->i.inode = inode;
356
357                 hlist_add_head(&entry->i.i_list, &inode->i_fsnotify_marks);
358                 list_add(&entry->g_list, &group->marks_list);
359
360                 fsnotify_get_mark(entry); /* for i_list and g_list */
361
362                 atomic_inc(&group->num_marks);
363
364                 fsnotify_recalc_inode_mask_locked(inode);
365         }
366
367         spin_unlock(&inode->i_lock);
368         spin_unlock(&group->mark_lock);
369         spin_unlock(&entry->lock);
370
371         if (lentry) {
372                 ret = -EEXIST;
373                 iput(inode);
374                 fsnotify_put_mark(lentry);
375         } else {
376                 __fsnotify_update_child_dentry_flags(inode);
377         }
378
379         return ret;
380 }
381
382 /**
383  * fsnotify_unmount_inodes - an sb is unmounting.  handle any watched inodes.
384  * @list: list of inodes being unmounted (sb->s_inodes)
385  *
386  * Called with inode_lock held, protecting the unmounting super block's list
387  * of inodes, and with iprune_mutex held, keeping shrink_icache_memory() at bay.
388  * We temporarily drop inode_lock, however, and CAN block.
389  */
390 void fsnotify_unmount_inodes(struct list_head *list)
391 {
392         struct inode *inode, *next_i, *need_iput = NULL;
393
394         list_for_each_entry_safe(inode, next_i, list, i_sb_list) {
395                 struct inode *need_iput_tmp;
396
397                 /*
398                  * We cannot __iget() an inode in state I_CLEAR, I_FREEING,
399                  * I_WILL_FREE, or I_NEW which is fine because by that point
400                  * the inode cannot have any associated watches.
401                  */
402                 if (inode->i_state & (I_CLEAR|I_FREEING|I_WILL_FREE|I_NEW))
403                         continue;
404
405                 /*
406                  * If i_count is zero, the inode cannot have any watches and
407                  * doing an __iget/iput with MS_ACTIVE clear would actually
408                  * evict all inodes with zero i_count from icache which is
409                  * unnecessarily violent and may in fact be illegal to do.
410                  */
411                 if (!atomic_read(&inode->i_count))
412                         continue;
413
414                 need_iput_tmp = need_iput;
415                 need_iput = NULL;
416
417                 /* In case fsnotify_inode_delete() drops a reference. */
418                 if (inode != need_iput_tmp)
419                         __iget(inode);
420                 else
421                         need_iput_tmp = NULL;
422
423                 /* In case the dropping of a reference would nuke next_i. */
424                 if ((&next_i->i_sb_list != list) &&
425                     atomic_read(&next_i->i_count) &&
426                     !(next_i->i_state & (I_CLEAR | I_FREEING | I_WILL_FREE))) {
427                         __iget(next_i);
428                         need_iput = next_i;
429                 }
430
431                 /*
432                  * We can safely drop inode_lock here because we hold
433                  * references on both inode and next_i.  Also no new inodes
434                  * will be added since the umount has begun.  Finally,
435                  * iprune_mutex keeps shrink_icache_memory() away.
436                  */
437                 spin_unlock(&inode_lock);
438
439                 if (need_iput_tmp)
440                         iput(need_iput_tmp);
441
442                 /* for each watch, send FS_UNMOUNT and then remove it */
443                 fsnotify(inode, FS_UNMOUNT, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
444
445                 fsnotify_inode_delete(inode);
446
447                 iput(inode);
448
449                 spin_lock(&inode_lock);
450         }
451 }