← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to fs/notify/inode_mark.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
#include <linux/fs.h>
 
20
#include <linux/init.h>
 
21
#include <linux/kernel.h>
 
22
#include <linux/module.h>
 
23
#include <linux/mutex.h>
 
24
#include <linux/spinlock.h>
 
25
 
 
26
#include <linux/atomic.h>
 
27
 
 
28
#include <linux/fsnotify_backend.h>
 
29
#include "fsnotify.h"
 
30
 
 
31
#include "../internal.h"
 
32
 
 
33
/*
 
34
 * Recalculate the mask of events relevant to a given inode locked.
 
35
 */
 
36
static void fsnotify_recalc_inode_mask_locked(struct inode *inode)
 
37
{
 
38
        struct fsnotify_mark *mark;
 
39
        struct hlist_node *pos;
 
40
        __u32 new_mask = 0;
 
41
 
 
42
        assert_spin_locked(&inode->i_lock);
 
43
 
 
44
        hlist_for_each_entry(mark, pos, &inode->i_fsnotify_marks, i.i_list)
 
45
                new_mask |= mark->mask;
 
46
        inode->i_fsnotify_mask = new_mask;
 
47
}
 
48
 
 
49
/*
 
50
 * Recalculate the inode->i_fsnotify_mask, or the mask of all FS_* event types
 
51
 * any notifier is interested in hearing for this inode.
 
52
 */
 
53
void fsnotify_recalc_inode_mask(struct inode *inode)
 
54
{
 
55
        spin_lock(&inode->i_lock);
 
56
        fsnotify_recalc_inode_mask_locked(inode);
 
57
        spin_unlock(&inode->i_lock);
 
58
 
 
59
        __fsnotify_update_child_dentry_flags(inode);
 
60
}
 
61
 
 
62
void fsnotify_destroy_inode_mark(struct fsnotify_mark *mark)
 
63
{
 
64
        struct inode *inode = mark->i.inode;
 
65
 
 
66
        assert_spin_locked(&mark->lock);
 
67
        assert_spin_locked(&mark->group->mark_lock);
 
68
 
 
69
        spin_lock(&inode->i_lock);
 
70
 
 
71
        hlist_del_init_rcu(&mark->i.i_list);
 
72
        mark->i.inode = NULL;
 
73
 
 
74
        /*
 
75
         * this mark is now off the inode->i_fsnotify_marks list and we
 
76
         * hold the inode->i_lock, so this is the perfect time to update the
 
77
         * inode->i_fsnotify_mask
 
78
         */
 
79
        fsnotify_recalc_inode_mask_locked(inode);
 
80
 
 
81
        spin_unlock(&inode->i_lock);
 
82
}
 
83
 
 
84
/*
 
85
 * Given an inode, destroy all of the marks associated with that inode.
 
86
 */
 
87
void fsnotify_clear_marks_by_inode(struct inode *inode)
 
88
{
 
89
        struct fsnotify_mark *mark, *lmark;
 
90
        struct hlist_node *pos, *n;
 
91
        LIST_HEAD(free_list);
 
92
 
 
93
        spin_lock(&inode->i_lock);
 
94
        hlist_for_each_entry_safe(mark, pos, n, &inode->i_fsnotify_marks, i.i_list) {
 
95
                list_add(&mark->i.free_i_list, &free_list);
 
96
                hlist_del_init_rcu(&mark->i.i_list);
 
97
                fsnotify_get_mark(mark);
 
98
        }
 
99
        spin_unlock(&inode->i_lock);
 
100
 
 
101
        list_for_each_entry_safe(mark, lmark, &free_list, i.free_i_list) {
 
102
                fsnotify_destroy_mark(mark);
 
103
                fsnotify_put_mark(mark);
 
104
        }
 
105
}
 
106
 
 
107
/*
 
108
 * Given a group clear all of the inode marks associated with that group.
 
109
 */
 
110
void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
 
111
{
 
112
        fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_MARK_FLAG_INODE);
 
113
}
 
114
 
 
115
/*
 
116
 * given a group and inode, find the mark associated with that combination.
 
117
 * if found take a reference to that mark and return it, else return NULL
 
118
 */
 
119
struct fsnotify_mark *fsnotify_find_inode_mark_locked(struct fsnotify_group *group,
 
120
                                                      struct inode *inode)
 
121
{
 
122
        struct fsnotify_mark *mark;
 
123
        struct hlist_node *pos;
 
124
 
 
125
        assert_spin_locked(&inode->i_lock);
 
126
 
 
127
        hlist_for_each_entry(mark, pos, &inode->i_fsnotify_marks, i.i_list) {
 
128
                if (mark->group == group) {
 
129
                        fsnotify_get_mark(mark);
 
130
                        return mark;
 
131
                }
 
132
        }
 
133
        return NULL;
 
134
}
 
135
 
 
136
/*
 
137
 * given a group and inode, find the mark associated with that combination.
 
138
 * if found take a reference to that mark and return it, else return NULL
 
139
 */
 
140
struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group,
 
141
                                               struct inode *inode)
 
142
{
 
143
        struct fsnotify_mark *mark;
 
144
 
 
145
        spin_lock(&inode->i_lock);
 
146
        mark = fsnotify_find_inode_mark_locked(group, inode);
 
147
        spin_unlock(&inode->i_lock);
 
148
 
 
149
        return mark;
 
150
}
 
151
 
 
152
/*
 
153
 * If we are setting a mark mask on an inode mark we should pin the inode
 
154
 * in memory.
 
155
 */
 
156
void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark *mark,
 
157
                                         __u32 mask)
 
158
{
 
159
        struct inode *inode;
 
160
 
 
161
        assert_spin_locked(&mark->lock);
 
162
 
 
163
        if (mask &&
 
164
            mark->i.inode &&
 
165
            !(mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED)) {
 
166
                mark->flags |= FSNOTIFY_MARK_FLAG_OBJECT_PINNED;
 
167
                inode = igrab(mark->i.inode);
 
168
                /*
 
169
                 * we shouldn't be able to get here if the inode wasn't
 
170
                 * already safely held in memory.  But bug in case it
 
171
                 * ever is wrong.
 
172
                 */
 
173
                BUG_ON(!inode);
 
174
        }
 
175
}
 
176
 
 
177
/*
 
178
 * Attach an initialized mark to a given inode.
 
179
 * These marks may be used for the fsnotify backend to determine which
 
180
 * event types should be delivered to which group and for which inodes.  These
 
181
 * marks are ordered according to priority, highest number first, and then by
 
182
 * the group's location in memory.
 
183
 */
 
184
int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
 
185
                            struct fsnotify_group *group, struct inode *inode,
 
186
                            int allow_dups)
 
187
{
 
188
        struct fsnotify_mark *lmark;
 
189
        struct hlist_node *node, *last = NULL;
 
190
        int ret = 0;
 
191
 
 
192
        mark->flags |= FSNOTIFY_MARK_FLAG_INODE;
 
193
 
 
194
        assert_spin_locked(&mark->lock);
 
195
        assert_spin_locked(&group->mark_lock);
 
196
 
 
197
        spin_lock(&inode->i_lock);
 
198
 
 
199
        mark->i.inode = inode;
 
200
 
 
201
        /* is mark the first mark? */
 
202
        if (hlist_empty(&inode->i_fsnotify_marks)) {
 
203
                hlist_add_head_rcu(&mark->i.i_list, &inode->i_fsnotify_marks);
 
204
                goto out;
 
205
        }
 
206
 
 
207
        /* should mark be in the middle of the current list? */
 
208
        hlist_for_each_entry(lmark, node, &inode->i_fsnotify_marks, i.i_list) {
 
209
                last = node;
 
210
 
 
211
                if ((lmark->group == group) && !allow_dups) {
 
212
                        ret = -EEXIST;
 
213
                        goto out;
 
214
                }
 
215
 
 
216
                if (mark->group->priority < lmark->group->priority)
 
217
                        continue;
 
218
 
 
219
                if ((mark->group->priority == lmark->group->priority) &&
 
220
                    (mark->group < lmark->group))
 
221
                        continue;
 
222
 
 
223
                hlist_add_before_rcu(&mark->i.i_list, &lmark->i.i_list);
 
224
                goto out;
 
225
        }
 
226
 
 
227
        BUG_ON(last == NULL);
 
228
        /* mark should be the last entry.  last is the current last entry */
 
229
        hlist_add_after_rcu(last, &mark->i.i_list);
 
230
out:
 
231
        fsnotify_recalc_inode_mask_locked(inode);
 
232
        spin_unlock(&inode->i_lock);
 
233
 
 
234
        return ret;
 
235
}
 
236
 
 
237
/**
 
238
 * fsnotify_unmount_inodes - an sb is unmounting.  handle any watched inodes.
 
239
 * @list: list of inodes being unmounted (sb->s_inodes)
 
240
 *
 
241
 * Called during unmount with no locks held, so needs to be safe against
 
242
 * concurrent modifiers. We temporarily drop inode_sb_list_lock and CAN block.
 
243
 */
 
244
void fsnotify_unmount_inodes(struct list_head *list)
 
245
{
 
246
        struct inode *inode, *next_i, *need_iput = NULL;
 
247
 
 
248
        spin_lock(&inode_sb_list_lock);
 
249
        list_for_each_entry_safe(inode, next_i, list, i_sb_list) {
 
250
                struct inode *need_iput_tmp;
 
251
 
 
252
                /*
 
253
                 * We cannot __iget() an inode in state I_FREEING,
 
254
                 * I_WILL_FREE, or I_NEW which is fine because by that point
 
255
                 * the inode cannot have any associated watches.
 
256
                 */
 
257
                spin_lock(&inode->i_lock);
 
258
                if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
 
259
                        spin_unlock(&inode->i_lock);
 
260
                        continue;
 
261
                }
 
262
 
 
263
                /*
 
264
                 * If i_count is zero, the inode cannot have any watches and
 
265
                 * doing an __iget/iput with MS_ACTIVE clear would actually
 
266
                 * evict all inodes with zero i_count from icache which is
 
267
                 * unnecessarily violent and may in fact be illegal to do.
 
268
                 */
 
269
                if (!atomic_read(&inode->i_count)) {
 
270
                        spin_unlock(&inode->i_lock);
 
271
                        continue;
 
272
                }
 
273
 
 
274
                need_iput_tmp = need_iput;
 
275
                need_iput = NULL;
 
276
 
 
277
                /* In case fsnotify_inode_delete() drops a reference. */
 
278
                if (inode != need_iput_tmp)
 
279
                        __iget(inode);
 
280
                else
 
281
                        need_iput_tmp = NULL;
 
282
                spin_unlock(&inode->i_lock);
 
283
 
 
284
                /* In case the dropping of a reference would nuke next_i. */
 
285
                if ((&next_i->i_sb_list != list) &&
 
286
                    atomic_read(&next_i->i_count)) {
 
287
                        spin_lock(&next_i->i_lock);
 
288
                        if (!(next_i->i_state & (I_FREEING | I_WILL_FREE))) {
 
289
                                __iget(next_i);
 
290
                                need_iput = next_i;
 
291
                        }
 
292
                        spin_unlock(&next_i->i_lock);
 
293
                }
 
294
 
 
295
                /*
 
296
                 * We can safely drop inode_sb_list_lock here because we hold
 
297
                 * references on both inode and next_i.  Also no new inodes
 
298
                 * will be added since the umount has begun.
 
299
                 */
 
300
                spin_unlock(&inode_sb_list_lock);
 
301
 
 
302
                if (need_iput_tmp)
 
303
                        iput(need_iput_tmp);
 
304
 
 
305
                /* for each watch, send FS_UNMOUNT and then remove it */
 
306
                fsnotify(inode, FS_UNMOUNT, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
 
307
 
 
308
                fsnotify_inode_delete(inode);
 
309
 
 
310
                iput(inode);
 
311
 
 
312
                spin_lock(&inode_sb_list_lock);
 
313
        }
 
314
        spin_unlock(&inode_sb_list_lock);
 
315
}