fsnotify: place marks on object in order of group memory address
[linux-2.6.git] / fs / notify / vfsmount_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 #include <linux/fs.h>
20 #include <linux/init.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/mount.h>
24 #include <linux/mutex.h>
25 #include <linux/spinlock.h>
26 #include <linux/writeback.h> /* for inode_lock */
27
28 #include <asm/atomic.h>
29
30 #include <linux/fsnotify_backend.h>
31 #include "fsnotify.h"
32
33 void fsnotify_clear_marks_by_mount(struct vfsmount *mnt)
34 {
35         struct fsnotify_mark *mark, *lmark;
36         struct hlist_node *pos, *n;
37         LIST_HEAD(free_list);
38
39         spin_lock(&mnt->mnt_root->d_lock);
40         hlist_for_each_entry_safe(mark, pos, n, &mnt->mnt_fsnotify_marks, m.m_list) {
41                 list_add(&mark->m.free_m_list, &free_list);
42                 hlist_del_init(&mark->m.m_list);
43                 fsnotify_get_mark(mark);
44         }
45         spin_unlock(&mnt->mnt_root->d_lock);
46
47         list_for_each_entry_safe(mark, lmark, &free_list, m.free_m_list) {
48                 fsnotify_destroy_mark(mark);
49                 fsnotify_put_mark(mark);
50         }
51 }
52
53 void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group)
54 {
55         fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_MARK_FLAG_VFSMOUNT);
56 }
57
58 /*
59  * Recalculate the mask of events relevant to a given vfsmount locked.
60  */
61 static void fsnotify_recalc_vfsmount_mask_locked(struct vfsmount *mnt)
62 {
63         struct fsnotify_mark *mark;
64         struct hlist_node *pos;
65         __u32 new_mask = 0;
66
67         assert_spin_locked(&mnt->mnt_root->d_lock);
68
69         hlist_for_each_entry(mark, pos, &mnt->mnt_fsnotify_marks, m.m_list)
70                 new_mask |= mark->mask;
71         mnt->mnt_fsnotify_mask = new_mask;
72 }
73
74 /*
75  * Recalculate the mnt->mnt_fsnotify_mask, or the mask of all FS_* event types
76  * any notifier is interested in hearing for this mount point
77  */
78 void fsnotify_recalc_vfsmount_mask(struct vfsmount *mnt)
79 {
80         spin_lock(&mnt->mnt_root->d_lock);
81         fsnotify_recalc_vfsmount_mask_locked(mnt);
82         spin_unlock(&mnt->mnt_root->d_lock);
83 }
84
85 void fsnotify_destroy_vfsmount_mark(struct fsnotify_mark *mark)
86 {
87         struct vfsmount *mnt = mark->m.mnt;
88
89         assert_spin_locked(&mark->lock);
90         assert_spin_locked(&mark->group->mark_lock);
91
92         spin_lock(&mnt->mnt_root->d_lock);
93
94         hlist_del_init(&mark->m.m_list);
95         mark->m.mnt = NULL;
96
97         fsnotify_recalc_vfsmount_mask_locked(mnt);
98
99         spin_unlock(&mnt->mnt_root->d_lock);
100 }
101
102 static struct fsnotify_mark *fsnotify_find_vfsmount_mark_locked(struct fsnotify_group *group,
103                                                                 struct vfsmount *mnt)
104 {
105         struct fsnotify_mark *mark;
106         struct hlist_node *pos;
107
108         assert_spin_locked(&mnt->mnt_root->d_lock);
109
110         hlist_for_each_entry(mark, pos, &mnt->mnt_fsnotify_marks, m.m_list) {
111                 if (mark->group == group) {
112                         fsnotify_get_mark(mark);
113                         return mark;
114                 }
115         }
116         return NULL;
117 }
118
119 /*
120  * given a group and vfsmount, find the mark associated with that combination.
121  * if found take a reference to that mark and return it, else return NULL
122  */
123 struct fsnotify_mark *fsnotify_find_vfsmount_mark(struct fsnotify_group *group,
124                                                   struct vfsmount *mnt)
125 {
126         struct fsnotify_mark *mark;
127
128         spin_lock(&mnt->mnt_root->d_lock);
129         mark = fsnotify_find_vfsmount_mark_locked(group, mnt);
130         spin_unlock(&mnt->mnt_root->d_lock);
131
132         return mark;
133 }
134
135 /*
136  * Attach an initialized mark to a given group and vfsmount.
137  * These marks may be used for the fsnotify backend to determine which
138  * event types should be delivered to which groups.
139  */
140 int fsnotify_add_vfsmount_mark(struct fsnotify_mark *mark,
141                                struct fsnotify_group *group, struct vfsmount *mnt,
142                                int allow_dups)
143 {
144         struct fsnotify_mark *lmark;
145         struct hlist_node *node, *last = NULL;
146         int ret = 0;
147
148         mark->flags = FSNOTIFY_MARK_FLAG_VFSMOUNT;
149
150         assert_spin_locked(&mark->lock);
151         assert_spin_locked(&group->mark_lock);
152
153         spin_lock(&mnt->mnt_root->d_lock);
154
155         mark->m.mnt = mnt;
156
157         /* is mark the first mark? */
158         if (hlist_empty(&mnt->mnt_fsnotify_marks)) {
159                 hlist_add_head(&mark->m.m_list, &mnt->mnt_fsnotify_marks);
160                 goto out;
161         }
162
163         /* should mark be in the middle of the current list? */
164         hlist_for_each_entry(lmark, node, &mnt->mnt_fsnotify_marks, m.m_list) {
165                 last = node;
166
167                 if ((lmark->group == group) && !allow_dups) {
168                         ret = -EEXIST;
169                         goto out;
170                 }
171
172                 if (mark->group < lmark->group)
173                         continue;
174
175                 hlist_add_before(&mark->m.m_list, &lmark->m.m_list);
176                 goto out;
177         }
178
179         BUG_ON(last == NULL);
180         /* mark should be the last entry.  last is the current last entry */
181         hlist_add_after(last, &mark->m.m_list);
182 out:
183         fsnotify_recalc_vfsmount_mask_locked(mnt);
184         spin_unlock(&mnt->mnt_root->d_lock);
185
186         return ret;
187 }