fsnotify: store struct file not struct path
[linux-2.6.git] / fs / notify / group.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/list.h>
20 #include <linux/mutex.h>
21 #include <linux/slab.h>
22 #include <linux/srcu.h>
23 #include <linux/rculist.h>
24 #include <linux/wait.h>
25
26 #include <linux/fsnotify_backend.h>
27 #include "fsnotify.h"
28
29 #include <asm/atomic.h>
30
31 /* protects writes to fsnotify_groups and fsnotify_mask */
32 static DEFINE_MUTEX(fsnotify_grp_mutex);
33 /* protects reads while running the fsnotify_groups list */
34 struct srcu_struct fsnotify_grp_srcu;
35 /* all groups registered to receive inode filesystem notifications */
36 LIST_HEAD(fsnotify_inode_groups);
37 /* all groups registered to receive mount point filesystem notifications */
38 LIST_HEAD(fsnotify_vfsmount_groups);
39 /* bitwise OR of all events (FS_*) interesting to some group on this system */
40 __u32 fsnotify_inode_mask;
41 /* bitwise OR of all events (FS_*) interesting to some group on this system */
42 __u32 fsnotify_vfsmount_mask;
43
44 /*
45  * When a new group registers or changes it's set of interesting events
46  * this function updates the fsnotify_mask to contain all interesting events
47  */
48 void fsnotify_recalc_global_mask(void)
49 {
50         struct fsnotify_group *group;
51         __u32 inode_mask = 0;
52         __u32 vfsmount_mask = 0;
53         int idx;
54
55         idx = srcu_read_lock(&fsnotify_grp_srcu);
56         list_for_each_entry_rcu(group, &fsnotify_inode_groups, inode_group_list)
57                 inode_mask |= group->mask;
58         list_for_each_entry_rcu(group, &fsnotify_vfsmount_groups, vfsmount_group_list)
59                 vfsmount_mask |= group->mask;
60                 
61         srcu_read_unlock(&fsnotify_grp_srcu, idx);
62
63         fsnotify_inode_mask = inode_mask;
64         fsnotify_vfsmount_mask = vfsmount_mask;
65 }
66
67 /*
68  * Update the group->mask by running all of the marks associated with this
69  * group and finding the bitwise | of all of the mark->mask.  If we change
70  * the group->mask we need to update the global mask of events interesting
71  * to the system.
72  */
73 void fsnotify_recalc_group_mask(struct fsnotify_group *group)
74 {
75         __u32 mask = 0;
76         __u32 old_mask = group->mask;
77         struct fsnotify_mark *mark;
78
79         spin_lock(&group->mark_lock);
80         list_for_each_entry(mark, &group->marks_list, g_list)
81                 mask |= mark->mask;
82         spin_unlock(&group->mark_lock);
83
84         group->mask = mask;
85
86         if (old_mask != mask)
87                 fsnotify_recalc_global_mask();
88 }
89
90 void fsnotify_add_vfsmount_group(struct fsnotify_group *group)
91 {
92         struct fsnotify_group *group_iter;
93
94         mutex_lock(&fsnotify_grp_mutex);
95
96         if (!group->on_vfsmount_group_list) {
97                 list_for_each_entry(group_iter, &fsnotify_vfsmount_groups,
98                                     vfsmount_group_list) {
99                         /* insert in front of this one? */
100                         if (group < group_iter) {
101                                 /* list_add_tail() insert in front of group_iter */
102                                 list_add_tail_rcu(&group->inode_group_list,
103                                                   &group_iter->inode_group_list);
104                                 goto out;
105                         }
106                 }
107
108                 /* apparently we need to be the last entry */
109                 list_add_tail_rcu(&group->vfsmount_group_list, &fsnotify_vfsmount_groups);
110         }
111 out:
112         group->on_vfsmount_group_list = 1;
113
114         mutex_unlock(&fsnotify_grp_mutex);
115 }
116
117 void fsnotify_add_inode_group(struct fsnotify_group *group)
118 {
119         struct fsnotify_group *group_iter;
120
121         mutex_lock(&fsnotify_grp_mutex);
122
123         /* add to global group list */
124         if (!group->on_inode_group_list) {
125                 list_for_each_entry(group_iter, &fsnotify_inode_groups,
126                                     inode_group_list) {
127                         if (group < group_iter) {
128                                 /* list_add_tail() insert in front of group_iter */
129                                 list_add_tail_rcu(&group->inode_group_list,
130                                                   &group_iter->inode_group_list);
131                                 goto out;
132                         }
133                 }
134
135                 /* apparently we need to be the last entry */
136                 list_add_tail_rcu(&group->inode_group_list, &fsnotify_inode_groups);
137         }
138 out:
139         group->on_inode_group_list = 1;
140
141         mutex_unlock(&fsnotify_grp_mutex);
142 }
143
144 /*
145  * Final freeing of a group
146  */
147 void fsnotify_final_destroy_group(struct fsnotify_group *group)
148 {
149         /* clear the notification queue of all events */
150         fsnotify_flush_notify(group);
151
152         if (group->ops->free_group_priv)
153                 group->ops->free_group_priv(group);
154
155         kfree(group);
156 }
157
158 /*
159  * Trying to get rid of a group.  We need to first get rid of any outstanding
160  * allocations and then free the group.  Remember that fsnotify_clear_marks_by_group
161  * could miss marks that are being freed by inode and those marks could still
162  * hold a reference to this group (via group->num_marks)  If we get into that
163  * situtation, the fsnotify_final_destroy_group will get called when that final
164  * mark is freed.
165  */
166 static void fsnotify_destroy_group(struct fsnotify_group *group)
167 {
168         /* clear all inode marks for this group */
169         fsnotify_clear_marks_by_group(group);
170
171         /* past the point of no return, matches the initial value of 1 */
172         if (atomic_dec_and_test(&group->num_marks))
173                 fsnotify_final_destroy_group(group);
174 }
175
176 /*
177  * Remove this group from the global list of groups that will get events
178  * this can be done even if there are still references and things still using
179  * this group.  This just stops the group from getting new events.
180  */
181 static void __fsnotify_evict_group(struct fsnotify_group *group)
182 {
183         BUG_ON(!mutex_is_locked(&fsnotify_grp_mutex));
184
185         if (group->on_inode_group_list)
186                 list_del_rcu(&group->inode_group_list);
187         group->on_inode_group_list = 0;
188         if (group->on_vfsmount_group_list)
189                 list_del_rcu(&group->vfsmount_group_list);
190         group->on_vfsmount_group_list = 0;
191 }
192
193 /*
194  * Called when a group is no longer interested in getting events.  This can be
195  * used if a group is misbehaving or if for some reason a group should no longer
196  * get any filesystem events.
197  */
198 void fsnotify_evict_group(struct fsnotify_group *group)
199 {
200         mutex_lock(&fsnotify_grp_mutex);
201         __fsnotify_evict_group(group);
202         mutex_unlock(&fsnotify_grp_mutex);
203 }
204
205 /*
206  * Drop a reference to a group.  Free it if it's through.
207  */
208 void fsnotify_put_group(struct fsnotify_group *group)
209 {
210         if (!atomic_dec_and_mutex_lock(&group->refcnt, &fsnotify_grp_mutex))
211                 return;
212
213         /*
214          * OK, now we know that there's no other users *and* we hold mutex,
215          * so no new references will appear
216          */
217         __fsnotify_evict_group(group);
218
219         /*
220          * now it's off the list, so the only thing we might care about is
221          * srcu access....
222          */
223         mutex_unlock(&fsnotify_grp_mutex);
224         synchronize_srcu(&fsnotify_grp_srcu);
225
226         /* and now it is really dead. _Nothing_ could be seeing it */
227         fsnotify_recalc_global_mask();
228         fsnotify_destroy_group(group);
229 }
230
231 /*
232  * Create a new fsnotify_group and hold a reference for the group returned.
233  */
234 struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops)
235 {
236         struct fsnotify_group *group;
237
238         group = kzalloc(sizeof(struct fsnotify_group), GFP_KERNEL);
239         if (!group)
240                 return ERR_PTR(-ENOMEM);
241
242         /* set to 0 when there a no external references to this group */
243         atomic_set(&group->refcnt, 1);
244         /*
245          * hits 0 when there are no external references AND no marks for
246          * this group
247          */
248         atomic_set(&group->num_marks, 1);
249
250         mutex_init(&group->notification_mutex);
251         INIT_LIST_HEAD(&group->notification_list);
252         init_waitqueue_head(&group->notification_waitq);
253         group->max_events = UINT_MAX;
254
255         INIT_LIST_HEAD(&group->inode_group_list);
256         INIT_LIST_HEAD(&group->vfsmount_group_list);
257
258         spin_lock_init(&group->mark_lock);
259         INIT_LIST_HEAD(&group->marks_list);
260
261         group->ops = ops;
262
263         return group;
264 }