Loading...
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 inode->i_fsnotify_mask, or the mask of all FS_* event types
35 * any notifier is interested in hearing for this inode.
36 */
37void fsnotify_recalc_inode_mask(struct inode *inode)
38{
39 spin_lock(&inode->i_lock);
40 inode->i_fsnotify_mask = fsnotify_recalc_mask(&inode->i_fsnotify_marks);
41 spin_unlock(&inode->i_lock);
42
43 __fsnotify_update_child_dentry_flags(inode);
44}
45
46void fsnotify_destroy_inode_mark(struct fsnotify_mark *mark)
47{
48 struct inode *inode = mark->inode;
49
50 BUG_ON(!mutex_is_locked(&mark->group->mark_mutex));
51 assert_spin_locked(&mark->lock);
52
53 spin_lock(&inode->i_lock);
54
55 hlist_del_init_rcu(&mark->obj_list);
56 mark->inode = NULL;
57
58 /*
59 * this mark is now off the inode->i_fsnotify_marks list and we
60 * hold the inode->i_lock, so this is the perfect time to update the
61 * inode->i_fsnotify_mask
62 */
63 inode->i_fsnotify_mask = fsnotify_recalc_mask(&inode->i_fsnotify_marks);
64 spin_unlock(&inode->i_lock);
65}
66
67/*
68 * Given a group clear all of the inode marks associated with that group.
69 */
70void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
71{
72 fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_MARK_FLAG_INODE);
73}
74
75/*
76 * given a group and inode, find the mark associated with that combination.
77 * if found take a reference to that mark and return it, else return NULL
78 */
79struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group,
80 struct inode *inode)
81{
82 struct fsnotify_mark *mark;
83
84 spin_lock(&inode->i_lock);
85 mark = fsnotify_find_mark(&inode->i_fsnotify_marks, group);
86 spin_unlock(&inode->i_lock);
87
88 return mark;
89}
90
91/*
92 * If we are setting a mark mask on an inode mark we should pin the inode
93 * in memory.
94 */
95void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark *mark,
96 __u32 mask)
97{
98 struct inode *inode;
99
100 assert_spin_locked(&mark->lock);
101
102 if (mask &&
103 mark->inode &&
104 !(mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED)) {
105 mark->flags |= FSNOTIFY_MARK_FLAG_OBJECT_PINNED;
106 inode = igrab(mark->inode);
107 /*
108 * we shouldn't be able to get here if the inode wasn't
109 * already safely held in memory. But bug in case it
110 * ever is wrong.
111 */
112 BUG_ON(!inode);
113 }
114}
115
116/*
117 * Attach an initialized mark to a given inode.
118 * These marks may be used for the fsnotify backend to determine which
119 * event types should be delivered to which group and for which inodes. These
120 * marks are ordered according to priority, highest number first, and then by
121 * the group's location in memory.
122 */
123int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
124 struct fsnotify_group *group, struct inode *inode,
125 int allow_dups)
126{
127 int ret;
128
129 mark->flags |= FSNOTIFY_MARK_FLAG_INODE;
130
131 BUG_ON(!mutex_is_locked(&group->mark_mutex));
132 assert_spin_locked(&mark->lock);
133
134 spin_lock(&inode->i_lock);
135 mark->inode = inode;
136 ret = fsnotify_add_mark_list(&inode->i_fsnotify_marks, mark,
137 allow_dups);
138 inode->i_fsnotify_mask = fsnotify_recalc_mask(&inode->i_fsnotify_marks);
139 spin_unlock(&inode->i_lock);
140
141 return ret;
142}
143
144/**
145 * fsnotify_unmount_inodes - an sb is unmounting. handle any watched inodes.
146 * @sb: superblock being unmounted.
147 *
148 * Called during unmount with no locks held, so needs to be safe against
149 * concurrent modifiers. We temporarily drop sb->s_inode_list_lock and CAN block.
150 */
151void fsnotify_unmount_inodes(struct super_block *sb)
152{
153 struct inode *inode, *next_i, *need_iput = NULL;
154
155 spin_lock(&sb->s_inode_list_lock);
156 list_for_each_entry_safe(inode, next_i, &sb->s_inodes, i_sb_list) {
157 struct inode *need_iput_tmp;
158
159 /*
160 * We cannot __iget() an inode in state I_FREEING,
161 * I_WILL_FREE, or I_NEW which is fine because by that point
162 * the inode cannot have any associated watches.
163 */
164 spin_lock(&inode->i_lock);
165 if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
166 spin_unlock(&inode->i_lock);
167 continue;
168 }
169
170 /*
171 * If i_count is zero, the inode cannot have any watches and
172 * doing an __iget/iput with MS_ACTIVE clear would actually
173 * evict all inodes with zero i_count from icache which is
174 * unnecessarily violent and may in fact be illegal to do.
175 */
176 if (!atomic_read(&inode->i_count)) {
177 spin_unlock(&inode->i_lock);
178 continue;
179 }
180
181 need_iput_tmp = need_iput;
182 need_iput = NULL;
183
184 /* In case fsnotify_inode_delete() drops a reference. */
185 if (inode != need_iput_tmp)
186 __iget(inode);
187 else
188 need_iput_tmp = NULL;
189 spin_unlock(&inode->i_lock);
190
191 /* In case the dropping of a reference would nuke next_i. */
192 while (&next_i->i_sb_list != &sb->s_inodes) {
193 spin_lock(&next_i->i_lock);
194 if (!(next_i->i_state & (I_FREEING | I_WILL_FREE)) &&
195 atomic_read(&next_i->i_count)) {
196 __iget(next_i);
197 need_iput = next_i;
198 spin_unlock(&next_i->i_lock);
199 break;
200 }
201 spin_unlock(&next_i->i_lock);
202 next_i = list_next_entry(next_i, i_sb_list);
203 }
204
205 /*
206 * We can safely drop s_inode_list_lock here because either
207 * we actually hold references on both inode and next_i or
208 * end of list. Also no new inodes will be added since the
209 * umount has begun.
210 */
211 spin_unlock(&sb->s_inode_list_lock);
212
213 if (need_iput_tmp)
214 iput(need_iput_tmp);
215
216 /* for each watch, send FS_UNMOUNT and then remove it */
217 fsnotify(inode, FS_UNMOUNT, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
218
219 fsnotify_inode_delete(inode);
220
221 iput(inode);
222
223 spin_lock(&sb->s_inode_list_lock);
224 }
225 spin_unlock(&sb->s_inode_list_lock);
226}
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 */
36static 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 */
53void 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
62void 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 */
87void 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 */
110void 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 */
119struct 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 */
140struct 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 */
156void 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 */
184int 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);
230out:
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 */
244void 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}