2 * Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
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)
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.
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.
20 * fsnotify inode mark locking/lifetime/and refcnting
23 * The group->recnt and mark->refcnt tell how many "things" in the kernel
24 * currently are referencing the objects. Both kind of objects typically will
25 * live inside the kernel with a refcnt of 2, one for its creation and one for
26 * the reference a group and a mark hold to each other.
27 * If you are holding the appropriate locks, you can take a reference and the
28 * object itself is guaranteed to survive until the reference is dropped.
31 * There are 3 locks involved with fsnotify inode marks and they MUST be taken
32 * in order as follows:
36 * mark->connector->lock
38 * group->mark_mutex protects the marks_list anchored inside a given group and
39 * each mark is hooked via the g_list. It also protects the groups private
40 * data (i.e group limits).
42 * mark->lock protects the marks attributes like its masks and flags.
43 * Furthermore it protects the access to a reference of the group that the mark
44 * is assigned to as well as the access to a reference of the inode/vfsmount
45 * that is being watched by the mark.
47 * mark->connector->lock protects the list of marks anchored inside an
48 * inode / vfsmount and each mark is hooked via the i_list.
50 * A list of notification marks relating to inode / mnt is contained in
51 * fsnotify_mark_connector. That structure is alive as long as there are any
52 * marks in the list and is also protected by fsnotify_mark_srcu. A mark gets
53 * detached from fsnotify_mark_connector when last reference to the mark is
54 * dropped. Thus having mark reference is enough to protect mark->connector
55 * pointer and to make sure fsnotify_mark_connector cannot disappear. Also
56 * because we remove mark from g_list before dropping mark reference associated
57 * with that, any mark found through g_list is guaranteed to have
58 * mark->connector set until we drop group->mark_mutex.
61 * Inode marks survive between when they are added to an inode and when their
62 * refcnt==0. Marks are also protected by fsnotify_mark_srcu.
64 * The inode mark can be cleared for a number of different reasons including:
65 * - The inode is unlinked for the last time. (fsnotify_inode_remove)
66 * - The inode is being evicted from cache. (fsnotify_inode_delete)
67 * - The fs the inode is on is unmounted. (fsnotify_inode_delete/fsnotify_unmount_inodes)
68 * - Something explicitly requests that it be removed. (fsnotify_destroy_mark)
69 * - The fsnotify_group associated with the mark is going away and all such marks
70 * need to be cleaned up. (fsnotify_clear_marks_by_group)
72 * This has the very interesting property of being able to run concurrently with
73 * any (or all) other directions.
77 #include <linux/init.h>
78 #include <linux/kernel.h>
79 #include <linux/kthread.h>
80 #include <linux/module.h>
81 #include <linux/mutex.h>
82 #include <linux/slab.h>
83 #include <linux/spinlock.h>
84 #include <linux/srcu.h>
86 #include <linux/atomic.h>
88 #include <linux/fsnotify_backend.h>
91 #define FSNOTIFY_REAPER_DELAY (1) /* 1 jiffy */
93 struct srcu_struct fsnotify_mark_srcu;
94 struct kmem_cache *fsnotify_mark_connector_cachep;
96 static DEFINE_SPINLOCK(destroy_lock);
97 static LIST_HEAD(destroy_list);
98 static struct fsnotify_mark_connector *connector_destroy_list;
100 static void fsnotify_mark_destroy_workfn(struct work_struct *work);
101 static DECLARE_DELAYED_WORK(reaper_work, fsnotify_mark_destroy_workfn);
103 static void fsnotify_connector_destroy_workfn(struct work_struct *work);
104 static DECLARE_WORK(connector_reaper_work, fsnotify_connector_destroy_workfn);
106 void fsnotify_get_mark(struct fsnotify_mark *mark)
108 WARN_ON_ONCE(!refcount_read(&mark->refcnt));
109 refcount_inc(&mark->refcnt);
112 static __u32 *fsnotify_conn_mask_p(struct fsnotify_mark_connector *conn)
114 if (conn->type == FSNOTIFY_OBJ_TYPE_INODE)
115 return &fsnotify_conn_inode(conn)->i_fsnotify_mask;
116 else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT)
117 return &fsnotify_conn_mount(conn)->mnt_fsnotify_mask;
118 else if (conn->type == FSNOTIFY_OBJ_TYPE_SB)
119 return &fsnotify_conn_sb(conn)->s_fsnotify_mask;
123 __u32 fsnotify_conn_mask(struct fsnotify_mark_connector *conn)
125 if (WARN_ON(!fsnotify_valid_obj_type(conn->type)))
128 return *fsnotify_conn_mask_p(conn);
131 static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
134 struct fsnotify_mark *mark;
136 assert_spin_locked(&conn->lock);
137 /* We can get detached connector here when inode is getting unlinked. */
138 if (!fsnotify_valid_obj_type(conn->type))
140 hlist_for_each_entry(mark, &conn->list, obj_list) {
141 if (mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)
142 new_mask |= mark->mask;
144 *fsnotify_conn_mask_p(conn) = new_mask;
148 * Calculate mask of events for a list of marks. The caller must make sure
149 * connector and connector->obj cannot disappear under us. Callers achieve
150 * this by holding a mark->lock or mark->group->mark_mutex for a mark on this
153 void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
158 spin_lock(&conn->lock);
159 __fsnotify_recalc_mask(conn);
160 spin_unlock(&conn->lock);
161 if (conn->type == FSNOTIFY_OBJ_TYPE_INODE)
162 __fsnotify_update_child_dentry_flags(
163 fsnotify_conn_inode(conn));
166 /* Free all connectors queued for freeing once SRCU period ends */
167 static void fsnotify_connector_destroy_workfn(struct work_struct *work)
169 struct fsnotify_mark_connector *conn, *free;
171 spin_lock(&destroy_lock);
172 conn = connector_destroy_list;
173 connector_destroy_list = NULL;
174 spin_unlock(&destroy_lock);
176 synchronize_srcu(&fsnotify_mark_srcu);
179 conn = conn->destroy_next;
180 kmem_cache_free(fsnotify_mark_connector_cachep, free);
184 static struct inode *fsnotify_detach_connector_from_object(
185 struct fsnotify_mark_connector *conn)
187 struct inode *inode = NULL;
189 if (conn->type == FSNOTIFY_OBJ_TYPE_DETACHED)
192 if (conn->type == FSNOTIFY_OBJ_TYPE_INODE) {
193 inode = fsnotify_conn_inode(conn);
194 inode->i_fsnotify_mask = 0;
195 } else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
196 fsnotify_conn_mount(conn)->mnt_fsnotify_mask = 0;
197 } else if (conn->type == FSNOTIFY_OBJ_TYPE_SB) {
198 fsnotify_conn_sb(conn)->s_fsnotify_mask = 0;
201 rcu_assign_pointer(*(conn->obj), NULL);
203 conn->type = FSNOTIFY_OBJ_TYPE_DETACHED;
208 static void fsnotify_final_mark_destroy(struct fsnotify_mark *mark)
210 struct fsnotify_group *group = mark->group;
212 if (WARN_ON_ONCE(!group))
214 group->ops->free_mark(mark);
215 fsnotify_put_group(group);
218 void fsnotify_put_mark(struct fsnotify_mark *mark)
220 struct fsnotify_mark_connector *conn;
221 struct inode *inode = NULL;
222 bool free_conn = false;
224 /* Catch marks that were actually never attached to object */
225 if (!mark->connector) {
226 if (refcount_dec_and_test(&mark->refcnt))
227 fsnotify_final_mark_destroy(mark);
232 * We have to be careful so that traversals of obj_list under lock can
233 * safely grab mark reference.
235 if (!refcount_dec_and_lock(&mark->refcnt, &mark->connector->lock))
238 conn = mark->connector;
239 hlist_del_init_rcu(&mark->obj_list);
240 if (hlist_empty(&conn->list)) {
241 inode = fsnotify_detach_connector_from_object(conn);
244 __fsnotify_recalc_mask(conn);
246 mark->connector = NULL;
247 spin_unlock(&conn->lock);
252 spin_lock(&destroy_lock);
253 conn->destroy_next = connector_destroy_list;
254 connector_destroy_list = conn;
255 spin_unlock(&destroy_lock);
256 queue_work(system_unbound_wq, &connector_reaper_work);
259 * Note that we didn't update flags telling whether inode cares about
260 * what's happening with children. We update these flags from
261 * __fsnotify_parent() lazily when next event happens on one of our
264 spin_lock(&destroy_lock);
265 list_add(&mark->g_list, &destroy_list);
266 spin_unlock(&destroy_lock);
267 queue_delayed_work(system_unbound_wq, &reaper_work,
268 FSNOTIFY_REAPER_DELAY);
272 * Get mark reference when we found the mark via lockless traversal of object
273 * list. Mark can be already removed from the list by now and on its way to be
274 * destroyed once SRCU period ends.
276 * Also pin the group so it doesn't disappear under us.
278 static bool fsnotify_get_mark_safe(struct fsnotify_mark *mark)
283 if (refcount_inc_not_zero(&mark->refcnt)) {
284 spin_lock(&mark->lock);
285 if (mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) {
286 /* mark is attached, group is still alive then */
287 atomic_inc(&mark->group->user_waits);
288 spin_unlock(&mark->lock);
291 spin_unlock(&mark->lock);
292 fsnotify_put_mark(mark);
298 * Puts marks and wakes up group destruction if necessary.
300 * Pairs with fsnotify_get_mark_safe()
302 static void fsnotify_put_mark_wake(struct fsnotify_mark *mark)
305 struct fsnotify_group *group = mark->group;
307 fsnotify_put_mark(mark);
309 * We abuse notification_waitq on group shutdown for waiting for
310 * all marks pinned when waiting for userspace.
312 if (atomic_dec_and_test(&group->user_waits) && group->shutdown)
313 wake_up(&group->notification_waitq);
317 bool fsnotify_prepare_user_wait(struct fsnotify_iter_info *iter_info)
321 fsnotify_foreach_obj_type(type) {
322 /* This can fail if mark is being removed */
323 if (!fsnotify_get_mark_safe(iter_info->marks[type]))
328 * Now that both marks are pinned by refcount in the inode / vfsmount
329 * lists, we can drop SRCU lock, and safely resume the list iteration
330 * once userspace returns.
332 srcu_read_unlock(&fsnotify_mark_srcu, iter_info->srcu_idx);
337 for (type--; type >= 0; type--)
338 fsnotify_put_mark_wake(iter_info->marks[type]);
342 void fsnotify_finish_user_wait(struct fsnotify_iter_info *iter_info)
346 iter_info->srcu_idx = srcu_read_lock(&fsnotify_mark_srcu);
347 fsnotify_foreach_obj_type(type)
348 fsnotify_put_mark_wake(iter_info->marks[type]);
352 * Mark mark as detached, remove it from group list. Mark still stays in object
353 * list until its last reference is dropped. Note that we rely on mark being
354 * removed from group list before corresponding reference to it is dropped. In
355 * particular we rely on mark->connector being valid while we hold
356 * group->mark_mutex if we found the mark through g_list.
358 * Must be called with group->mark_mutex held. The caller must either hold
359 * reference to the mark or be protected by fsnotify_mark_srcu.
361 void fsnotify_detach_mark(struct fsnotify_mark *mark)
363 struct fsnotify_group *group = mark->group;
365 WARN_ON_ONCE(!mutex_is_locked(&group->mark_mutex));
366 WARN_ON_ONCE(!srcu_read_lock_held(&fsnotify_mark_srcu) &&
367 refcount_read(&mark->refcnt) < 1 +
368 !!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED));
370 spin_lock(&mark->lock);
371 /* something else already called this function on this mark */
372 if (!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
373 spin_unlock(&mark->lock);
376 mark->flags &= ~FSNOTIFY_MARK_FLAG_ATTACHED;
377 list_del_init(&mark->g_list);
378 spin_unlock(&mark->lock);
380 atomic_dec(&group->num_marks);
382 /* Drop mark reference acquired in fsnotify_add_mark_locked() */
383 fsnotify_put_mark(mark);
387 * Free fsnotify mark. The mark is actually only marked as being freed. The
388 * freeing is actually happening only once last reference to the mark is
389 * dropped from a workqueue which first waits for srcu period end.
391 * Caller must have a reference to the mark or be protected by
392 * fsnotify_mark_srcu.
394 void fsnotify_free_mark(struct fsnotify_mark *mark)
396 struct fsnotify_group *group = mark->group;
398 spin_lock(&mark->lock);
399 /* something else already called this function on this mark */
400 if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE)) {
401 spin_unlock(&mark->lock);
404 mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE;
405 spin_unlock(&mark->lock);
408 * Some groups like to know that marks are being freed. This is a
409 * callback to the group function to let it know that this mark
412 if (group->ops->freeing_mark)
413 group->ops->freeing_mark(mark, group);
416 void fsnotify_destroy_mark(struct fsnotify_mark *mark,
417 struct fsnotify_group *group)
419 mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
420 fsnotify_detach_mark(mark);
421 mutex_unlock(&group->mark_mutex);
422 fsnotify_free_mark(mark);
426 * Sorting function for lists of fsnotify marks.
428 * Fanotify supports different notification classes (reflected as priority of
429 * notification group). Events shall be passed to notification groups in
430 * decreasing priority order. To achieve this marks in notification lists for
431 * inodes and vfsmounts are sorted so that priorities of corresponding groups
434 * Furthermore correct handling of the ignore mask requires processing inode
435 * and vfsmount marks of each group together. Using the group address as
436 * further sort criterion provides a unique sorting order and thus we can
437 * merge inode and vfsmount lists of marks in linear time and find groups
438 * present in both lists.
440 * A return value of 1 signifies that b has priority over a.
441 * A return value of 0 signifies that the two marks have to be handled together.
442 * A return value of -1 signifies that a has priority over b.
444 int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b)
452 if (a->priority < b->priority)
454 if (a->priority > b->priority)
461 static int fsnotify_attach_connector_to_object(fsnotify_connp_t *connp,
464 struct inode *inode = NULL;
465 struct fsnotify_mark_connector *conn;
467 conn = kmem_cache_alloc(fsnotify_mark_connector_cachep, GFP_KERNEL);
470 spin_lock_init(&conn->lock);
471 INIT_HLIST_HEAD(&conn->list);
474 if (conn->type == FSNOTIFY_OBJ_TYPE_INODE)
475 inode = igrab(fsnotify_conn_inode(conn));
477 * cmpxchg() provides the barrier so that readers of *connp can see
478 * only initialized structure
480 if (cmpxchg(connp, NULL, conn)) {
481 /* Someone else created list structure for us */
484 kmem_cache_free(fsnotify_mark_connector_cachep, conn);
491 * Get mark connector, make sure it is alive and return with its lock held.
492 * This is for users that get connector pointer from inode or mount. Users that
493 * hold reference to a mark on the list may directly lock connector->lock as
494 * they are sure list cannot go away under them.
496 static struct fsnotify_mark_connector *fsnotify_grab_connector(
497 fsnotify_connp_t *connp)
499 struct fsnotify_mark_connector *conn;
502 idx = srcu_read_lock(&fsnotify_mark_srcu);
503 conn = srcu_dereference(*connp, &fsnotify_mark_srcu);
506 spin_lock(&conn->lock);
507 if (conn->type == FSNOTIFY_OBJ_TYPE_DETACHED) {
508 spin_unlock(&conn->lock);
509 srcu_read_unlock(&fsnotify_mark_srcu, idx);
513 srcu_read_unlock(&fsnotify_mark_srcu, idx);
518 * Add mark into proper place in given list of marks. These marks may be used
519 * for the fsnotify backend to determine which event types should be delivered
520 * to which group and for which inodes. These marks are ordered according to
521 * priority, highest number first, and then by the group's location in memory.
523 static int fsnotify_add_mark_list(struct fsnotify_mark *mark,
524 fsnotify_connp_t *connp, unsigned int type,
527 struct fsnotify_mark *lmark, *last = NULL;
528 struct fsnotify_mark_connector *conn;
532 if (WARN_ON(!fsnotify_valid_obj_type(type)))
535 spin_lock(&mark->lock);
536 conn = fsnotify_grab_connector(connp);
538 spin_unlock(&mark->lock);
539 err = fsnotify_attach_connector_to_object(connp, type);
545 /* is mark the first mark? */
546 if (hlist_empty(&conn->list)) {
547 hlist_add_head_rcu(&mark->obj_list, &conn->list);
551 /* should mark be in the middle of the current list? */
552 hlist_for_each_entry(lmark, &conn->list, obj_list) {
555 if ((lmark->group == mark->group) &&
556 (lmark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) &&
562 cmp = fsnotify_compare_groups(lmark->group, mark->group);
564 hlist_add_before_rcu(&mark->obj_list, &lmark->obj_list);
569 BUG_ON(last == NULL);
570 /* mark should be the last entry. last is the current last entry */
571 hlist_add_behind_rcu(&mark->obj_list, &last->obj_list);
573 mark->connector = conn;
575 spin_unlock(&conn->lock);
576 spin_unlock(&mark->lock);
581 * Attach an initialized mark to a given group and fs object.
582 * These marks may be used for the fsnotify backend to determine which
583 * event types should be delivered to which group.
585 int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
586 fsnotify_connp_t *connp, unsigned int type,
589 struct fsnotify_group *group = mark->group;
592 BUG_ON(!mutex_is_locked(&group->mark_mutex));
598 * mark->connector->lock
600 spin_lock(&mark->lock);
601 mark->flags |= FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_ATTACHED;
603 list_add(&mark->g_list, &group->marks_list);
604 atomic_inc(&group->num_marks);
605 fsnotify_get_mark(mark); /* for g_list */
606 spin_unlock(&mark->lock);
608 ret = fsnotify_add_mark_list(mark, connp, type, allow_dups);
613 fsnotify_recalc_mask(mark->connector);
617 spin_lock(&mark->lock);
618 mark->flags &= ~(FSNOTIFY_MARK_FLAG_ALIVE |
619 FSNOTIFY_MARK_FLAG_ATTACHED);
620 list_del_init(&mark->g_list);
621 spin_unlock(&mark->lock);
622 atomic_dec(&group->num_marks);
624 fsnotify_put_mark(mark);
628 int fsnotify_add_mark(struct fsnotify_mark *mark, fsnotify_connp_t *connp,
629 unsigned int type, int allow_dups)
632 struct fsnotify_group *group = mark->group;
634 mutex_lock(&group->mark_mutex);
635 ret = fsnotify_add_mark_locked(mark, connp, type, allow_dups);
636 mutex_unlock(&group->mark_mutex);
641 * Given a list of marks, find the mark associated with given group. If found
642 * take a reference to that mark and return it, else return NULL.
644 struct fsnotify_mark *fsnotify_find_mark(fsnotify_connp_t *connp,
645 struct fsnotify_group *group)
647 struct fsnotify_mark_connector *conn;
648 struct fsnotify_mark *mark;
650 conn = fsnotify_grab_connector(connp);
654 hlist_for_each_entry(mark, &conn->list, obj_list) {
655 if (mark->group == group &&
656 (mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
657 fsnotify_get_mark(mark);
658 spin_unlock(&conn->lock);
662 spin_unlock(&conn->lock);
666 /* Clear any marks in a group with given type mask */
667 void fsnotify_clear_marks_by_group(struct fsnotify_group *group,
668 unsigned int type_mask)
670 struct fsnotify_mark *lmark, *mark;
672 struct list_head *head = &to_free;
674 /* Skip selection step if we want to clear all marks. */
675 if (type_mask == FSNOTIFY_OBJ_ALL_TYPES_MASK) {
676 head = &group->marks_list;
680 * We have to be really careful here. Anytime we drop mark_mutex, e.g.
681 * fsnotify_clear_marks_by_inode() can come and free marks. Even in our
682 * to_free list so we have to use mark_mutex even when accessing that
683 * list. And freeing mark requires us to drop mark_mutex. So we can
684 * reliably free only the first mark in the list. That's why we first
685 * move marks to free to to_free list in one go and then free marks in
686 * to_free list one by one.
688 mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
689 list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) {
690 if ((1U << mark->connector->type) & type_mask)
691 list_move(&mark->g_list, &to_free);
693 mutex_unlock(&group->mark_mutex);
697 mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
698 if (list_empty(head)) {
699 mutex_unlock(&group->mark_mutex);
702 mark = list_first_entry(head, struct fsnotify_mark, g_list);
703 fsnotify_get_mark(mark);
704 fsnotify_detach_mark(mark);
705 mutex_unlock(&group->mark_mutex);
706 fsnotify_free_mark(mark);
707 fsnotify_put_mark(mark);
711 /* Destroy all marks attached to an object via connector */
712 void fsnotify_destroy_marks(fsnotify_connp_t *connp)
714 struct fsnotify_mark_connector *conn;
715 struct fsnotify_mark *mark, *old_mark = NULL;
718 conn = fsnotify_grab_connector(connp);
722 * We have to be careful since we can race with e.g.
723 * fsnotify_clear_marks_by_group() and once we drop the conn->lock, the
724 * list can get modified. However we are holding mark reference and
725 * thus our mark cannot be removed from obj_list so we can continue
726 * iteration after regaining conn->lock.
728 hlist_for_each_entry(mark, &conn->list, obj_list) {
729 fsnotify_get_mark(mark);
730 spin_unlock(&conn->lock);
732 fsnotify_put_mark(old_mark);
734 fsnotify_destroy_mark(mark, mark->group);
735 spin_lock(&conn->lock);
738 * Detach list from object now so that we don't pin inode until all
739 * mark references get dropped. It would lead to strange results such
740 * as delaying inode deletion or blocking unmount.
742 inode = fsnotify_detach_connector_from_object(conn);
743 spin_unlock(&conn->lock);
745 fsnotify_put_mark(old_mark);
750 * Nothing fancy, just initialize lists and locks and counters.
752 void fsnotify_init_mark(struct fsnotify_mark *mark,
753 struct fsnotify_group *group)
755 memset(mark, 0, sizeof(*mark));
756 spin_lock_init(&mark->lock);
757 refcount_set(&mark->refcnt, 1);
758 fsnotify_get_group(group);
763 * Destroy all marks in destroy_list, waits for SRCU period to finish before
764 * actually freeing marks.
766 static void fsnotify_mark_destroy_workfn(struct work_struct *work)
768 struct fsnotify_mark *mark, *next;
769 struct list_head private_destroy_list;
771 spin_lock(&destroy_lock);
772 /* exchange the list head */
773 list_replace_init(&destroy_list, &private_destroy_list);
774 spin_unlock(&destroy_lock);
776 synchronize_srcu(&fsnotify_mark_srcu);
778 list_for_each_entry_safe(mark, next, &private_destroy_list, g_list) {
779 list_del_init(&mark->g_list);
780 fsnotify_final_mark_destroy(mark);
784 /* Wait for all marks queued for destruction to be actually destroyed */
785 void fsnotify_wait_marks_destroyed(void)
787 flush_delayed_work(&reaper_work);