Root/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/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
98void fsnotify_get_mark(struct fsnotify_mark_entry *entry)
99{
100    atomic_inc(&entry->refcnt);
101}
102
103void 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 */
112static 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 */
129void 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 */
143void 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    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 */
222void fsnotify_clear_marks_by_group(struct fsnotify_group *group)
223{
224    struct fsnotify_mark_entry *lentry, *entry;
225    LIST_HEAD(free_list);
226
227    spin_lock(&group->mark_lock);
228    list_for_each_entry_safe(entry, lentry, &group->mark_entries, 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_by_entry(entry);
237        fsnotify_put_mark(entry);
238    }
239}
240
241/*
242 * Given an inode, destroy all of the marks associated with that inode.
243 */
244void fsnotify_clear_marks_by_inode(struct inode *inode)
245{
246    struct fsnotify_mark_entry *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_mark_entries, i_list) {
252        list_add(&entry->free_i_list, &free_list);
253        hlist_del_init(&entry->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, free_i_list) {
259        fsnotify_destroy_mark_by_entry(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 */
268struct fsnotify_mark_entry *fsnotify_find_mark_entry(struct fsnotify_group *group,
269                             struct inode *inode)
270{
271    struct fsnotify_mark_entry *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_mark_entries, i_list) {
277        if (entry->group == group) {
278            fsnotify_get_mark(entry);
279            return entry;
280        }
281    }
282    return NULL;
283}
284
285/*
286 * Nothing fancy, just initialize lists and locks and counters.
287 */
288void fsnotify_init_mark(struct fsnotify_mark_entry *entry,
289            void (*free_mark)(struct fsnotify_mark_entry *entry))
290
291{
292    spin_lock_init(&entry->lock);
293    atomic_set(&entry->refcnt, 1);
294    INIT_HLIST_NODE(&entry->i_list);
295    entry->group = NULL;
296    entry->mask = 0;
297    entry->inode = NULL;
298    entry->free_mark = free_mark;
299}
300
301/*
302 * Attach an initialized mark entry to a given group and inode.
303 * These marks may be used for the fsnotify backend to determine which
304 * event types should be delivered to which group and for which inodes.
305 */
306int fsnotify_add_mark(struct fsnotify_mark_entry *entry,
307              struct fsnotify_group *group, struct inode *inode)
308{
309    struct fsnotify_mark_entry *lentry;
310    int ret = 0;
311
312    inode = igrab(inode);
313    if (unlikely(!inode))
314        return -EINVAL;
315
316    /*
317     * LOCKING ORDER!!!!
318     * entry->lock
319     * group->mark_lock
320     * inode->i_lock
321     */
322    spin_lock(&entry->lock);
323    spin_lock(&group->mark_lock);
324    spin_lock(&inode->i_lock);
325
326    lentry = fsnotify_find_mark_entry(group, inode);
327    if (!lentry) {
328        entry->group = group;
329        entry->inode = inode;
330
331        hlist_add_head(&entry->i_list, &inode->i_fsnotify_mark_entries);
332        list_add(&entry->g_list, &group->mark_entries);
333
334        fsnotify_get_mark(entry); /* for i_list and g_list */
335
336        atomic_inc(&group->num_marks);
337
338        fsnotify_recalc_inode_mask_locked(inode);
339    }
340
341    spin_unlock(&inode->i_lock);
342    spin_unlock(&group->mark_lock);
343    spin_unlock(&entry->lock);
344
345    if (lentry) {
346        ret = -EEXIST;
347        iput(inode);
348        fsnotify_put_mark(lentry);
349    } else {
350        __fsnotify_update_child_dentry_flags(inode);
351    }
352
353    return ret;
354}
355
356/**
357 * fsnotify_unmount_inodes - an sb is unmounting. handle any watched inodes.
358 * @list: list of inodes being unmounted (sb->s_inodes)
359 *
360 * Called with inode_lock held, protecting the unmounting super block's list
361 * of inodes, and with iprune_mutex held, keeping shrink_icache_memory() at bay.
362 * We temporarily drop inode_lock, however, and CAN block.
363 */
364void fsnotify_unmount_inodes(struct list_head *list)
365{
366    struct inode *inode, *next_i, *need_iput = NULL;
367
368    list_for_each_entry_safe(inode, next_i, list, i_sb_list) {
369        struct inode *need_iput_tmp;
370
371        /*
372         * We cannot __iget() an inode in state I_CLEAR, I_FREEING,
373         * I_WILL_FREE, or I_NEW which is fine because by that point
374         * the inode cannot have any associated watches.
375         */
376        if (inode->i_state & (I_CLEAR|I_FREEING|I_WILL_FREE|I_NEW))
377            continue;
378
379        /*
380         * If i_count is zero, the inode cannot have any watches and
381         * doing an __iget/iput with MS_ACTIVE clear would actually
382         * evict all inodes with zero i_count from icache which is
383         * unnecessarily violent and may in fact be illegal to do.
384         */
385        if (!atomic_read(&inode->i_count))
386            continue;
387
388        need_iput_tmp = need_iput;
389        need_iput = NULL;
390
391        /* In case fsnotify_inode_delete() drops a reference. */
392        if (inode != need_iput_tmp)
393            __iget(inode);
394        else
395            need_iput_tmp = NULL;
396
397        /* In case the dropping of a reference would nuke next_i. */
398        if ((&next_i->i_sb_list != list) &&
399            atomic_read(&next_i->i_count) &&
400            !(next_i->i_state & (I_CLEAR | I_FREEING | I_WILL_FREE))) {
401            __iget(next_i);
402            need_iput = next_i;
403        }
404
405        /*
406         * We can safely drop inode_lock here because we hold
407         * references on both inode and next_i. Also no new inodes
408         * will be added since the umount has begun. Finally,
409         * iprune_mutex keeps shrink_icache_memory() away.
410         */
411        spin_unlock(&inode_lock);
412
413        if (need_iput_tmp)
414            iput(need_iput_tmp);
415
416        /* for each watch, send FS_UNMOUNT and then remove it */
417        fsnotify(inode, FS_UNMOUNT, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
418
419        fsnotify_inode_delete(inode);
420
421        iput(inode);
422
423        spin_lock(&inode_lock);
424    }
425}
426

Archive Download this file



interactive