Commit | Line | Data |
---|---|---|
5444e298 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 | |
25985edc | 27 | * and the object itself is guaranteed to survive until the reference is dropped. |
5444e298 EP |
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 | * mark->lock | |
34 | * group->mark_lock | |
35 | * inode->i_lock | |
36 | * | |
37 | * mark->lock protects 2 things, mark->group and mark->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 mark 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 mark 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> | |
75c1be48 | 88 | #include <linux/kthread.h> |
5444e298 EP |
89 | #include <linux/module.h> |
90 | #include <linux/mutex.h> | |
91 | #include <linux/slab.h> | |
92 | #include <linux/spinlock.h> | |
75c1be48 | 93 | #include <linux/srcu.h> |
5444e298 | 94 | |
60063497 | 95 | #include <linux/atomic.h> |
5444e298 EP |
96 | |
97 | #include <linux/fsnotify_backend.h> | |
98 | #include "fsnotify.h" | |
99 | ||
75c1be48 EP |
100 | struct srcu_struct fsnotify_mark_srcu; |
101 | static DEFINE_SPINLOCK(destroy_lock); | |
102 | static LIST_HEAD(destroy_list); | |
103 | static DECLARE_WAIT_QUEUE_HEAD(destroy_waitq); | |
104 | ||
5444e298 EP |
105 | void fsnotify_get_mark(struct fsnotify_mark *mark) |
106 | { | |
107 | atomic_inc(&mark->refcnt); | |
108 | } | |
109 | ||
110 | void fsnotify_put_mark(struct fsnotify_mark *mark) | |
111 | { | |
23e964c2 LS |
112 | if (atomic_dec_and_test(&mark->refcnt)) { |
113 | if (mark->group) | |
114 | fsnotify_put_group(mark->group); | |
5444e298 | 115 | mark->free_mark(mark); |
23e964c2 | 116 | } |
5444e298 EP |
117 | } |
118 | ||
119 | /* | |
120 | * Any time a mark is getting freed we end up here. | |
121 | * The caller had better be holding a reference to this mark so we don't actually | |
122 | * do the final put under the mark->lock | |
123 | */ | |
d5a335b8 LS |
124 | void fsnotify_destroy_mark_locked(struct fsnotify_mark *mark, |
125 | struct fsnotify_group *group) | |
5444e298 | 126 | { |
0d48b7f0 | 127 | struct inode *inode = NULL; |
5444e298 | 128 | |
d5a335b8 LS |
129 | BUG_ON(!mutex_is_locked(&group->mark_mutex)); |
130 | ||
104d06f0 | 131 | spin_lock(&mark->lock); |
5444e298 | 132 | |
700307a2 EP |
133 | /* something else already called this function on this mark */ |
134 | if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE)) { | |
5444e298 | 135 | spin_unlock(&mark->lock); |
e2a29943 | 136 | return; |
5444e298 EP |
137 | } |
138 | ||
700307a2 EP |
139 | mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE; |
140 | ||
0d48b7f0 | 141 | if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) { |
0d48b7f0 | 142 | inode = mark->i.inode; |
b31d397e | 143 | fsnotify_destroy_inode_mark(mark); |
0d48b7f0 EP |
144 | } else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT) |
145 | fsnotify_destroy_vfsmount_mark(mark); | |
5444e298 EP |
146 | else |
147 | BUG(); | |
148 | ||
149 | list_del_init(&mark->g_list); | |
5444e298 | 150 | |
5444e298 | 151 | spin_unlock(&mark->lock); |
d5a335b8 LS |
152 | |
153 | /* release lock temporarily */ | |
986ab098 | 154 | mutex_unlock(&group->mark_mutex); |
5444e298 | 155 | |
75c1be48 EP |
156 | spin_lock(&destroy_lock); |
157 | list_add(&mark->destroy_list, &destroy_list); | |
158 | spin_unlock(&destroy_lock); | |
159 | wake_up(&destroy_waitq); | |
160 | ||
5444e298 EP |
161 | /* |
162 | * Some groups like to know that marks are being freed. This is a | |
163 | * callback to the group function to let it know that this mark | |
164 | * is being freed. | |
165 | */ | |
166 | if (group->ops->freeing_mark) | |
167 | group->ops->freeing_mark(mark, group); | |
168 | ||
169 | /* | |
170 | * __fsnotify_update_child_dentry_flags(inode); | |
171 | * | |
172 | * I really want to call that, but we can't, we have no idea if the inode | |
173 | * still exists the second we drop the mark->lock. | |
174 | * | |
175 | * The next time an event arrive to this inode from one of it's children | |
176 | * __fsnotify_parent will see that the inode doesn't care about it's | |
177 | * children and will update all of these flags then. So really this | |
178 | * is just a lazy update (and could be a perf win...) | |
179 | */ | |
180 | ||
90b1e7a5 | 181 | if (inode && (mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED)) |
0d48b7f0 | 182 | iput(inode); |
fed47485 MS |
183 | /* |
184 | * We don't necessarily have a ref on mark from caller so the above iput | |
185 | * may have already destroyed it. Don't touch from now on. | |
186 | */ | |
187 | ||
23e964c2 | 188 | atomic_dec(&group->num_marks); |
d5a335b8 LS |
189 | |
190 | mutex_lock(&group->mark_mutex); | |
191 | } | |
192 | ||
193 | void fsnotify_destroy_mark(struct fsnotify_mark *mark, | |
194 | struct fsnotify_group *group) | |
195 | { | |
196 | mutex_lock(&group->mark_mutex); | |
197 | fsnotify_destroy_mark_locked(mark, group); | |
198 | mutex_unlock(&group->mark_mutex); | |
5444e298 EP |
199 | } |
200 | ||
90b1e7a5 EP |
201 | void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask) |
202 | { | |
203 | assert_spin_locked(&mark->lock); | |
204 | ||
205 | mark->mask = mask; | |
206 | ||
207 | if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) | |
208 | fsnotify_set_inode_mark_mask_locked(mark, mask); | |
209 | } | |
210 | ||
33af5e32 EP |
211 | void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask) |
212 | { | |
213 | assert_spin_locked(&mark->lock); | |
214 | ||
215 | mark->ignored_mask = mask; | |
216 | } | |
90b1e7a5 | 217 | |
5444e298 EP |
218 | /* |
219 | * Attach an initialized mark to a given group and fs object. | |
220 | * These marks may be used for the fsnotify backend to determine which | |
221 | * event types should be delivered to which group. | |
222 | */ | |
d5a335b8 LS |
223 | int fsnotify_add_mark_locked(struct fsnotify_mark *mark, |
224 | struct fsnotify_group *group, struct inode *inode, | |
225 | struct vfsmount *mnt, int allow_dups) | |
5444e298 EP |
226 | { |
227 | int ret = 0; | |
228 | ||
5444e298 EP |
229 | BUG_ON(inode && mnt); |
230 | BUG_ON(!inode && !mnt); | |
d5a335b8 | 231 | BUG_ON(!mutex_is_locked(&group->mark_mutex)); |
5444e298 | 232 | |
5444e298 EP |
233 | /* |
234 | * LOCKING ORDER!!!! | |
986ab098 | 235 | * group->mark_mutex |
104d06f0 | 236 | * mark->lock |
5444e298 EP |
237 | * inode->i_lock |
238 | */ | |
104d06f0 | 239 | spin_lock(&mark->lock); |
700307a2 EP |
240 | mark->flags |= FSNOTIFY_MARK_FLAG_ALIVE; |
241 | ||
23e964c2 | 242 | fsnotify_get_group(group); |
5444e298 EP |
243 | mark->group = group; |
244 | list_add(&mark->g_list, &group->marks_list); | |
245 | atomic_inc(&group->num_marks); | |
246 | fsnotify_get_mark(mark); /* for i_list and g_list */ | |
247 | ||
248 | if (inode) { | |
249 | ret = fsnotify_add_inode_mark(mark, group, inode, allow_dups); | |
250 | if (ret) | |
251 | goto err; | |
0d48b7f0 EP |
252 | } else if (mnt) { |
253 | ret = fsnotify_add_vfsmount_mark(mark, group, mnt, allow_dups); | |
254 | if (ret) | |
255 | goto err; | |
5444e298 EP |
256 | } else { |
257 | BUG(); | |
258 | } | |
259 | ||
90b1e7a5 EP |
260 | /* this will pin the object if appropriate */ |
261 | fsnotify_set_mark_mask_locked(mark, mark->mask); | |
5444e298 EP |
262 | spin_unlock(&mark->lock); |
263 | ||
264 | if (inode) | |
265 | __fsnotify_update_child_dentry_flags(inode); | |
266 | ||
267 | return ret; | |
268 | err: | |
700307a2 | 269 | mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE; |
5444e298 | 270 | list_del_init(&mark->g_list); |
23e964c2 | 271 | fsnotify_put_group(group); |
75c1be48 | 272 | mark->group = NULL; |
5444e298 | 273 | atomic_dec(&group->num_marks); |
5444e298 | 274 | |
5444e298 EP |
275 | spin_unlock(&mark->lock); |
276 | ||
75c1be48 EP |
277 | spin_lock(&destroy_lock); |
278 | list_add(&mark->destroy_list, &destroy_list); | |
279 | spin_unlock(&destroy_lock); | |
280 | wake_up(&destroy_waitq); | |
281 | ||
5444e298 EP |
282 | return ret; |
283 | } | |
284 | ||
d5a335b8 LS |
285 | int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group, |
286 | struct inode *inode, struct vfsmount *mnt, int allow_dups) | |
287 | { | |
288 | int ret; | |
289 | mutex_lock(&group->mark_mutex); | |
290 | ret = fsnotify_add_mark_locked(mark, group, inode, mnt, allow_dups); | |
291 | mutex_unlock(&group->mark_mutex); | |
292 | return ret; | |
293 | } | |
294 | ||
5444e298 | 295 | /* |
4d92604c | 296 | * clear any marks in a group in which mark->flags & flags is true |
5444e298 | 297 | */ |
4d92604c EP |
298 | void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, |
299 | unsigned int flags) | |
5444e298 EP |
300 | { |
301 | struct fsnotify_mark *lmark, *mark; | |
302 | LIST_HEAD(free_list); | |
303 | ||
986ab098 | 304 | mutex_lock(&group->mark_mutex); |
5444e298 | 305 | list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) { |
4d92604c EP |
306 | if (mark->flags & flags) { |
307 | list_add(&mark->free_g_list, &free_list); | |
308 | list_del_init(&mark->g_list); | |
309 | fsnotify_get_mark(mark); | |
310 | } | |
5444e298 | 311 | } |
986ab098 | 312 | mutex_unlock(&group->mark_mutex); |
5444e298 EP |
313 | |
314 | list_for_each_entry_safe(mark, lmark, &free_list, free_g_list) { | |
e2a29943 | 315 | fsnotify_destroy_mark(mark, group); |
5444e298 EP |
316 | fsnotify_put_mark(mark); |
317 | } | |
318 | } | |
319 | ||
4d92604c EP |
320 | /* |
321 | * Given a group, destroy all of the marks associated with that group. | |
322 | */ | |
323 | void fsnotify_clear_marks_by_group(struct fsnotify_group *group) | |
324 | { | |
325 | fsnotify_clear_marks_by_group_flags(group, (unsigned int)-1); | |
326 | } | |
327 | ||
5444e298 EP |
328 | void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old) |
329 | { | |
330 | assert_spin_locked(&old->lock); | |
331 | new->i.inode = old->i.inode; | |
332 | new->m.mnt = old->m.mnt; | |
23e964c2 LS |
333 | if (old->group) |
334 | fsnotify_get_group(old->group); | |
5444e298 EP |
335 | new->group = old->group; |
336 | new->mask = old->mask; | |
337 | new->free_mark = old->free_mark; | |
338 | } | |
339 | ||
340 | /* | |
341 | * Nothing fancy, just initialize lists and locks and counters. | |
342 | */ | |
343 | void fsnotify_init_mark(struct fsnotify_mark *mark, | |
344 | void (*free_mark)(struct fsnotify_mark *mark)) | |
345 | { | |
ba643f04 | 346 | memset(mark, 0, sizeof(*mark)); |
5444e298 EP |
347 | spin_lock_init(&mark->lock); |
348 | atomic_set(&mark->refcnt, 1); | |
5444e298 EP |
349 | mark->free_mark = free_mark; |
350 | } | |
75c1be48 EP |
351 | |
352 | static int fsnotify_mark_destroy(void *ignored) | |
353 | { | |
354 | struct fsnotify_mark *mark, *next; | |
355 | LIST_HEAD(private_destroy_list); | |
356 | ||
357 | for (;;) { | |
358 | spin_lock(&destroy_lock); | |
8778abb9 AG |
359 | /* exchange the list head */ |
360 | list_replace_init(&destroy_list, &private_destroy_list); | |
75c1be48 EP |
361 | spin_unlock(&destroy_lock); |
362 | ||
363 | synchronize_srcu(&fsnotify_mark_srcu); | |
364 | ||
365 | list_for_each_entry_safe(mark, next, &private_destroy_list, destroy_list) { | |
366 | list_del_init(&mark->destroy_list); | |
367 | fsnotify_put_mark(mark); | |
368 | } | |
369 | ||
370 | wait_event_interruptible(destroy_waitq, !list_empty(&destroy_list)); | |
371 | } | |
372 | ||
373 | return 0; | |
374 | } | |
375 | ||
376 | static int __init fsnotify_mark_init(void) | |
377 | { | |
378 | struct task_struct *thread; | |
379 | ||
380 | thread = kthread_run(fsnotify_mark_destroy, NULL, | |
381 | "fsnotify_mark"); | |
382 | if (IS_ERR(thread)) | |
383 | panic("unable to start fsnotify mark destruction thread."); | |
384 | ||
385 | return 0; | |
386 | } | |
387 | device_initcall(fsnotify_mark_init); |