Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Directory notifications for Linux. | |
3 | * | |
4 | * Copyright (C) 2000,2001,2002 Stephen Rothwell | |
5 | * | |
3c5119c0 EP |
6 | * Copyright (C) 2009 Eric Paris <Red Hat Inc> |
7 | * dnotify was largly rewritten to use the new fsnotify infrastructure | |
8 | * | |
1da177e4 LT |
9 | * This program is free software; you can redistribute it and/or modify it |
10 | * under the terms of the GNU General Public License as published by the | |
11 | * Free Software Foundation; either version 2, or (at your option) any | |
12 | * later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, but | |
15 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
17 | * General Public License for more details. | |
18 | */ | |
19 | #include <linux/fs.h> | |
20 | #include <linux/module.h> | |
21 | #include <linux/sched.h> | |
22 | #include <linux/dnotify.h> | |
23 | #include <linux/init.h> | |
24 | #include <linux/spinlock.h> | |
25 | #include <linux/slab.h> | |
9f3acc31 | 26 | #include <linux/fdtable.h> |
3c5119c0 | 27 | #include <linux/fsnotify_backend.h> |
1da177e4 | 28 | |
fa3536cc | 29 | int dir_notify_enable __read_mostly = 1; |
1da177e4 | 30 | |
3c5119c0 | 31 | static struct kmem_cache *dnotify_struct_cache __read_mostly; |
ef5e2b78 | 32 | static struct kmem_cache *dnotify_mark_cache __read_mostly; |
3c5119c0 | 33 | static struct fsnotify_group *dnotify_group __read_mostly; |
3c5119c0 EP |
34 | |
35 | /* | |
e61ce867 | 36 | * dnotify will attach one of these to each inode (i_fsnotify_marks) which |
3c5119c0 EP |
37 | * is being watched by dnotify. If multiple userspace applications are watching |
38 | * the same directory with dnotify their information is chained in dn | |
39 | */ | |
ef5e2b78 EP |
40 | struct dnotify_mark { |
41 | struct fsnotify_mark fsn_mark; | |
3c5119c0 EP |
42 | struct dnotify_struct *dn; |
43 | }; | |
1da177e4 | 44 | |
3c5119c0 EP |
45 | /* |
46 | * When a process starts or stops watching an inode the set of events which | |
47 | * dnotify cares about for that inode may change. This function runs the | |
48 | * list of everything receiving dnotify events about this directory and calculates | |
49 | * the set of all those events. After it updates what dnotify is interested in | |
50 | * it calls the fsnotify function so it can update the set of all events relevant | |
51 | * to this inode. | |
52 | */ | |
ef5e2b78 | 53 | static void dnotify_recalc_inode_mask(struct fsnotify_mark *fsn_mark) |
1da177e4 | 54 | { |
3c5119c0 | 55 | __u32 new_mask, old_mask; |
1da177e4 | 56 | struct dnotify_struct *dn; |
ef5e2b78 EP |
57 | struct dnotify_mark *dn_mark = container_of(fsn_mark, |
58 | struct dnotify_mark, | |
59 | fsn_mark); | |
3c5119c0 | 60 | |
ef5e2b78 | 61 | assert_spin_locked(&fsn_mark->lock); |
1da177e4 | 62 | |
ef5e2b78 | 63 | old_mask = fsn_mark->mask; |
1da177e4 | 64 | new_mask = 0; |
ef5e2b78 | 65 | for (dn = dn_mark->dn; dn != NULL; dn = dn->dn_next) |
3c5119c0 | 66 | new_mask |= (dn->dn_mask & ~FS_DN_MULTISHOT); |
90b1e7a5 | 67 | fsnotify_set_mark_mask_locked(fsn_mark, new_mask); |
3c5119c0 EP |
68 | |
69 | if (old_mask == new_mask) | |
70 | return; | |
71 | ||
ef5e2b78 EP |
72 | if (fsn_mark->i.inode) |
73 | fsnotify_recalc_inode_mask(fsn_mark->i.inode); | |
1da177e4 LT |
74 | } |
75 | ||
3c5119c0 EP |
76 | /* |
77 | * Mains fsnotify call where events are delivered to dnotify. | |
78 | * Find the dnotify mark on the relevant inode, run the list of dnotify structs | |
79 | * on that mark and determine which of them has expressed interest in receiving | |
80 | * events of this type. When found send the correct process and signal and | |
81 | * destroy the dnotify struct if it was not registered to receive multiple | |
82 | * events. | |
83 | */ | |
84 | static int dnotify_handle_event(struct fsnotify_group *group, | |
ce8f76fb EP |
85 | struct fsnotify_mark *inode_mark, |
86 | struct fsnotify_mark *vfsmount_mark, | |
3c5119c0 EP |
87 | struct fsnotify_event *event) |
88 | { | |
ef5e2b78 | 89 | struct dnotify_mark *dn_mark; |
3c5119c0 EP |
90 | struct inode *to_tell; |
91 | struct dnotify_struct *dn; | |
92 | struct dnotify_struct **prev; | |
93 | struct fown_struct *fown; | |
94552684 | 94 | __u32 test_mask = event->mask & ~FS_EVENT_ON_CHILD; |
3c5119c0 | 95 | |
ce8f76fb EP |
96 | BUG_ON(vfsmount_mark); |
97 | ||
3c5119c0 EP |
98 | to_tell = event->to_tell; |
99 | ||
ce8f76fb | 100 | dn_mark = container_of(inode_mark, struct dnotify_mark, fsn_mark); |
3c5119c0 | 101 | |
ce8f76fb | 102 | spin_lock(&inode_mark->lock); |
ef5e2b78 | 103 | prev = &dn_mark->dn; |
3c5119c0 | 104 | while ((dn = *prev) != NULL) { |
94552684 | 105 | if ((dn->dn_mask & test_mask) == 0) { |
3c5119c0 EP |
106 | prev = &dn->dn_next; |
107 | continue; | |
108 | } | |
109 | fown = &dn->dn_filp->f_owner; | |
110 | send_sigio(fown, dn->dn_fd, POLL_MSG); | |
111 | if (dn->dn_mask & FS_DN_MULTISHOT) | |
112 | prev = &dn->dn_next; | |
113 | else { | |
114 | *prev = dn->dn_next; | |
115 | kmem_cache_free(dnotify_struct_cache, dn); | |
ce8f76fb | 116 | dnotify_recalc_inode_mask(inode_mark); |
3c5119c0 EP |
117 | } |
118 | } | |
119 | ||
ce8f76fb | 120 | spin_unlock(&inode_mark->lock); |
3c5119c0 EP |
121 | |
122 | return 0; | |
123 | } | |
124 | ||
125 | /* | |
126 | * Given an inode and mask determine if dnotify would be interested in sending | |
127 | * userspace notification for that pair. | |
128 | */ | |
129 | static bool dnotify_should_send_event(struct fsnotify_group *group, | |
1968f5ee | 130 | struct inode *inode, |
ce8f76fb EP |
131 | struct fsnotify_mark *inode_mark, |
132 | struct fsnotify_mark *vfsmount_mark, | |
133 | __u32 mask, void *data, int data_type) | |
3c5119c0 | 134 | { |
3c5119c0 EP |
135 | /* not a dir, dnotify doesn't care */ |
136 | if (!S_ISDIR(inode->i_mode)) | |
137 | return false; | |
138 | ||
2612abb5 | 139 | return true; |
3c5119c0 EP |
140 | } |
141 | ||
ef5e2b78 | 142 | static void dnotify_free_mark(struct fsnotify_mark *fsn_mark) |
3c5119c0 | 143 | { |
ef5e2b78 EP |
144 | struct dnotify_mark *dn_mark = container_of(fsn_mark, |
145 | struct dnotify_mark, | |
146 | fsn_mark); | |
3c5119c0 | 147 | |
ef5e2b78 | 148 | BUG_ON(dn_mark->dn); |
3c5119c0 | 149 | |
ef5e2b78 | 150 | kmem_cache_free(dnotify_mark_cache, dn_mark); |
3c5119c0 EP |
151 | } |
152 | ||
153 | static struct fsnotify_ops dnotify_fsnotify_ops = { | |
154 | .handle_event = dnotify_handle_event, | |
155 | .should_send_event = dnotify_should_send_event, | |
156 | .free_group_priv = NULL, | |
a092ee20 | 157 | .freeing_mark = NULL, |
e4aff117 | 158 | .free_event_priv = NULL, |
3c5119c0 EP |
159 | }; |
160 | ||
161 | /* | |
162 | * Called every time a file is closed. Looks first for a dnotify mark on the | |
e61ce867 | 163 | * inode. If one is found run all of the ->dn structures attached to that |
3c5119c0 EP |
164 | * mark for one relevant to this process closing the file and remove that |
165 | * dnotify_struct. If that was the last dnotify_struct also remove the | |
e61ce867 | 166 | * fsnotify_mark. |
3c5119c0 | 167 | */ |
1da177e4 LT |
168 | void dnotify_flush(struct file *filp, fl_owner_t id) |
169 | { | |
ef5e2b78 EP |
170 | struct fsnotify_mark *fsn_mark; |
171 | struct dnotify_mark *dn_mark; | |
1da177e4 LT |
172 | struct dnotify_struct *dn; |
173 | struct dnotify_struct **prev; | |
174 | struct inode *inode; | |
175 | ||
496ad9aa | 176 | inode = file_inode(filp); |
1da177e4 LT |
177 | if (!S_ISDIR(inode->i_mode)) |
178 | return; | |
3c5119c0 | 179 | |
5444e298 | 180 | fsn_mark = fsnotify_find_inode_mark(dnotify_group, inode); |
ef5e2b78 | 181 | if (!fsn_mark) |
3c5119c0 | 182 | return; |
ef5e2b78 | 183 | dn_mark = container_of(fsn_mark, struct dnotify_mark, fsn_mark); |
3c5119c0 | 184 | |
52f85729 | 185 | mutex_lock(&dnotify_group->mark_mutex); |
3c5119c0 | 186 | |
ef5e2b78 EP |
187 | spin_lock(&fsn_mark->lock); |
188 | prev = &dn_mark->dn; | |
1da177e4 LT |
189 | while ((dn = *prev) != NULL) { |
190 | if ((dn->dn_owner == id) && (dn->dn_filp == filp)) { | |
191 | *prev = dn->dn_next; | |
3c5119c0 | 192 | kmem_cache_free(dnotify_struct_cache, dn); |
ef5e2b78 | 193 | dnotify_recalc_inode_mask(fsn_mark); |
1da177e4 LT |
194 | break; |
195 | } | |
196 | prev = &dn->dn_next; | |
197 | } | |
3c5119c0 | 198 | |
ef5e2b78 | 199 | spin_unlock(&fsn_mark->lock); |
3c5119c0 | 200 | |
52f85729 LS |
201 | /* nothing else could have found us thanks to the dnotify_groups |
202 | mark_mutex */ | |
ef5e2b78 | 203 | if (dn_mark->dn == NULL) |
52f85729 | 204 | fsnotify_destroy_mark_locked(fsn_mark, dnotify_group); |
3c5119c0 | 205 | |
52f85729 | 206 | mutex_unlock(&dnotify_group->mark_mutex); |
3c5119c0 | 207 | |
ef5e2b78 | 208 | fsnotify_put_mark(fsn_mark); |
3c5119c0 EP |
209 | } |
210 | ||
211 | /* this conversion is done only at watch creation */ | |
212 | static __u32 convert_arg(unsigned long arg) | |
213 | { | |
214 | __u32 new_mask = FS_EVENT_ON_CHILD; | |
215 | ||
216 | if (arg & DN_MULTISHOT) | |
217 | new_mask |= FS_DN_MULTISHOT; | |
218 | if (arg & DN_DELETE) | |
219 | new_mask |= (FS_DELETE | FS_MOVED_FROM); | |
220 | if (arg & DN_MODIFY) | |
221 | new_mask |= FS_MODIFY; | |
222 | if (arg & DN_ACCESS) | |
223 | new_mask |= FS_ACCESS; | |
224 | if (arg & DN_ATTRIB) | |
225 | new_mask |= FS_ATTRIB; | |
226 | if (arg & DN_RENAME) | |
227 | new_mask |= FS_DN_RENAME; | |
228 | if (arg & DN_CREATE) | |
229 | new_mask |= (FS_CREATE | FS_MOVED_TO); | |
230 | ||
231 | return new_mask; | |
1da177e4 LT |
232 | } |
233 | ||
3c5119c0 EP |
234 | /* |
235 | * If multiple processes watch the same inode with dnotify there is only one | |
e61ce867 | 236 | * dnotify mark in inode->i_fsnotify_marks but we chain a dnotify_struct |
3c5119c0 EP |
237 | * onto that mark. This function either attaches the new dnotify_struct onto |
238 | * that list, or it |= the mask onto an existing dnofiy_struct. | |
239 | */ | |
ef5e2b78 | 240 | static int attach_dn(struct dnotify_struct *dn, struct dnotify_mark *dn_mark, |
3c5119c0 EP |
241 | fl_owner_t id, int fd, struct file *filp, __u32 mask) |
242 | { | |
243 | struct dnotify_struct *odn; | |
244 | ||
ef5e2b78 | 245 | odn = dn_mark->dn; |
3c5119c0 EP |
246 | while (odn != NULL) { |
247 | /* adding more events to existing dnofiy_struct? */ | |
248 | if ((odn->dn_owner == id) && (odn->dn_filp == filp)) { | |
249 | odn->dn_fd = fd; | |
250 | odn->dn_mask |= mask; | |
251 | return -EEXIST; | |
252 | } | |
253 | odn = odn->dn_next; | |
254 | } | |
255 | ||
256 | dn->dn_mask = mask; | |
257 | dn->dn_fd = fd; | |
258 | dn->dn_filp = filp; | |
259 | dn->dn_owner = id; | |
ef5e2b78 EP |
260 | dn->dn_next = dn_mark->dn; |
261 | dn_mark->dn = dn; | |
3c5119c0 EP |
262 | |
263 | return 0; | |
264 | } | |
265 | ||
266 | /* | |
267 | * When a process calls fcntl to attach a dnotify watch to a directory it ends | |
268 | * up here. Allocate both a mark for fsnotify to add and a dnotify_struct to be | |
269 | * attached to the fsnotify_mark. | |
270 | */ | |
1da177e4 LT |
271 | int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg) |
272 | { | |
ef5e2b78 EP |
273 | struct dnotify_mark *new_dn_mark, *dn_mark; |
274 | struct fsnotify_mark *new_fsn_mark, *fsn_mark; | |
1da177e4 | 275 | struct dnotify_struct *dn; |
1da177e4 LT |
276 | struct inode *inode; |
277 | fl_owner_t id = current->files; | |
214b7049 | 278 | struct file *f; |
3c5119c0 EP |
279 | int destroy = 0, error = 0; |
280 | __u32 mask; | |
281 | ||
282 | /* we use these to tell if we need to kfree */ | |
ef5e2b78 | 283 | new_fsn_mark = NULL; |
3c5119c0 | 284 | dn = NULL; |
1da177e4 | 285 | |
3c5119c0 EP |
286 | if (!dir_notify_enable) { |
287 | error = -EINVAL; | |
288 | goto out_err; | |
289 | } | |
290 | ||
291 | /* a 0 mask means we are explicitly removing the watch */ | |
1da177e4 LT |
292 | if ((arg & ~DN_MULTISHOT) == 0) { |
293 | dnotify_flush(filp, id); | |
3c5119c0 EP |
294 | error = 0; |
295 | goto out_err; | |
1da177e4 | 296 | } |
3c5119c0 EP |
297 | |
298 | /* dnotify only works on directories */ | |
496ad9aa | 299 | inode = file_inode(filp); |
3c5119c0 EP |
300 | if (!S_ISDIR(inode->i_mode)) { |
301 | error = -ENOTDIR; | |
302 | goto out_err; | |
1da177e4 LT |
303 | } |
304 | ||
3c5119c0 EP |
305 | /* expect most fcntl to add new rather than augment old */ |
306 | dn = kmem_cache_alloc(dnotify_struct_cache, GFP_KERNEL); | |
307 | if (!dn) { | |
308 | error = -ENOMEM; | |
309 | goto out_err; | |
310 | } | |
214b7049 | 311 | |
3c5119c0 | 312 | /* new fsnotify mark, we expect most fcntl calls to add a new mark */ |
ef5e2b78 EP |
313 | new_dn_mark = kmem_cache_alloc(dnotify_mark_cache, GFP_KERNEL); |
314 | if (!new_dn_mark) { | |
3c5119c0 EP |
315 | error = -ENOMEM; |
316 | goto out_err; | |
317 | } | |
1da177e4 | 318 | |
3c5119c0 EP |
319 | /* convert the userspace DN_* "arg" to the internal FS_* defines in fsnotify */ |
320 | mask = convert_arg(arg); | |
1da177e4 | 321 | |
ef5e2b78 EP |
322 | /* set up the new_fsn_mark and new_dn_mark */ |
323 | new_fsn_mark = &new_dn_mark->fsn_mark; | |
324 | fsnotify_init_mark(new_fsn_mark, dnotify_free_mark); | |
325 | new_fsn_mark->mask = mask; | |
326 | new_dn_mark->dn = NULL; | |
1da177e4 | 327 | |
3c5119c0 | 328 | /* this is needed to prevent the fcntl/close race described below */ |
52f85729 | 329 | mutex_lock(&dnotify_group->mark_mutex); |
1da177e4 | 330 | |
ef5e2b78 | 331 | /* add the new_fsn_mark or find an old one. */ |
5444e298 | 332 | fsn_mark = fsnotify_find_inode_mark(dnotify_group, inode); |
ef5e2b78 EP |
333 | if (fsn_mark) { |
334 | dn_mark = container_of(fsn_mark, struct dnotify_mark, fsn_mark); | |
335 | spin_lock(&fsn_mark->lock); | |
3c5119c0 | 336 | } else { |
52f85729 LS |
337 | fsnotify_add_mark_locked(new_fsn_mark, dnotify_group, inode, |
338 | NULL, 0); | |
ef5e2b78 EP |
339 | spin_lock(&new_fsn_mark->lock); |
340 | fsn_mark = new_fsn_mark; | |
341 | dn_mark = new_dn_mark; | |
342 | /* we used new_fsn_mark, so don't free it */ | |
343 | new_fsn_mark = NULL; | |
3c5119c0 | 344 | } |
1da177e4 | 345 | |
3c5119c0 EP |
346 | rcu_read_lock(); |
347 | f = fcheck(fd); | |
348 | rcu_read_unlock(); | |
1da177e4 | 349 | |
3c5119c0 EP |
350 | /* if (f != filp) means that we lost a race and another task/thread |
351 | * actually closed the fd we are still playing with before we grabbed | |
52f85729 LS |
352 | * the dnotify_groups mark_mutex and fsn_mark->lock. Since closing the |
353 | * fd is the only time we clean up the marks we need to get our mark | |
354 | * off the list. */ | |
3c5119c0 EP |
355 | if (f != filp) { |
356 | /* if we added ourselves, shoot ourselves, it's possible that | |
ef5e2b78 | 357 | * the flush actually did shoot this fsn_mark. That's fine too |
3c5119c0 | 358 | * since multiple calls to destroy_mark is perfectly safe, if |
ef5e2b78 | 359 | * we found a dn_mark already attached to the inode, just sod |
3c5119c0 EP |
360 | * off silently as the flush at close time dealt with it. |
361 | */ | |
ef5e2b78 | 362 | if (dn_mark == new_dn_mark) |
3c5119c0 EP |
363 | destroy = 1; |
364 | goto out; | |
365 | } | |
1da177e4 | 366 | |
3c5119c0 EP |
367 | error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0); |
368 | if (error) { | |
369 | /* if we added, we must shoot */ | |
ef5e2b78 | 370 | if (dn_mark == new_dn_mark) |
3c5119c0 EP |
371 | destroy = 1; |
372 | goto out; | |
1da177e4 | 373 | } |
3c5119c0 | 374 | |
ef5e2b78 EP |
375 | error = attach_dn(dn, dn_mark, id, fd, filp, mask); |
376 | /* !error means that we attached the dn to the dn_mark, so don't free it */ | |
3c5119c0 EP |
377 | if (!error) |
378 | dn = NULL; | |
379 | /* -EEXIST means that we didn't add this new dn and used an old one. | |
380 | * that isn't an error (and the unused dn should be freed) */ | |
381 | else if (error == -EEXIST) | |
382 | error = 0; | |
383 | ||
ef5e2b78 | 384 | dnotify_recalc_inode_mask(fsn_mark); |
3c5119c0 | 385 | out: |
ef5e2b78 | 386 | spin_unlock(&fsn_mark->lock); |
3c5119c0 EP |
387 | |
388 | if (destroy) | |
52f85729 | 389 | fsnotify_destroy_mark_locked(fsn_mark, dnotify_group); |
3c5119c0 | 390 | |
52f85729 | 391 | mutex_unlock(&dnotify_group->mark_mutex); |
ef5e2b78 | 392 | fsnotify_put_mark(fsn_mark); |
3c5119c0 | 393 | out_err: |
ef5e2b78 EP |
394 | if (new_fsn_mark) |
395 | fsnotify_put_mark(new_fsn_mark); | |
3c5119c0 EP |
396 | if (dn) |
397 | kmem_cache_free(dnotify_struct_cache, dn); | |
398 | return error; | |
1da177e4 | 399 | } |
1da177e4 LT |
400 | |
401 | static int __init dnotify_init(void) | |
402 | { | |
3c5119c0 | 403 | dnotify_struct_cache = KMEM_CACHE(dnotify_struct, SLAB_PANIC); |
ef5e2b78 | 404 | dnotify_mark_cache = KMEM_CACHE(dnotify_mark, SLAB_PANIC); |
3c5119c0 | 405 | |
0d2e2a1d | 406 | dnotify_group = fsnotify_alloc_group(&dnotify_fsnotify_ops); |
3c5119c0 EP |
407 | if (IS_ERR(dnotify_group)) |
408 | panic("unable to allocate fsnotify group for dnotify\n"); | |
1da177e4 LT |
409 | return 0; |
410 | } | |
411 | ||
412 | module_init(dnotify_init) |