fsnotify: Move locking into fsnotify_find_mark()
[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  * inode->i_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  * inode->i_lock protects the i_fsnotify_marks list anchored inside a
48  * given inode and each mark is hooked via the i_list. (and sorta the
49  * free_i_list)
50  *
51  *
52  * LIFETIME:
53  * Inode marks survive between when they are added to an inode and when their
54  * refcnt==0. Marks are also protected by fsnotify_mark_srcu.
55  *
56  * The inode mark can be cleared for a number of different reasons including:
57  * - The inode is unlinked for the last time.  (fsnotify_inode_remove)
58  * - The inode is being evicted from cache. (fsnotify_inode_delete)
59  * - The fs the inode is on is unmounted.  (fsnotify_inode_delete/fsnotify_unmount_inodes)
60  * - Something explicitly requests that it be removed.  (fsnotify_destroy_mark)
61  * - The fsnotify_group associated with the mark is going away and all such marks
62  *   need to be cleaned up. (fsnotify_clear_marks_by_group)
63  *
64  * This has the very interesting property of being able to run concurrently with
65  * any (or all) other directions.
66  */
67
68 #include <linux/fs.h>
69 #include <linux/init.h>
70 #include <linux/kernel.h>
71 #include <linux/kthread.h>
72 #include <linux/module.h>
73 #include <linux/mutex.h>
74 #include <linux/slab.h>
75 #include <linux/spinlock.h>
76 #include <linux/srcu.h>
77
78 #include <linux/atomic.h>
79
80 #include <linux/fsnotify_backend.h>
81 #include "fsnotify.h"
82
83 #define FSNOTIFY_REAPER_DELAY   (1)     /* 1 jiffy */
84
85 struct srcu_struct fsnotify_mark_srcu;
86 struct kmem_cache *fsnotify_mark_connector_cachep;
87
88 static DEFINE_SPINLOCK(destroy_lock);
89 static LIST_HEAD(destroy_list);
90
91 static void fsnotify_mark_destroy_workfn(struct work_struct *work);
92 static DECLARE_DELAYED_WORK(reaper_work, fsnotify_mark_destroy_workfn);
93
94 void fsnotify_get_mark(struct fsnotify_mark *mark)
95 {
96         atomic_inc(&mark->refcnt);
97 }
98
99 void fsnotify_put_mark(struct fsnotify_mark *mark)
100 {
101         if (atomic_dec_and_test(&mark->refcnt)) {
102                 if (mark->group)
103                         fsnotify_put_group(mark->group);
104                 mark->free_mark(mark);
105         }
106 }
107
108 static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
109 {
110         u32 new_mask = 0;
111         struct fsnotify_mark *mark;
112
113         hlist_for_each_entry(mark, &conn->list, obj_list)
114                 new_mask |= mark->mask;
115         if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE)
116                 conn->inode->i_fsnotify_mask = new_mask;
117         else if (conn->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT)
118                 real_mount(conn->mnt)->mnt_fsnotify_mask = new_mask;
119 }
120
121 /*
122  * Calculate mask of events for a list of marks. The caller must make sure
123  * connector cannot disappear under us (usually by holding a mark->lock or
124  * mark->group->mark_mutex for a mark on this list).
125  */
126 void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
127 {
128         if (!conn)
129                 return;
130
131         if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE)
132                 spin_lock(&conn->inode->i_lock);
133         else
134                 spin_lock(&conn->mnt->mnt_root->d_lock);
135         __fsnotify_recalc_mask(conn);
136         if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE) {
137                 spin_unlock(&conn->inode->i_lock);
138                 __fsnotify_update_child_dentry_flags(conn->inode);
139         } else {
140                 spin_unlock(&conn->mnt->mnt_root->d_lock);
141         }
142 }
143
144 /*
145  * Remove mark from inode / vfsmount list, group list, drop inode reference
146  * if we got one.
147  *
148  * Must be called with group->mark_mutex held.
149  */
150 void fsnotify_detach_mark(struct fsnotify_mark *mark)
151 {
152         struct inode *inode = NULL;
153         struct fsnotify_group *group = mark->group;
154
155         BUG_ON(!mutex_is_locked(&group->mark_mutex));
156
157         spin_lock(&mark->lock);
158
159         /* something else already called this function on this mark */
160         if (!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
161                 spin_unlock(&mark->lock);
162                 return;
163         }
164
165         mark->flags &= ~FSNOTIFY_MARK_FLAG_ATTACHED;
166
167         if (mark->connector->flags & FSNOTIFY_OBJ_TYPE_INODE)
168                 inode = fsnotify_destroy_inode_mark(mark);
169         else if (mark->connector->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT)
170                 fsnotify_destroy_vfsmount_mark(mark);
171         else
172                 BUG();
173         /*
174          * Note that we didn't update flags telling whether inode cares about
175          * what's happening with children. We update these flags from
176          * __fsnotify_parent() lazily when next event happens on one of our
177          * children.
178          */
179
180         list_del_init(&mark->g_list);
181
182         spin_unlock(&mark->lock);
183
184         if (inode)
185                 iput(inode);
186
187         atomic_dec(&group->num_marks);
188 }
189
190 /*
191  * Prepare mark for freeing and add it to the list of marks prepared for
192  * freeing. The actual freeing must happen after SRCU period ends and the
193  * caller is responsible for this.
194  *
195  * The function returns true if the mark was added to the list of marks for
196  * freeing. The function returns false if someone else has already called
197  * __fsnotify_free_mark() for the mark.
198  */
199 static bool __fsnotify_free_mark(struct fsnotify_mark *mark)
200 {
201         struct fsnotify_group *group = mark->group;
202
203         spin_lock(&mark->lock);
204         /* something else already called this function on this mark */
205         if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE)) {
206                 spin_unlock(&mark->lock);
207                 return false;
208         }
209         mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE;
210         spin_unlock(&mark->lock);
211
212         /*
213          * Some groups like to know that marks are being freed.  This is a
214          * callback to the group function to let it know that this mark
215          * is being freed.
216          */
217         if (group->ops->freeing_mark)
218                 group->ops->freeing_mark(mark, group);
219
220         spin_lock(&destroy_lock);
221         list_add(&mark->g_list, &destroy_list);
222         spin_unlock(&destroy_lock);
223
224         return true;
225 }
226
227 /*
228  * Free fsnotify mark. The freeing is actually happening from a workqueue which
229  * first waits for srcu period end. Caller must have a reference to the mark
230  * or be protected by fsnotify_mark_srcu.
231  */
232 void fsnotify_free_mark(struct fsnotify_mark *mark)
233 {
234         if (__fsnotify_free_mark(mark)) {
235                 queue_delayed_work(system_unbound_wq, &reaper_work,
236                                    FSNOTIFY_REAPER_DELAY);
237         }
238 }
239
240 void fsnotify_destroy_mark(struct fsnotify_mark *mark,
241                            struct fsnotify_group *group)
242 {
243         mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
244         fsnotify_detach_mark(mark);
245         mutex_unlock(&group->mark_mutex);
246         fsnotify_free_mark(mark);
247 }
248
249 void fsnotify_connector_free(struct fsnotify_mark_connector **connp)
250 {
251         if (*connp) {
252                 kmem_cache_free(fsnotify_mark_connector_cachep, *connp);
253                 *connp = NULL;
254         }
255 }
256
257 void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask)
258 {
259         assert_spin_locked(&mark->lock);
260
261         mark->mask = mask;
262 }
263
264 void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask)
265 {
266         assert_spin_locked(&mark->lock);
267
268         mark->ignored_mask = mask;
269 }
270
271 /*
272  * Sorting function for lists of fsnotify marks.
273  *
274  * Fanotify supports different notification classes (reflected as priority of
275  * notification group). Events shall be passed to notification groups in
276  * decreasing priority order. To achieve this marks in notification lists for
277  * inodes and vfsmounts are sorted so that priorities of corresponding groups
278  * are descending.
279  *
280  * Furthermore correct handling of the ignore mask requires processing inode
281  * and vfsmount marks of each group together. Using the group address as
282  * further sort criterion provides a unique sorting order and thus we can
283  * merge inode and vfsmount lists of marks in linear time and find groups
284  * present in both lists.
285  *
286  * A return value of 1 signifies that b has priority over a.
287  * A return value of 0 signifies that the two marks have to be handled together.
288  * A return value of -1 signifies that a has priority over b.
289  */
290 int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b)
291 {
292         if (a == b)
293                 return 0;
294         if (!a)
295                 return 1;
296         if (!b)
297                 return -1;
298         if (a->priority < b->priority)
299                 return 1;
300         if (a->priority > b->priority)
301                 return -1;
302         if (a < b)
303                 return 1;
304         return -1;
305 }
306
307 static int fsnotify_attach_connector_to_object(
308                                         struct fsnotify_mark_connector **connp,
309                                         spinlock_t *lock,
310                                         struct inode *inode,
311                                         struct vfsmount *mnt)
312 {
313         struct fsnotify_mark_connector *conn;
314
315         conn = kmem_cache_alloc(fsnotify_mark_connector_cachep, GFP_KERNEL);
316         if (!conn)
317                 return -ENOMEM;
318         INIT_HLIST_HEAD(&conn->list);
319         if (inode) {
320                 conn->flags = FSNOTIFY_OBJ_TYPE_INODE;
321                 conn->inode = inode;
322         } else {
323                 conn->flags = FSNOTIFY_OBJ_TYPE_VFSMOUNT;
324                 conn->mnt = mnt;
325         }
326         /*
327          * Make sure 'conn' initialization is visible. Matches
328          * lockless_dereference() in fsnotify().
329          */
330         smp_wmb();
331         spin_lock(lock);
332         if (!*connp)
333                 *connp = conn;
334         else
335                 kmem_cache_free(fsnotify_mark_connector_cachep, conn);
336         spin_unlock(lock);
337
338         return 0;
339 }
340
341 /*
342  * Add mark into proper place in given list of marks. These marks may be used
343  * for the fsnotify backend to determine which event types should be delivered
344  * to which group and for which inodes. These marks are ordered according to
345  * priority, highest number first, and then by the group's location in memory.
346  */
347 static int fsnotify_add_mark_list(struct fsnotify_mark *mark,
348                                   struct inode *inode, struct vfsmount *mnt,
349                                   int allow_dups)
350 {
351         struct fsnotify_mark *lmark, *last = NULL;
352         struct fsnotify_mark_connector *conn;
353         struct fsnotify_mark_connector **connp;
354         spinlock_t *lock;
355         int cmp;
356         int err = 0;
357
358         if (WARN_ON(!inode && !mnt))
359                 return -EINVAL;
360         if (inode) {
361                 connp = &inode->i_fsnotify_marks;
362                 lock = &inode->i_lock;
363         } else {
364                 connp = &real_mount(mnt)->mnt_fsnotify_marks;
365                 lock = &mnt->mnt_root->d_lock;
366         }
367
368         if (!*connp) {
369                 err = fsnotify_attach_connector_to_object(connp, lock,
370                                                           inode, mnt);
371                 if (err)
372                         return err;
373         }
374         spin_lock(&mark->lock);
375         spin_lock(lock);
376         conn = *connp;
377
378         /* is mark the first mark? */
379         if (hlist_empty(&conn->list)) {
380                 hlist_add_head_rcu(&mark->obj_list, &conn->list);
381                 if (inode)
382                         __iget(inode);
383                 goto added;
384         }
385
386         /* should mark be in the middle of the current list? */
387         hlist_for_each_entry(lmark, &conn->list, obj_list) {
388                 last = lmark;
389
390                 if ((lmark->group == mark->group) && !allow_dups) {
391                         err = -EEXIST;
392                         goto out_err;
393                 }
394
395                 cmp = fsnotify_compare_groups(lmark->group, mark->group);
396                 if (cmp >= 0) {
397                         hlist_add_before_rcu(&mark->obj_list, &lmark->obj_list);
398                         goto added;
399                 }
400         }
401
402         BUG_ON(last == NULL);
403         /* mark should be the last entry.  last is the current last entry */
404         hlist_add_behind_rcu(&mark->obj_list, &last->obj_list);
405 added:
406         mark->connector = conn;
407 out_err:
408         spin_unlock(lock);
409         spin_unlock(&mark->lock);
410         return err;
411 }
412
413 /*
414  * Attach an initialized mark to a given group and fs object.
415  * These marks may be used for the fsnotify backend to determine which
416  * event types should be delivered to which group.
417  */
418 int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
419                              struct fsnotify_group *group, struct inode *inode,
420                              struct vfsmount *mnt, int allow_dups)
421 {
422         int ret = 0;
423
424         BUG_ON(inode && mnt);
425         BUG_ON(!inode && !mnt);
426         BUG_ON(!mutex_is_locked(&group->mark_mutex));
427
428         /*
429          * LOCKING ORDER!!!!
430          * group->mark_mutex
431          * mark->lock
432          * inode->i_lock
433          */
434         spin_lock(&mark->lock);
435         mark->flags |= FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_ATTACHED;
436
437         fsnotify_get_group(group);
438         mark->group = group;
439         list_add(&mark->g_list, &group->marks_list);
440         atomic_inc(&group->num_marks);
441         fsnotify_get_mark(mark); /* for i_list and g_list */
442         spin_unlock(&mark->lock);
443
444         ret = fsnotify_add_mark_list(mark, inode, mnt, allow_dups);
445         if (ret)
446                 goto err;
447
448         if (mark->mask)
449                 fsnotify_recalc_mask(mark->connector);
450
451         return ret;
452 err:
453         mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE;
454         list_del_init(&mark->g_list);
455         fsnotify_put_group(group);
456         mark->group = NULL;
457         atomic_dec(&group->num_marks);
458
459         spin_unlock(&mark->lock);
460
461         spin_lock(&destroy_lock);
462         list_add(&mark->g_list, &destroy_list);
463         spin_unlock(&destroy_lock);
464         queue_delayed_work(system_unbound_wq, &reaper_work,
465                                 FSNOTIFY_REAPER_DELAY);
466
467         return ret;
468 }
469
470 int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group,
471                       struct inode *inode, struct vfsmount *mnt, int allow_dups)
472 {
473         int ret;
474         mutex_lock(&group->mark_mutex);
475         ret = fsnotify_add_mark_locked(mark, group, inode, mnt, allow_dups);
476         mutex_unlock(&group->mark_mutex);
477         return ret;
478 }
479
480 /*
481  * Given a list of marks, find the mark associated with given group. If found
482  * take a reference to that mark and return it, else return NULL.
483  */
484 struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_mark_connector *conn,
485                                          struct fsnotify_group *group)
486 {
487         struct fsnotify_mark *mark;
488         spinlock_t *lock;
489
490         if (!conn)
491                 return NULL;
492
493         if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE)
494                 lock = &conn->inode->i_lock;
495         else
496                 lock = &conn->mnt->mnt_root->d_lock;
497         spin_lock(lock);
498         hlist_for_each_entry(mark, &conn->list, obj_list) {
499                 if (mark->group == group) {
500                         fsnotify_get_mark(mark);
501                         spin_unlock(lock);
502                         return mark;
503                 }
504         }
505         spin_unlock(lock);
506         return NULL;
507 }
508
509 /*
510  * clear any marks in a group in which mark->flags & flags is true
511  */
512 void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group,
513                                          unsigned int flags)
514 {
515         struct fsnotify_mark *lmark, *mark;
516         LIST_HEAD(to_free);
517
518         /*
519          * We have to be really careful here. Anytime we drop mark_mutex, e.g.
520          * fsnotify_clear_marks_by_inode() can come and free marks. Even in our
521          * to_free list so we have to use mark_mutex even when accessing that
522          * list. And freeing mark requires us to drop mark_mutex. So we can
523          * reliably free only the first mark in the list. That's why we first
524          * move marks to free to to_free list in one go and then free marks in
525          * to_free list one by one.
526          */
527         mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
528         list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) {
529                 if (mark->connector->flags & flags)
530                         list_move(&mark->g_list, &to_free);
531         }
532         mutex_unlock(&group->mark_mutex);
533
534         while (1) {
535                 mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
536                 if (list_empty(&to_free)) {
537                         mutex_unlock(&group->mark_mutex);
538                         break;
539                 }
540                 mark = list_first_entry(&to_free, struct fsnotify_mark, g_list);
541                 fsnotify_get_mark(mark);
542                 fsnotify_detach_mark(mark);
543                 mutex_unlock(&group->mark_mutex);
544                 fsnotify_free_mark(mark);
545                 fsnotify_put_mark(mark);
546         }
547 }
548
549 /*
550  * Given a group, prepare for freeing all the marks associated with that group.
551  * The marks are attached to the list of marks prepared for destruction, the
552  * caller is responsible for freeing marks in that list after SRCU period has
553  * ended.
554  */
555 void fsnotify_detach_group_marks(struct fsnotify_group *group)
556 {
557         struct fsnotify_mark *mark;
558
559         while (1) {
560                 mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
561                 if (list_empty(&group->marks_list)) {
562                         mutex_unlock(&group->mark_mutex);
563                         break;
564                 }
565                 mark = list_first_entry(&group->marks_list,
566                                         struct fsnotify_mark, g_list);
567                 fsnotify_get_mark(mark);
568                 fsnotify_detach_mark(mark);
569                 mutex_unlock(&group->mark_mutex);
570                 __fsnotify_free_mark(mark);
571                 fsnotify_put_mark(mark);
572         }
573 }
574
575 void fsnotify_destroy_marks(struct fsnotify_mark_connector *conn,
576                             spinlock_t *lock)
577 {
578         struct fsnotify_mark *mark;
579
580         if (!conn)
581                 return;
582
583         while (1) {
584                 /*
585                  * We have to be careful since we can race with e.g.
586                  * fsnotify_clear_marks_by_group() and once we drop 'lock',
587                  * mark can get removed from the obj_list and destroyed. But
588                  * we are holding mark reference so mark cannot be freed and
589                  * calling fsnotify_destroy_mark() more than once is fine.
590                  */
591                 spin_lock(lock);
592                 if (hlist_empty(&conn->list)) {
593                         spin_unlock(lock);
594                         break;
595                 }
596                 mark = hlist_entry(conn->list.first, struct fsnotify_mark,
597                                    obj_list);
598                 /*
599                  * We don't update i_fsnotify_mask / mnt_fsnotify_mask here
600                  * since inode / mount is going away anyway. So just remove
601                  * mark from the list.
602                  */
603                 hlist_del_init_rcu(&mark->obj_list);
604                 fsnotify_get_mark(mark);
605                 spin_unlock(lock);
606                 fsnotify_destroy_mark(mark, mark->group);
607                 fsnotify_put_mark(mark);
608         }
609 }
610
611 /*
612  * Nothing fancy, just initialize lists and locks and counters.
613  */
614 void fsnotify_init_mark(struct fsnotify_mark *mark,
615                         void (*free_mark)(struct fsnotify_mark *mark))
616 {
617         memset(mark, 0, sizeof(*mark));
618         spin_lock_init(&mark->lock);
619         atomic_set(&mark->refcnt, 1);
620         mark->free_mark = free_mark;
621 }
622
623 /*
624  * Destroy all marks in destroy_list, waits for SRCU period to finish before
625  * actually freeing marks.
626  */
627 void fsnotify_mark_destroy_list(void)
628 {
629         struct fsnotify_mark *mark, *next;
630         struct list_head private_destroy_list;
631
632         spin_lock(&destroy_lock);
633         /* exchange the list head */
634         list_replace_init(&destroy_list, &private_destroy_list);
635         spin_unlock(&destroy_lock);
636
637         synchronize_srcu(&fsnotify_mark_srcu);
638
639         list_for_each_entry_safe(mark, next, &private_destroy_list, g_list) {
640                 list_del_init(&mark->g_list);
641                 fsnotify_put_mark(mark);
642         }
643 }
644
645 static void fsnotify_mark_destroy_workfn(struct work_struct *work)
646 {
647         fsnotify_mark_destroy_list();
648 }