Merge tag 'for_v4.20-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs
[sfrench/cifs-2.6.git] / fs / notify / 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 /*
20  * fsnotify inode mark locking/lifetime/and refcnting
21  *
22  * REFCNT:
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.
29  *
30  * LOCKING:
31  * There are 3 locks involved with fsnotify inode marks and they MUST be taken
32  * in order as follows:
33  *
34  * group->mark_mutex
35  * mark->lock
36  * mark->connector->lock
37  *
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).
41
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.
46  *
47  * mark->connector->lock protects the list of marks anchored inside an
48  * inode / vfsmount and each mark is hooked via the i_list.
49  *
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.
59  *
60  * LIFETIME:
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.
63  *
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)
71  *
72  * This has the very interesting property of being able to run concurrently with
73  * any (or all) other directions.
74  */
75
76 #include <linux/fs.h>
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>
85
86 #include <linux/atomic.h>
87
88 #include <linux/fsnotify_backend.h>
89 #include "fsnotify.h"
90
91 #define FSNOTIFY_REAPER_DELAY   (1)     /* 1 jiffy */
92
93 struct srcu_struct fsnotify_mark_srcu;
94 struct kmem_cache *fsnotify_mark_connector_cachep;
95
96 static DEFINE_SPINLOCK(destroy_lock);
97 static LIST_HEAD(destroy_list);
98 static struct fsnotify_mark_connector *connector_destroy_list;
99
100 static void fsnotify_mark_destroy_workfn(struct work_struct *work);
101 static DECLARE_DELAYED_WORK(reaper_work, fsnotify_mark_destroy_workfn);
102
103 static void fsnotify_connector_destroy_workfn(struct work_struct *work);
104 static DECLARE_WORK(connector_reaper_work, fsnotify_connector_destroy_workfn);
105
106 void fsnotify_get_mark(struct fsnotify_mark *mark)
107 {
108         WARN_ON_ONCE(!refcount_read(&mark->refcnt));
109         refcount_inc(&mark->refcnt);
110 }
111
112 static __u32 *fsnotify_conn_mask_p(struct fsnotify_mark_connector *conn)
113 {
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;
120         return NULL;
121 }
122
123 __u32 fsnotify_conn_mask(struct fsnotify_mark_connector *conn)
124 {
125         if (WARN_ON(!fsnotify_valid_obj_type(conn->type)))
126                 return 0;
127
128         return *fsnotify_conn_mask_p(conn);
129 }
130
131 static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
132 {
133         u32 new_mask = 0;
134         struct fsnotify_mark *mark;
135
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))
139                 return;
140         hlist_for_each_entry(mark, &conn->list, obj_list) {
141                 if (mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)
142                         new_mask |= mark->mask;
143         }
144         *fsnotify_conn_mask_p(conn) = new_mask;
145 }
146
147 /*
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
151  * list.
152  */
153 void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
154 {
155         if (!conn)
156                 return;
157
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));
164 }
165
166 /* Free all connectors queued for freeing once SRCU period ends */
167 static void fsnotify_connector_destroy_workfn(struct work_struct *work)
168 {
169         struct fsnotify_mark_connector *conn, *free;
170
171         spin_lock(&destroy_lock);
172         conn = connector_destroy_list;
173         connector_destroy_list = NULL;
174         spin_unlock(&destroy_lock);
175
176         synchronize_srcu(&fsnotify_mark_srcu);
177         while (conn) {
178                 free = conn;
179                 conn = conn->destroy_next;
180                 kmem_cache_free(fsnotify_mark_connector_cachep, free);
181         }
182 }
183
184 static void *fsnotify_detach_connector_from_object(
185                                         struct fsnotify_mark_connector *conn,
186                                         unsigned int *type)
187 {
188         struct inode *inode = NULL;
189
190         *type = conn->type;
191         if (conn->type == FSNOTIFY_OBJ_TYPE_DETACHED)
192                 return NULL;
193
194         if (conn->type == FSNOTIFY_OBJ_TYPE_INODE) {
195                 inode = fsnotify_conn_inode(conn);
196                 inode->i_fsnotify_mask = 0;
197                 atomic_long_inc(&inode->i_sb->s_fsnotify_inode_refs);
198         } else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
199                 fsnotify_conn_mount(conn)->mnt_fsnotify_mask = 0;
200         } else if (conn->type == FSNOTIFY_OBJ_TYPE_SB) {
201                 fsnotify_conn_sb(conn)->s_fsnotify_mask = 0;
202         }
203
204         rcu_assign_pointer(*(conn->obj), NULL);
205         conn->obj = NULL;
206         conn->type = FSNOTIFY_OBJ_TYPE_DETACHED;
207
208         return inode;
209 }
210
211 static void fsnotify_final_mark_destroy(struct fsnotify_mark *mark)
212 {
213         struct fsnotify_group *group = mark->group;
214
215         if (WARN_ON_ONCE(!group))
216                 return;
217         group->ops->free_mark(mark);
218         fsnotify_put_group(group);
219 }
220
221 /* Drop object reference originally held by a connector */
222 static void fsnotify_drop_object(unsigned int type, void *objp)
223 {
224         struct inode *inode;
225         struct super_block *sb;
226
227         if (!objp)
228                 return;
229         /* Currently only inode references are passed to be dropped */
230         if (WARN_ON_ONCE(type != FSNOTIFY_OBJ_TYPE_INODE))
231                 return;
232         inode = objp;
233         sb = inode->i_sb;
234         iput(inode);
235         if (atomic_long_dec_and_test(&sb->s_fsnotify_inode_refs))
236                 wake_up_var(&sb->s_fsnotify_inode_refs);
237 }
238
239 void fsnotify_put_mark(struct fsnotify_mark *mark)
240 {
241         struct fsnotify_mark_connector *conn;
242         void *objp = NULL;
243         unsigned int type = FSNOTIFY_OBJ_TYPE_DETACHED;
244         bool free_conn = false;
245
246         /* Catch marks that were actually never attached to object */
247         if (!mark->connector) {
248                 if (refcount_dec_and_test(&mark->refcnt))
249                         fsnotify_final_mark_destroy(mark);
250                 return;
251         }
252
253         /*
254          * We have to be careful so that traversals of obj_list under lock can
255          * safely grab mark reference.
256          */
257         if (!refcount_dec_and_lock(&mark->refcnt, &mark->connector->lock))
258                 return;
259
260         conn = mark->connector;
261         hlist_del_init_rcu(&mark->obj_list);
262         if (hlist_empty(&conn->list)) {
263                 objp = fsnotify_detach_connector_from_object(conn, &type);
264                 free_conn = true;
265         } else {
266                 __fsnotify_recalc_mask(conn);
267         }
268         mark->connector = NULL;
269         spin_unlock(&conn->lock);
270
271         fsnotify_drop_object(type, objp);
272
273         if (free_conn) {
274                 spin_lock(&destroy_lock);
275                 conn->destroy_next = connector_destroy_list;
276                 connector_destroy_list = conn;
277                 spin_unlock(&destroy_lock);
278                 queue_work(system_unbound_wq, &connector_reaper_work);
279         }
280         /*
281          * Note that we didn't update flags telling whether inode cares about
282          * what's happening with children. We update these flags from
283          * __fsnotify_parent() lazily when next event happens on one of our
284          * children.
285          */
286         spin_lock(&destroy_lock);
287         list_add(&mark->g_list, &destroy_list);
288         spin_unlock(&destroy_lock);
289         queue_delayed_work(system_unbound_wq, &reaper_work,
290                            FSNOTIFY_REAPER_DELAY);
291 }
292
293 /*
294  * Get mark reference when we found the mark via lockless traversal of object
295  * list. Mark can be already removed from the list by now and on its way to be
296  * destroyed once SRCU period ends.
297  *
298  * Also pin the group so it doesn't disappear under us.
299  */
300 static bool fsnotify_get_mark_safe(struct fsnotify_mark *mark)
301 {
302         if (!mark)
303                 return true;
304
305         if (refcount_inc_not_zero(&mark->refcnt)) {
306                 spin_lock(&mark->lock);
307                 if (mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) {
308                         /* mark is attached, group is still alive then */
309                         atomic_inc(&mark->group->user_waits);
310                         spin_unlock(&mark->lock);
311                         return true;
312                 }
313                 spin_unlock(&mark->lock);
314                 fsnotify_put_mark(mark);
315         }
316         return false;
317 }
318
319 /*
320  * Puts marks and wakes up group destruction if necessary.
321  *
322  * Pairs with fsnotify_get_mark_safe()
323  */
324 static void fsnotify_put_mark_wake(struct fsnotify_mark *mark)
325 {
326         if (mark) {
327                 struct fsnotify_group *group = mark->group;
328
329                 fsnotify_put_mark(mark);
330                 /*
331                  * We abuse notification_waitq on group shutdown for waiting for
332                  * all marks pinned when waiting for userspace.
333                  */
334                 if (atomic_dec_and_test(&group->user_waits) && group->shutdown)
335                         wake_up(&group->notification_waitq);
336         }
337 }
338
339 bool fsnotify_prepare_user_wait(struct fsnotify_iter_info *iter_info)
340 {
341         int type;
342
343         fsnotify_foreach_obj_type(type) {
344                 /* This can fail if mark is being removed */
345                 if (!fsnotify_get_mark_safe(iter_info->marks[type]))
346                         goto fail;
347         }
348
349         /*
350          * Now that both marks are pinned by refcount in the inode / vfsmount
351          * lists, we can drop SRCU lock, and safely resume the list iteration
352          * once userspace returns.
353          */
354         srcu_read_unlock(&fsnotify_mark_srcu, iter_info->srcu_idx);
355
356         return true;
357
358 fail:
359         for (type--; type >= 0; type--)
360                 fsnotify_put_mark_wake(iter_info->marks[type]);
361         return false;
362 }
363
364 void fsnotify_finish_user_wait(struct fsnotify_iter_info *iter_info)
365 {
366         int type;
367
368         iter_info->srcu_idx = srcu_read_lock(&fsnotify_mark_srcu);
369         fsnotify_foreach_obj_type(type)
370                 fsnotify_put_mark_wake(iter_info->marks[type]);
371 }
372
373 /*
374  * Mark mark as detached, remove it from group list. Mark still stays in object
375  * list until its last reference is dropped. Note that we rely on mark being
376  * removed from group list before corresponding reference to it is dropped. In
377  * particular we rely on mark->connector being valid while we hold
378  * group->mark_mutex if we found the mark through g_list.
379  *
380  * Must be called with group->mark_mutex held. The caller must either hold
381  * reference to the mark or be protected by fsnotify_mark_srcu.
382  */
383 void fsnotify_detach_mark(struct fsnotify_mark *mark)
384 {
385         struct fsnotify_group *group = mark->group;
386
387         WARN_ON_ONCE(!mutex_is_locked(&group->mark_mutex));
388         WARN_ON_ONCE(!srcu_read_lock_held(&fsnotify_mark_srcu) &&
389                      refcount_read(&mark->refcnt) < 1 +
390                         !!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED));
391
392         spin_lock(&mark->lock);
393         /* something else already called this function on this mark */
394         if (!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
395                 spin_unlock(&mark->lock);
396                 return;
397         }
398         mark->flags &= ~FSNOTIFY_MARK_FLAG_ATTACHED;
399         list_del_init(&mark->g_list);
400         spin_unlock(&mark->lock);
401
402         atomic_dec(&group->num_marks);
403
404         /* Drop mark reference acquired in fsnotify_add_mark_locked() */
405         fsnotify_put_mark(mark);
406 }
407
408 /*
409  * Free fsnotify mark. The mark is actually only marked as being freed.  The
410  * freeing is actually happening only once last reference to the mark is
411  * dropped from a workqueue which first waits for srcu period end.
412  *
413  * Caller must have a reference to the mark or be protected by
414  * fsnotify_mark_srcu.
415  */
416 void fsnotify_free_mark(struct fsnotify_mark *mark)
417 {
418         struct fsnotify_group *group = mark->group;
419
420         spin_lock(&mark->lock);
421         /* something else already called this function on this mark */
422         if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE)) {
423                 spin_unlock(&mark->lock);
424                 return;
425         }
426         mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE;
427         spin_unlock(&mark->lock);
428
429         /*
430          * Some groups like to know that marks are being freed.  This is a
431          * callback to the group function to let it know that this mark
432          * is being freed.
433          */
434         if (group->ops->freeing_mark)
435                 group->ops->freeing_mark(mark, group);
436 }
437
438 void fsnotify_destroy_mark(struct fsnotify_mark *mark,
439                            struct fsnotify_group *group)
440 {
441         mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
442         fsnotify_detach_mark(mark);
443         mutex_unlock(&group->mark_mutex);
444         fsnotify_free_mark(mark);
445 }
446
447 /*
448  * Sorting function for lists of fsnotify marks.
449  *
450  * Fanotify supports different notification classes (reflected as priority of
451  * notification group). Events shall be passed to notification groups in
452  * decreasing priority order. To achieve this marks in notification lists for
453  * inodes and vfsmounts are sorted so that priorities of corresponding groups
454  * are descending.
455  *
456  * Furthermore correct handling of the ignore mask requires processing inode
457  * and vfsmount marks of each group together. Using the group address as
458  * further sort criterion provides a unique sorting order and thus we can
459  * merge inode and vfsmount lists of marks in linear time and find groups
460  * present in both lists.
461  *
462  * A return value of 1 signifies that b has priority over a.
463  * A return value of 0 signifies that the two marks have to be handled together.
464  * A return value of -1 signifies that a has priority over b.
465  */
466 int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b)
467 {
468         if (a == b)
469                 return 0;
470         if (!a)
471                 return 1;
472         if (!b)
473                 return -1;
474         if (a->priority < b->priority)
475                 return 1;
476         if (a->priority > b->priority)
477                 return -1;
478         if (a < b)
479                 return 1;
480         return -1;
481 }
482
483 static int fsnotify_attach_connector_to_object(fsnotify_connp_t *connp,
484                                                unsigned int type)
485 {
486         struct inode *inode = NULL;
487         struct fsnotify_mark_connector *conn;
488
489         conn = kmem_cache_alloc(fsnotify_mark_connector_cachep, GFP_KERNEL);
490         if (!conn)
491                 return -ENOMEM;
492         spin_lock_init(&conn->lock);
493         INIT_HLIST_HEAD(&conn->list);
494         conn->type = type;
495         conn->obj = connp;
496         if (conn->type == FSNOTIFY_OBJ_TYPE_INODE)
497                 inode = igrab(fsnotify_conn_inode(conn));
498         /*
499          * cmpxchg() provides the barrier so that readers of *connp can see
500          * only initialized structure
501          */
502         if (cmpxchg(connp, NULL, conn)) {
503                 /* Someone else created list structure for us */
504                 if (inode)
505                         iput(inode);
506                 kmem_cache_free(fsnotify_mark_connector_cachep, conn);
507         }
508
509         return 0;
510 }
511
512 /*
513  * Get mark connector, make sure it is alive and return with its lock held.
514  * This is for users that get connector pointer from inode or mount. Users that
515  * hold reference to a mark on the list may directly lock connector->lock as
516  * they are sure list cannot go away under them.
517  */
518 static struct fsnotify_mark_connector *fsnotify_grab_connector(
519                                                 fsnotify_connp_t *connp)
520 {
521         struct fsnotify_mark_connector *conn;
522         int idx;
523
524         idx = srcu_read_lock(&fsnotify_mark_srcu);
525         conn = srcu_dereference(*connp, &fsnotify_mark_srcu);
526         if (!conn)
527                 goto out;
528         spin_lock(&conn->lock);
529         if (conn->type == FSNOTIFY_OBJ_TYPE_DETACHED) {
530                 spin_unlock(&conn->lock);
531                 srcu_read_unlock(&fsnotify_mark_srcu, idx);
532                 return NULL;
533         }
534 out:
535         srcu_read_unlock(&fsnotify_mark_srcu, idx);
536         return conn;
537 }
538
539 /*
540  * Add mark into proper place in given list of marks. These marks may be used
541  * for the fsnotify backend to determine which event types should be delivered
542  * to which group and for which inodes. These marks are ordered according to
543  * priority, highest number first, and then by the group's location in memory.
544  */
545 static int fsnotify_add_mark_list(struct fsnotify_mark *mark,
546                                   fsnotify_connp_t *connp, unsigned int type,
547                                   int allow_dups)
548 {
549         struct fsnotify_mark *lmark, *last = NULL;
550         struct fsnotify_mark_connector *conn;
551         int cmp;
552         int err = 0;
553
554         if (WARN_ON(!fsnotify_valid_obj_type(type)))
555                 return -EINVAL;
556 restart:
557         spin_lock(&mark->lock);
558         conn = fsnotify_grab_connector(connp);
559         if (!conn) {
560                 spin_unlock(&mark->lock);
561                 err = fsnotify_attach_connector_to_object(connp, type);
562                 if (err)
563                         return err;
564                 goto restart;
565         }
566
567         /* is mark the first mark? */
568         if (hlist_empty(&conn->list)) {
569                 hlist_add_head_rcu(&mark->obj_list, &conn->list);
570                 goto added;
571         }
572
573         /* should mark be in the middle of the current list? */
574         hlist_for_each_entry(lmark, &conn->list, obj_list) {
575                 last = lmark;
576
577                 if ((lmark->group == mark->group) &&
578                     (lmark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) &&
579                     !allow_dups) {
580                         err = -EEXIST;
581                         goto out_err;
582                 }
583
584                 cmp = fsnotify_compare_groups(lmark->group, mark->group);
585                 if (cmp >= 0) {
586                         hlist_add_before_rcu(&mark->obj_list, &lmark->obj_list);
587                         goto added;
588                 }
589         }
590
591         BUG_ON(last == NULL);
592         /* mark should be the last entry.  last is the current last entry */
593         hlist_add_behind_rcu(&mark->obj_list, &last->obj_list);
594 added:
595         mark->connector = conn;
596 out_err:
597         spin_unlock(&conn->lock);
598         spin_unlock(&mark->lock);
599         return err;
600 }
601
602 /*
603  * Attach an initialized mark to a given group and fs object.
604  * These marks may be used for the fsnotify backend to determine which
605  * event types should be delivered to which group.
606  */
607 int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
608                              fsnotify_connp_t *connp, unsigned int type,
609                              int allow_dups)
610 {
611         struct fsnotify_group *group = mark->group;
612         int ret = 0;
613
614         BUG_ON(!mutex_is_locked(&group->mark_mutex));
615
616         /*
617          * LOCKING ORDER!!!!
618          * group->mark_mutex
619          * mark->lock
620          * mark->connector->lock
621          */
622         spin_lock(&mark->lock);
623         mark->flags |= FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_ATTACHED;
624
625         list_add(&mark->g_list, &group->marks_list);
626         atomic_inc(&group->num_marks);
627         fsnotify_get_mark(mark); /* for g_list */
628         spin_unlock(&mark->lock);
629
630         ret = fsnotify_add_mark_list(mark, connp, type, allow_dups);
631         if (ret)
632                 goto err;
633
634         if (mark->mask)
635                 fsnotify_recalc_mask(mark->connector);
636
637         return ret;
638 err:
639         spin_lock(&mark->lock);
640         mark->flags &= ~(FSNOTIFY_MARK_FLAG_ALIVE |
641                          FSNOTIFY_MARK_FLAG_ATTACHED);
642         list_del_init(&mark->g_list);
643         spin_unlock(&mark->lock);
644         atomic_dec(&group->num_marks);
645
646         fsnotify_put_mark(mark);
647         return ret;
648 }
649
650 int fsnotify_add_mark(struct fsnotify_mark *mark, fsnotify_connp_t *connp,
651                       unsigned int type, int allow_dups)
652 {
653         int ret;
654         struct fsnotify_group *group = mark->group;
655
656         mutex_lock(&group->mark_mutex);
657         ret = fsnotify_add_mark_locked(mark, connp, type, allow_dups);
658         mutex_unlock(&group->mark_mutex);
659         return ret;
660 }
661
662 /*
663  * Given a list of marks, find the mark associated with given group. If found
664  * take a reference to that mark and return it, else return NULL.
665  */
666 struct fsnotify_mark *fsnotify_find_mark(fsnotify_connp_t *connp,
667                                          struct fsnotify_group *group)
668 {
669         struct fsnotify_mark_connector *conn;
670         struct fsnotify_mark *mark;
671
672         conn = fsnotify_grab_connector(connp);
673         if (!conn)
674                 return NULL;
675
676         hlist_for_each_entry(mark, &conn->list, obj_list) {
677                 if (mark->group == group &&
678                     (mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
679                         fsnotify_get_mark(mark);
680                         spin_unlock(&conn->lock);
681                         return mark;
682                 }
683         }
684         spin_unlock(&conn->lock);
685         return NULL;
686 }
687
688 /* Clear any marks in a group with given type mask */
689 void fsnotify_clear_marks_by_group(struct fsnotify_group *group,
690                                    unsigned int type_mask)
691 {
692         struct fsnotify_mark *lmark, *mark;
693         LIST_HEAD(to_free);
694         struct list_head *head = &to_free;
695
696         /* Skip selection step if we want to clear all marks. */
697         if (type_mask == FSNOTIFY_OBJ_ALL_TYPES_MASK) {
698                 head = &group->marks_list;
699                 goto clear;
700         }
701         /*
702          * We have to be really careful here. Anytime we drop mark_mutex, e.g.
703          * fsnotify_clear_marks_by_inode() can come and free marks. Even in our
704          * to_free list so we have to use mark_mutex even when accessing that
705          * list. And freeing mark requires us to drop mark_mutex. So we can
706          * reliably free only the first mark in the list. That's why we first
707          * move marks to free to to_free list in one go and then free marks in
708          * to_free list one by one.
709          */
710         mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
711         list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) {
712                 if ((1U << mark->connector->type) & type_mask)
713                         list_move(&mark->g_list, &to_free);
714         }
715         mutex_unlock(&group->mark_mutex);
716
717 clear:
718         while (1) {
719                 mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
720                 if (list_empty(head)) {
721                         mutex_unlock(&group->mark_mutex);
722                         break;
723                 }
724                 mark = list_first_entry(head, struct fsnotify_mark, g_list);
725                 fsnotify_get_mark(mark);
726                 fsnotify_detach_mark(mark);
727                 mutex_unlock(&group->mark_mutex);
728                 fsnotify_free_mark(mark);
729                 fsnotify_put_mark(mark);
730         }
731 }
732
733 /* Destroy all marks attached to an object via connector */
734 void fsnotify_destroy_marks(fsnotify_connp_t *connp)
735 {
736         struct fsnotify_mark_connector *conn;
737         struct fsnotify_mark *mark, *old_mark = NULL;
738         void *objp;
739         unsigned int type;
740
741         conn = fsnotify_grab_connector(connp);
742         if (!conn)
743                 return;
744         /*
745          * We have to be careful since we can race with e.g.
746          * fsnotify_clear_marks_by_group() and once we drop the conn->lock, the
747          * list can get modified. However we are holding mark reference and
748          * thus our mark cannot be removed from obj_list so we can continue
749          * iteration after regaining conn->lock.
750          */
751         hlist_for_each_entry(mark, &conn->list, obj_list) {
752                 fsnotify_get_mark(mark);
753                 spin_unlock(&conn->lock);
754                 if (old_mark)
755                         fsnotify_put_mark(old_mark);
756                 old_mark = mark;
757                 fsnotify_destroy_mark(mark, mark->group);
758                 spin_lock(&conn->lock);
759         }
760         /*
761          * Detach list from object now so that we don't pin inode until all
762          * mark references get dropped. It would lead to strange results such
763          * as delaying inode deletion or blocking unmount.
764          */
765         objp = fsnotify_detach_connector_from_object(conn, &type);
766         spin_unlock(&conn->lock);
767         if (old_mark)
768                 fsnotify_put_mark(old_mark);
769         fsnotify_drop_object(type, objp);
770 }
771
772 /*
773  * Nothing fancy, just initialize lists and locks and counters.
774  */
775 void fsnotify_init_mark(struct fsnotify_mark *mark,
776                         struct fsnotify_group *group)
777 {
778         memset(mark, 0, sizeof(*mark));
779         spin_lock_init(&mark->lock);
780         refcount_set(&mark->refcnt, 1);
781         fsnotify_get_group(group);
782         mark->group = group;
783 }
784
785 /*
786  * Destroy all marks in destroy_list, waits for SRCU period to finish before
787  * actually freeing marks.
788  */
789 static void fsnotify_mark_destroy_workfn(struct work_struct *work)
790 {
791         struct fsnotify_mark *mark, *next;
792         struct list_head private_destroy_list;
793
794         spin_lock(&destroy_lock);
795         /* exchange the list head */
796         list_replace_init(&destroy_list, &private_destroy_list);
797         spin_unlock(&destroy_lock);
798
799         synchronize_srcu(&fsnotify_mark_srcu);
800
801         list_for_each_entry_safe(mark, next, &private_destroy_list, g_list) {
802                 list_del_init(&mark->g_list);
803                 fsnotify_final_mark_destroy(mark);
804         }
805 }
806
807 /* Wait for all marks queued for destruction to be actually destroyed */
808 void fsnotify_wait_marks_destroyed(void)
809 {
810         flush_delayed_work(&reaper_work);
811 }