]>
Commit | Line | Data |
---|---|---|
3be25f49 EP |
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 | * | |
841bdc10 | 33 | * mark->lock |
3be25f49 EP |
34 | * group->mark_lock |
35 | * inode->i_lock | |
36 | * | |
841bdc10 | 37 | * mark->lock protects 2 things, mark->group and mark->inode. You must hold |
3be25f49 EP |
38 | * that lock to dereference either of these things (they could be NULL even with |
39 | * the lock) | |
40 | * | |
e61ce867 | 41 | * group->mark_lock protects the marks_list anchored inside a given group |
841bdc10 | 42 | * and each mark is hooked via the g_list. It also sorta protects the |
3be25f49 EP |
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 | * | |
e61ce867 | 46 | * inode->i_lock protects the i_fsnotify_marks list anchored inside a |
841bdc10 | 47 | * given inode and each mark is hooked via the i_list. (and sorta the |
3be25f49 EP |
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) | |
d0775441 | 59 | * - Something explicitly requests that it be removed. (fsnotify_destroy_mark) |
3be25f49 EP |
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 | |
e61ce867 | 64 | * inode. We take i_lock and walk the i_fsnotify_marks safely. For each |
3be25f49 EP |
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> | |
3be25f49 | 90 | #include <linux/spinlock.h> |
164bc619 | 91 | #include <linux/writeback.h> /* for inode_lock */ |
3be25f49 EP |
92 | |
93 | #include <asm/atomic.h> | |
94 | ||
95 | #include <linux/fsnotify_backend.h> | |
96 | #include "fsnotify.h" | |
97 | ||
841bdc10 | 98 | void fsnotify_get_mark(struct fsnotify_mark *mark) |
3be25f49 | 99 | { |
841bdc10 | 100 | atomic_inc(&mark->refcnt); |
3be25f49 EP |
101 | } |
102 | ||
841bdc10 | 103 | void fsnotify_put_mark(struct fsnotify_mark *mark) |
3be25f49 | 104 | { |
841bdc10 EP |
105 | if (atomic_dec_and_test(&mark->refcnt)) |
106 | mark->free_mark(mark); | |
3be25f49 EP |
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 | { | |
841bdc10 | 114 | struct fsnotify_mark *mark; |
3be25f49 EP |
115 | struct hlist_node *pos; |
116 | __u32 new_mask = 0; | |
117 | ||
118 | assert_spin_locked(&inode->i_lock); | |
119 | ||
841bdc10 EP |
120 | hlist_for_each_entry(mark, pos, &inode->i_fsnotify_marks, i.i_list) |
121 | new_mask |= mark->mask; | |
3be25f49 EP |
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); | |
c28f7e56 EP |
134 | |
135 | __fsnotify_update_child_dentry_flags(inode); | |
3be25f49 EP |
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 | |
841bdc10 | 141 | * do the final put under the mark->lock |
3be25f49 | 142 | */ |
841bdc10 | 143 | void fsnotify_destroy_mark(struct fsnotify_mark *mark) |
3be25f49 EP |
144 | { |
145 | struct fsnotify_group *group; | |
146 | struct inode *inode; | |
147 | ||
841bdc10 | 148 | spin_lock(&mark->lock); |
3be25f49 | 149 | |
841bdc10 EP |
150 | group = mark->group; |
151 | inode = mark->i.inode; | |
3be25f49 EP |
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) { | |
841bdc10 | 158 | spin_unlock(&mark->lock); |
3be25f49 EP |
159 | return; |
160 | } | |
161 | ||
162 | /* 1 from caller and 1 for being on i_list/g_list */ | |
841bdc10 | 163 | BUG_ON(atomic_read(&mark->refcnt) < 2); |
3be25f49 EP |
164 | |
165 | spin_lock(&group->mark_lock); | |
166 | spin_lock(&inode->i_lock); | |
167 | ||
841bdc10 EP |
168 | hlist_del_init(&mark->i.i_list); |
169 | mark->i.inode = NULL; | |
3be25f49 | 170 | |
841bdc10 EP |
171 | list_del_init(&mark->g_list); |
172 | mark->group = NULL; | |
3be25f49 | 173 | |
841bdc10 | 174 | fsnotify_put_mark(mark); /* for i_list and g_list */ |
3be25f49 EP |
175 | |
176 | /* | |
e61ce867 | 177 | * this mark is now off the inode->i_fsnotify_marks list and we |
3be25f49 EP |
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); | |
841bdc10 | 185 | spin_unlock(&mark->lock); |
3be25f49 EP |
186 | |
187 | /* | |
188 | * Some groups like to know that marks are being freed. This is a | |
841bdc10 | 189 | * callback to the group function to let it know that this mark |
3be25f49 EP |
190 | * is being freed. |
191 | */ | |
a092ee20 | 192 | if (group->ops->freeing_mark) |
841bdc10 | 193 | group->ops->freeing_mark(mark, group); |
3be25f49 | 194 | |
c28f7e56 EP |
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 | |
841bdc10 | 199 | * still exists the second we drop the mark->lock. |
c28f7e56 EP |
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 | ||
1ef5f13c EP |
208 | iput(inode); |
209 | ||
3be25f49 EP |
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 | { | |
841bdc10 | 224 | struct fsnotify_mark *lmark, *mark; |
3be25f49 EP |
225 | LIST_HEAD(free_list); |
226 | ||
227 | spin_lock(&group->mark_lock); | |
841bdc10 EP |
228 | list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) { |
229 | list_add(&mark->free_g_list, &free_list); | |
230 | list_del_init(&mark->g_list); | |
231 | fsnotify_get_mark(mark); | |
3be25f49 EP |
232 | } |
233 | spin_unlock(&group->mark_lock); | |
234 | ||
841bdc10 EP |
235 | list_for_each_entry_safe(mark, lmark, &free_list, free_g_list) { |
236 | fsnotify_destroy_mark(mark); | |
237 | fsnotify_put_mark(mark); | |
3be25f49 EP |
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 | { | |
841bdc10 | 246 | struct fsnotify_mark *mark, *lmark; |
3be25f49 EP |
247 | struct hlist_node *pos, *n; |
248 | LIST_HEAD(free_list); | |
249 | ||
250 | spin_lock(&inode->i_lock); | |
841bdc10 EP |
251 | hlist_for_each_entry_safe(mark, pos, n, &inode->i_fsnotify_marks, i.i_list) { |
252 | list_add(&mark->i.free_i_list, &free_list); | |
253 | hlist_del_init(&mark->i.i_list); | |
254 | fsnotify_get_mark(mark); | |
3be25f49 EP |
255 | } |
256 | spin_unlock(&inode->i_lock); | |
257 | ||
841bdc10 EP |
258 | list_for_each_entry_safe(mark, lmark, &free_list, i.free_i_list) { |
259 | fsnotify_destroy_mark(mark); | |
260 | fsnotify_put_mark(mark); | |
3be25f49 EP |
261 | } |
262 | } | |
263 | ||
35566087 AG |
264 | static struct fsnotify_mark *fsnotify_find_mark_locked(struct fsnotify_group *group, |
265 | struct inode *inode) | |
3be25f49 | 266 | { |
841bdc10 | 267 | struct fsnotify_mark *mark; |
3be25f49 EP |
268 | struct hlist_node *pos; |
269 | ||
270 | assert_spin_locked(&inode->i_lock); | |
271 | ||
841bdc10 EP |
272 | hlist_for_each_entry(mark, pos, &inode->i_fsnotify_marks, i.i_list) { |
273 | if (mark->group == group) { | |
274 | fsnotify_get_mark(mark); | |
275 | return mark; | |
3be25f49 EP |
276 | } |
277 | } | |
278 | return NULL; | |
279 | } | |
280 | ||
35566087 AG |
281 | /* |
282 | * given a group and inode, find the mark associated with that combination. | |
283 | * if found take a reference to that mark and return it, else return NULL | |
284 | */ | |
285 | struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_group *group, | |
286 | struct inode *inode) | |
287 | { | |
288 | struct fsnotify_mark *mark; | |
289 | ||
290 | spin_lock(&inode->i_lock); | |
291 | mark = fsnotify_find_mark_locked(group, inode); | |
292 | spin_unlock(&inode->i_lock); | |
293 | ||
294 | return mark; | |
295 | } | |
296 | ||
e61ce867 | 297 | void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old) |
9e1c7432 EP |
298 | { |
299 | assert_spin_locked(&old->lock); | |
2823e04d | 300 | new->i.inode = old->i.inode; |
9e1c7432 EP |
301 | new->group = old->group; |
302 | new->mask = old->mask; | |
303 | new->free_mark = old->free_mark; | |
304 | } | |
305 | ||
3be25f49 EP |
306 | /* |
307 | * Nothing fancy, just initialize lists and locks and counters. | |
308 | */ | |
841bdc10 EP |
309 | void fsnotify_init_mark(struct fsnotify_mark *mark, |
310 | void (*free_mark)(struct fsnotify_mark *mark)) | |
3be25f49 | 311 | { |
841bdc10 EP |
312 | spin_lock_init(&mark->lock); |
313 | atomic_set(&mark->refcnt, 1); | |
314 | INIT_HLIST_NODE(&mark->i.i_list); | |
315 | mark->group = NULL; | |
316 | mark->mask = 0; | |
317 | mark->i.inode = NULL; | |
318 | mark->free_mark = free_mark; | |
3be25f49 EP |
319 | } |
320 | ||
321 | /* | |
841bdc10 | 322 | * Attach an initialized mark mark to a given group and inode. |
3be25f49 EP |
323 | * These marks may be used for the fsnotify backend to determine which |
324 | * event types should be delivered to which group and for which inodes. | |
325 | */ | |
841bdc10 | 326 | int fsnotify_add_mark(struct fsnotify_mark *mark, |
40554c3d EP |
327 | struct fsnotify_group *group, struct inode *inode, |
328 | int allow_dups) | |
3be25f49 | 329 | { |
841bdc10 | 330 | struct fsnotify_mark *lmark = NULL; |
3be25f49 EP |
331 | int ret = 0; |
332 | ||
1ef5f13c EP |
333 | inode = igrab(inode); |
334 | if (unlikely(!inode)) | |
335 | return -EINVAL; | |
336 | ||
841bdc10 | 337 | mark->flags = FSNOTIFY_MARK_FLAG_INODE; |
098cf2fc | 338 | |
4ca76352 EP |
339 | /* |
340 | * if this group isn't being testing for inode type events we need | |
341 | * to start testing | |
342 | */ | |
343 | if (unlikely(list_empty(&group->inode_group_list))) | |
344 | fsnotify_add_inode_group(group); | |
7131485a EP |
345 | /* |
346 | * XXX This is where we could also do the fsnotify_add_vfsmount_group | |
347 | * if we are setting and vfsmount mark.... | |
348 | ||
349 | if (unlikely(list_empty(&group->vfsmount_group_list))) | |
350 | fsnotify_add_vfsmount_group(group); | |
351 | */ | |
4ca76352 | 352 | |
3be25f49 EP |
353 | /* |
354 | * LOCKING ORDER!!!! | |
841bdc10 | 355 | * mark->lock |
3be25f49 EP |
356 | * group->mark_lock |
357 | * inode->i_lock | |
358 | */ | |
841bdc10 | 359 | spin_lock(&mark->lock); |
3be25f49 EP |
360 | spin_lock(&group->mark_lock); |
361 | spin_lock(&inode->i_lock); | |
362 | ||
40554c3d | 363 | if (!allow_dups) |
35566087 | 364 | lmark = fsnotify_find_mark_locked(group, inode); |
841bdc10 EP |
365 | if (!lmark) { |
366 | mark->group = group; | |
367 | mark->i.inode = inode; | |
9f0d793b | 368 | |
841bdc10 EP |
369 | hlist_add_head(&mark->i.i_list, &inode->i_fsnotify_marks); |
370 | list_add(&mark->g_list, &group->marks_list); | |
3be25f49 | 371 | |
841bdc10 | 372 | fsnotify_get_mark(mark); /* for i_list and g_list */ |
3be25f49 EP |
373 | |
374 | atomic_inc(&group->num_marks); | |
375 | ||
376 | fsnotify_recalc_inode_mask_locked(inode); | |
377 | } | |
378 | ||
379 | spin_unlock(&inode->i_lock); | |
380 | spin_unlock(&group->mark_lock); | |
841bdc10 | 381 | spin_unlock(&mark->lock); |
3be25f49 | 382 | |
841bdc10 | 383 | if (lmark) { |
3be25f49 | 384 | ret = -EEXIST; |
1ef5f13c | 385 | iput(inode); |
841bdc10 | 386 | fsnotify_put_mark(lmark); |
c28f7e56 EP |
387 | } else { |
388 | __fsnotify_update_child_dentry_flags(inode); | |
3be25f49 EP |
389 | } |
390 | ||
391 | return ret; | |
392 | } | |
164bc619 EP |
393 | |
394 | /** | |
395 | * fsnotify_unmount_inodes - an sb is unmounting. handle any watched inodes. | |
396 | * @list: list of inodes being unmounted (sb->s_inodes) | |
397 | * | |
398 | * Called with inode_lock held, protecting the unmounting super block's list | |
399 | * of inodes, and with iprune_mutex held, keeping shrink_icache_memory() at bay. | |
400 | * We temporarily drop inode_lock, however, and CAN block. | |
401 | */ | |
402 | void fsnotify_unmount_inodes(struct list_head *list) | |
403 | { | |
404 | struct inode *inode, *next_i, *need_iput = NULL; | |
405 | ||
406 | list_for_each_entry_safe(inode, next_i, list, i_sb_list) { | |
407 | struct inode *need_iput_tmp; | |
408 | ||
409 | /* | |
410 | * We cannot __iget() an inode in state I_CLEAR, I_FREEING, | |
411 | * I_WILL_FREE, or I_NEW which is fine because by that point | |
412 | * the inode cannot have any associated watches. | |
413 | */ | |
414 | if (inode->i_state & (I_CLEAR|I_FREEING|I_WILL_FREE|I_NEW)) | |
415 | continue; | |
416 | ||
417 | /* | |
418 | * If i_count is zero, the inode cannot have any watches and | |
419 | * doing an __iget/iput with MS_ACTIVE clear would actually | |
420 | * evict all inodes with zero i_count from icache which is | |
421 | * unnecessarily violent and may in fact be illegal to do. | |
422 | */ | |
423 | if (!atomic_read(&inode->i_count)) | |
424 | continue; | |
425 | ||
426 | need_iput_tmp = need_iput; | |
427 | need_iput = NULL; | |
428 | ||
429 | /* In case fsnotify_inode_delete() drops a reference. */ | |
430 | if (inode != need_iput_tmp) | |
431 | __iget(inode); | |
432 | else | |
433 | need_iput_tmp = NULL; | |
434 | ||
435 | /* In case the dropping of a reference would nuke next_i. */ | |
436 | if ((&next_i->i_sb_list != list) && | |
437 | atomic_read(&next_i->i_count) && | |
438 | !(next_i->i_state & (I_CLEAR | I_FREEING | I_WILL_FREE))) { | |
439 | __iget(next_i); | |
440 | need_iput = next_i; | |
441 | } | |
442 | ||
443 | /* | |
444 | * We can safely drop inode_lock here because we hold | |
445 | * references on both inode and next_i. Also no new inodes | |
446 | * will be added since the umount has begun. Finally, | |
447 | * iprune_mutex keeps shrink_icache_memory() away. | |
448 | */ | |
449 | spin_unlock(&inode_lock); | |
450 | ||
451 | if (need_iput_tmp) | |
452 | iput(need_iput_tmp); | |
453 | ||
454 | /* for each watch, send FS_UNMOUNT and then remove it */ | |
455 | fsnotify(inode, FS_UNMOUNT, inode, FSNOTIFY_EVENT_INODE, NULL, 0); | |
456 | ||
457 | fsnotify_inode_delete(inode); | |
458 | ||
459 | iput(inode); | |
460 | ||
461 | spin_lock(&inode_lock); | |
462 | } | |
463 | } |