Commit | Line | Data |
---|---|---|
0eeca283 RL |
1 | /* |
2 | * fs/inotify.c - inode-based file event notifications | |
3 | * | |
4 | * Authors: | |
5 | * John McCutchan <ttb@tentacle.dhs.org> | |
6 | * Robert Love <rml@novell.com> | |
7 | * | |
2d9048e2 AG |
8 | * Kernel API added by: Amy Griffis <amy.griffis@hp.com> |
9 | * | |
0eeca283 | 10 | * Copyright (C) 2005 John McCutchan |
2d9048e2 | 11 | * Copyright 2006 Hewlett-Packard Development Company, L.P. |
0eeca283 RL |
12 | * |
13 | * This program is free software; you can redistribute it and/or modify it | |
14 | * under the terms of the GNU General Public License as published by the | |
15 | * Free Software Foundation; either version 2, or (at your option) any | |
16 | * later version. | |
17 | * | |
18 | * This program is distributed in the hope that it will be useful, but | |
19 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
21 | * General Public License for more details. | |
22 | */ | |
23 | ||
24 | #include <linux/module.h> | |
25 | #include <linux/kernel.h> | |
0eeca283 RL |
26 | #include <linux/spinlock.h> |
27 | #include <linux/idr.h> | |
28 | #include <linux/slab.h> | |
29 | #include <linux/fs.h> | |
914e2637 | 30 | #include <linux/sched.h> |
0eeca283 RL |
31 | #include <linux/init.h> |
32 | #include <linux/list.h> | |
33 | #include <linux/writeback.h> | |
34 | #include <linux/inotify.h> | |
90586523 | 35 | #include <linux/fsnotify_backend.h> |
0eeca283 RL |
36 | |
37 | static atomic_t inotify_cookie; | |
38 | ||
0eeca283 RL |
39 | /* |
40 | * Lock ordering: | |
41 | * | |
42 | * dentry->d_lock (used to keep d_move() away from dentry->d_parent) | |
f24075bd | 43 | * iprune_mutex (synchronize shrink_icache_memory()) |
0eeca283 | 44 | * inode_lock (protects the super_block->s_inodes list) |
d4f9af9d | 45 | * inode->inotify_mutex (protects inode->inotify_watches and watches->i_list) |
2d9048e2 AG |
46 | * inotify_handle->mutex (protects inotify_handle and watches->h_list) |
47 | * | |
48 | * The inode->inotify_mutex and inotify_handle->mutex and held during execution | |
49 | * of a caller's event handler. Thus, the caller must not hold any locks | |
50 | * taken in their event handler while calling any of the published inotify | |
51 | * interfaces. | |
0eeca283 RL |
52 | */ |
53 | ||
54 | /* | |
2d9048e2 | 55 | * Lifetimes of the three main data structures--inotify_handle, inode, and |
0eeca283 RL |
56 | * inotify_watch--are managed by reference count. |
57 | * | |
2d9048e2 AG |
58 | * inotify_handle: Lifetime is from inotify_init() to inotify_destroy(). |
59 | * Additional references can bump the count via get_inotify_handle() and drop | |
60 | * the count via put_inotify_handle(). | |
0eeca283 | 61 | * |
2d9048e2 AG |
62 | * inotify_watch: for inotify's purposes, lifetime is from inotify_add_watch() |
63 | * to remove_watch_no_event(). Additional references can bump the count via | |
64 | * get_inotify_watch() and drop the count via put_inotify_watch(). The caller | |
65 | * is reponsible for the final put after receiving IN_IGNORED, or when using | |
66 | * IN_ONESHOT after receiving the first event. Inotify does the final put if | |
67 | * inotify_destroy() is called. | |
0eeca283 RL |
68 | * |
69 | * inode: Pinned so long as the inode is associated with a watch, from | |
2d9048e2 | 70 | * inotify_add_watch() to the final put_inotify_watch(). |
0eeca283 RL |
71 | */ |
72 | ||
73 | /* | |
2d9048e2 | 74 | * struct inotify_handle - represents an inotify instance |
0eeca283 | 75 | * |
d4f9af9d | 76 | * This structure is protected by the mutex 'mutex'. |
0eeca283 | 77 | */ |
2d9048e2 | 78 | struct inotify_handle { |
0eeca283 | 79 | struct idr idr; /* idr mapping wd -> watch */ |
d4f9af9d | 80 | struct mutex mutex; /* protects this bad boy */ |
0eeca283 RL |
81 | struct list_head watches; /* list of watches */ |
82 | atomic_t count; /* reference count */ | |
b9c55d29 | 83 | u32 last_wd; /* the last wd allocated */ |
2d9048e2 | 84 | const struct inotify_operations *in_ops; /* inotify caller operations */ |
0eeca283 RL |
85 | }; |
86 | ||
2d9048e2 | 87 | static inline void get_inotify_handle(struct inotify_handle *ih) |
0eeca283 | 88 | { |
2d9048e2 | 89 | atomic_inc(&ih->count); |
0eeca283 RL |
90 | } |
91 | ||
2d9048e2 | 92 | static inline void put_inotify_handle(struct inotify_handle *ih) |
0eeca283 | 93 | { |
2d9048e2 AG |
94 | if (atomic_dec_and_test(&ih->count)) { |
95 | idr_destroy(&ih->idr); | |
96 | kfree(ih); | |
0eeca283 RL |
97 | } |
98 | } | |
99 | ||
2d9048e2 AG |
100 | /** |
101 | * get_inotify_watch - grab a reference to an inotify_watch | |
102 | * @watch: watch to grab | |
103 | */ | |
104 | void get_inotify_watch(struct inotify_watch *watch) | |
0eeca283 RL |
105 | { |
106 | atomic_inc(&watch->count); | |
107 | } | |
2d9048e2 | 108 | EXPORT_SYMBOL_GPL(get_inotify_watch); |
0eeca283 | 109 | |
8f7b0ba1 AV |
110 | int pin_inotify_watch(struct inotify_watch *watch) |
111 | { | |
112 | struct super_block *sb = watch->inode->i_sb; | |
b20bd1a5 | 113 | if (atomic_inc_not_zero(&sb->s_active)) { |
8f7b0ba1 AV |
114 | atomic_inc(&watch->count); |
115 | return 1; | |
116 | } | |
8f7b0ba1 AV |
117 | return 0; |
118 | } | |
119 | ||
2d9048e2 | 120 | /** |
0eeca283 | 121 | * put_inotify_watch - decrements the ref count on a given watch. cleans up |
2d9048e2 AG |
122 | * watch references if the count reaches zero. inotify_watch is freed by |
123 | * inotify callers via the destroy_watch() op. | |
124 | * @watch: watch to release | |
0eeca283 | 125 | */ |
2d9048e2 | 126 | void put_inotify_watch(struct inotify_watch *watch) |
0eeca283 RL |
127 | { |
128 | if (atomic_dec_and_test(&watch->count)) { | |
2d9048e2 | 129 | struct inotify_handle *ih = watch->ih; |
0eeca283 | 130 | |
2d9048e2 AG |
131 | iput(watch->inode); |
132 | ih->in_ops->destroy_watch(watch); | |
133 | put_inotify_handle(ih); | |
0eeca283 RL |
134 | } |
135 | } | |
2d9048e2 | 136 | EXPORT_SYMBOL_GPL(put_inotify_watch); |
0eeca283 | 137 | |
8f7b0ba1 AV |
138 | void unpin_inotify_watch(struct inotify_watch *watch) |
139 | { | |
140 | struct super_block *sb = watch->inode->i_sb; | |
141 | put_inotify_watch(watch); | |
142 | deactivate_super(sb); | |
143 | } | |
144 | ||
0eeca283 | 145 | /* |
2d9048e2 | 146 | * inotify_handle_get_wd - returns the next WD for use by the given handle |
0eeca283 | 147 | * |
2d9048e2 | 148 | * Callers must hold ih->mutex. This function can sleep. |
0eeca283 | 149 | */ |
2d9048e2 AG |
150 | static int inotify_handle_get_wd(struct inotify_handle *ih, |
151 | struct inotify_watch *watch) | |
0eeca283 RL |
152 | { |
153 | int ret; | |
154 | ||
155 | do { | |
f04b30de | 156 | if (unlikely(!idr_pre_get(&ih->idr, GFP_NOFS))) |
0eeca283 | 157 | return -ENOSPC; |
2d9048e2 | 158 | ret = idr_get_new_above(&ih->idr, watch, ih->last_wd+1, &watch->wd); |
0eeca283 RL |
159 | } while (ret == -EAGAIN); |
160 | ||
2d9048e2 AG |
161 | if (likely(!ret)) |
162 | ih->last_wd = watch->wd; | |
0eeca283 | 163 | |
2d9048e2 | 164 | return ret; |
0eeca283 RL |
165 | } |
166 | ||
c32ccd87 NP |
167 | /* |
168 | * inotify_inode_watched - returns nonzero if there are watches on this inode | |
169 | * and zero otherwise. We call this lockless, we do not care if we race. | |
170 | */ | |
171 | static inline int inotify_inode_watched(struct inode *inode) | |
172 | { | |
173 | return !list_empty(&inode->inotify_watches); | |
174 | } | |
175 | ||
176 | /* | |
177 | * Get child dentry flag into synch with parent inode. | |
178 | * Flag should always be clear for negative dentrys. | |
179 | */ | |
180 | static void set_dentry_child_flags(struct inode *inode, int watched) | |
181 | { | |
182 | struct dentry *alias; | |
183 | ||
184 | spin_lock(&dcache_lock); | |
185 | list_for_each_entry(alias, &inode->i_dentry, d_alias) { | |
186 | struct dentry *child; | |
187 | ||
188 | list_for_each_entry(child, &alias->d_subdirs, d_u.d_child) { | |
0d71bd59 | 189 | if (!child->d_inode) |
c32ccd87 | 190 | continue; |
0d71bd59 | 191 | |
c32ccd87 | 192 | spin_lock(&child->d_lock); |
0d71bd59 | 193 | if (watched) |
c32ccd87 | 194 | child->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED; |
0d71bd59 NP |
195 | else |
196 | child->d_flags &=~DCACHE_INOTIFY_PARENT_WATCHED; | |
c32ccd87 NP |
197 | spin_unlock(&child->d_lock); |
198 | } | |
199 | } | |
200 | spin_unlock(&dcache_lock); | |
201 | } | |
202 | ||
0eeca283 | 203 | /* |
2d9048e2 AG |
204 | * inotify_find_handle - find the watch associated with the given inode and |
205 | * handle | |
0eeca283 | 206 | * |
d4f9af9d | 207 | * Callers must hold inode->inotify_mutex. |
0eeca283 | 208 | */ |
2d9048e2 AG |
209 | static struct inotify_watch *inode_find_handle(struct inode *inode, |
210 | struct inotify_handle *ih) | |
0eeca283 RL |
211 | { |
212 | struct inotify_watch *watch; | |
213 | ||
214 | list_for_each_entry(watch, &inode->inotify_watches, i_list) { | |
2d9048e2 | 215 | if (watch->ih == ih) |
0eeca283 RL |
216 | return watch; |
217 | } | |
218 | ||
219 | return NULL; | |
220 | } | |
221 | ||
222 | /* | |
3ca10067 | 223 | * remove_watch_no_event - remove watch without the IN_IGNORED event. |
2d9048e2 AG |
224 | * |
225 | * Callers must hold both inode->inotify_mutex and ih->mutex. | |
0eeca283 RL |
226 | */ |
227 | static void remove_watch_no_event(struct inotify_watch *watch, | |
2d9048e2 | 228 | struct inotify_handle *ih) |
0eeca283 RL |
229 | { |
230 | list_del(&watch->i_list); | |
2d9048e2 | 231 | list_del(&watch->h_list); |
0eeca283 | 232 | |
c32ccd87 NP |
233 | if (!inotify_inode_watched(watch->inode)) |
234 | set_dentry_child_flags(watch->inode, 0); | |
235 | ||
2d9048e2 | 236 | idr_remove(&ih->idr, watch->wd); |
0eeca283 RL |
237 | } |
238 | ||
3ca10067 AG |
239 | /** |
240 | * inotify_remove_watch_locked - Remove a watch from both the handle and the | |
241 | * inode. Sends the IN_IGNORED event signifying that the inode is no longer | |
242 | * watched. May be invoked from a caller's event handler. | |
243 | * @ih: inotify handle associated with watch | |
244 | * @watch: watch to remove | |
0eeca283 | 245 | * |
2d9048e2 | 246 | * Callers must hold both inode->inotify_mutex and ih->mutex. |
0eeca283 | 247 | */ |
3ca10067 AG |
248 | void inotify_remove_watch_locked(struct inotify_handle *ih, |
249 | struct inotify_watch *watch) | |
0eeca283 | 250 | { |
2d9048e2 | 251 | remove_watch_no_event(watch, ih); |
7c297722 | 252 | ih->in_ops->handle_event(watch, watch->wd, IN_IGNORED, 0, NULL, NULL); |
0eeca283 | 253 | } |
3ca10067 | 254 | EXPORT_SYMBOL_GPL(inotify_remove_watch_locked); |
0eeca283 | 255 | |
2d9048e2 | 256 | /* Kernel API for producing events */ |
c32ccd87 | 257 | |
0eeca283 | 258 | /* |
c32ccd87 | 259 | * inotify_d_instantiate - instantiate dcache entry for inode |
0eeca283 | 260 | */ |
c32ccd87 | 261 | void inotify_d_instantiate(struct dentry *entry, struct inode *inode) |
0eeca283 | 262 | { |
c32ccd87 NP |
263 | struct dentry *parent; |
264 | ||
265 | if (!inode) | |
266 | return; | |
267 | ||
c32ccd87 NP |
268 | spin_lock(&entry->d_lock); |
269 | parent = entry->d_parent; | |
091e881d | 270 | if (parent->d_inode && inotify_inode_watched(parent->d_inode)) |
c32ccd87 NP |
271 | entry->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED; |
272 | spin_unlock(&entry->d_lock); | |
0eeca283 RL |
273 | } |
274 | ||
c32ccd87 NP |
275 | /* |
276 | * inotify_d_move - dcache entry has been moved | |
277 | */ | |
278 | void inotify_d_move(struct dentry *entry) | |
279 | { | |
280 | struct dentry *parent; | |
281 | ||
282 | parent = entry->d_parent; | |
283 | if (inotify_inode_watched(parent->d_inode)) | |
284 | entry->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED; | |
285 | else | |
286 | entry->d_flags &= ~DCACHE_INOTIFY_PARENT_WATCHED; | |
287 | } | |
0eeca283 RL |
288 | |
289 | /** | |
290 | * inotify_inode_queue_event - queue an event to all watches on this inode | |
291 | * @inode: inode event is originating from | |
292 | * @mask: event mask describing this event | |
293 | * @cookie: cookie for synchronization, or zero | |
294 | * @name: filename, if any | |
7c297722 | 295 | * @n_inode: inode associated with name |
0eeca283 RL |
296 | */ |
297 | void inotify_inode_queue_event(struct inode *inode, u32 mask, u32 cookie, | |
7c297722 | 298 | const char *name, struct inode *n_inode) |
0eeca283 RL |
299 | { |
300 | struct inotify_watch *watch, *next; | |
301 | ||
302 | if (!inotify_inode_watched(inode)) | |
303 | return; | |
304 | ||
d4f9af9d | 305 | mutex_lock(&inode->inotify_mutex); |
0eeca283 RL |
306 | list_for_each_entry_safe(watch, next, &inode->inotify_watches, i_list) { |
307 | u32 watch_mask = watch->mask; | |
308 | if (watch_mask & mask) { | |
2d9048e2 AG |
309 | struct inotify_handle *ih= watch->ih; |
310 | mutex_lock(&ih->mutex); | |
0eeca283 | 311 | if (watch_mask & IN_ONESHOT) |
2d9048e2 | 312 | remove_watch_no_event(watch, ih); |
7c297722 AG |
313 | ih->in_ops->handle_event(watch, watch->wd, mask, cookie, |
314 | name, n_inode); | |
2d9048e2 | 315 | mutex_unlock(&ih->mutex); |
0eeca283 RL |
316 | } |
317 | } | |
d4f9af9d | 318 | mutex_unlock(&inode->inotify_mutex); |
0eeca283 RL |
319 | } |
320 | EXPORT_SYMBOL_GPL(inotify_inode_queue_event); | |
321 | ||
322 | /** | |
323 | * inotify_dentry_parent_queue_event - queue an event to a dentry's parent | |
324 | * @dentry: the dentry in question, we queue against this dentry's parent | |
325 | * @mask: event mask describing this event | |
326 | * @cookie: cookie for synchronization, or zero | |
327 | * @name: filename, if any | |
328 | */ | |
329 | void inotify_dentry_parent_queue_event(struct dentry *dentry, u32 mask, | |
330 | u32 cookie, const char *name) | |
331 | { | |
332 | struct dentry *parent; | |
333 | struct inode *inode; | |
334 | ||
c32ccd87 | 335 | if (!(dentry->d_flags & DCACHE_INOTIFY_PARENT_WATCHED)) |
820249ba JM |
336 | return; |
337 | ||
0eeca283 RL |
338 | spin_lock(&dentry->d_lock); |
339 | parent = dentry->d_parent; | |
340 | inode = parent->d_inode; | |
341 | ||
342 | if (inotify_inode_watched(inode)) { | |
343 | dget(parent); | |
344 | spin_unlock(&dentry->d_lock); | |
7c297722 AG |
345 | inotify_inode_queue_event(inode, mask, cookie, name, |
346 | dentry->d_inode); | |
0eeca283 RL |
347 | dput(parent); |
348 | } else | |
349 | spin_unlock(&dentry->d_lock); | |
350 | } | |
351 | EXPORT_SYMBOL_GPL(inotify_dentry_parent_queue_event); | |
352 | ||
353 | /** | |
354 | * inotify_get_cookie - return a unique cookie for use in synchronizing events. | |
355 | */ | |
356 | u32 inotify_get_cookie(void) | |
357 | { | |
358 | return atomic_inc_return(&inotify_cookie); | |
359 | } | |
360 | EXPORT_SYMBOL_GPL(inotify_get_cookie); | |
361 | ||
362 | /** | |
363 | * inotify_unmount_inodes - an sb is unmounting. handle any watched inodes. | |
364 | * @list: list of inodes being unmounted (sb->s_inodes) | |
365 | * | |
366 | * Called with inode_lock held, protecting the unmounting super block's list | |
f24075bd | 367 | * of inodes, and with iprune_mutex held, keeping shrink_icache_memory() at bay. |
0eeca283 RL |
368 | * We temporarily drop inode_lock, however, and CAN block. |
369 | */ | |
370 | void inotify_unmount_inodes(struct list_head *list) | |
371 | { | |
372 | struct inode *inode, *next_i, *need_iput = NULL; | |
373 | ||
374 | list_for_each_entry_safe(inode, next_i, list, i_sb_list) { | |
375 | struct inotify_watch *watch, *next_w; | |
376 | struct inode *need_iput_tmp; | |
377 | struct list_head *watches; | |
378 | ||
aabb8fdb | 379 | /* |
a4ffdde6 | 380 | * We cannot __iget() an inode in state I_FREEING, |
aabb8fdb NP |
381 | * I_WILL_FREE, or I_NEW which is fine because by that point |
382 | * the inode cannot have any associated watches. | |
383 | */ | |
a4ffdde6 | 384 | if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) |
aabb8fdb NP |
385 | continue; |
386 | ||
0eeca283 RL |
387 | /* |
388 | * If i_count is zero, the inode cannot have any watches and | |
389 | * doing an __iget/iput with MS_ACTIVE clear would actually | |
390 | * evict all inodes with zero i_count from icache which is | |
391 | * unnecessarily violent and may in fact be illegal to do. | |
392 | */ | |
393 | if (!atomic_read(&inode->i_count)) | |
394 | continue; | |
395 | ||
0eeca283 RL |
396 | need_iput_tmp = need_iput; |
397 | need_iput = NULL; | |
3ca10067 | 398 | /* In case inotify_remove_watch_locked() drops a reference. */ |
0eeca283 RL |
399 | if (inode != need_iput_tmp) |
400 | __iget(inode); | |
401 | else | |
402 | need_iput_tmp = NULL; | |
403 | /* In case the dropping of a reference would nuke next_i. */ | |
404 | if ((&next_i->i_sb_list != list) && | |
405 | atomic_read(&next_i->i_count) && | |
a4ffdde6 | 406 | !(next_i->i_state & (I_FREEING|I_WILL_FREE))) { |
0eeca283 RL |
407 | __iget(next_i); |
408 | need_iput = next_i; | |
409 | } | |
410 | ||
411 | /* | |
412 | * We can safely drop inode_lock here because we hold | |
413 | * references on both inode and next_i. Also no new inodes | |
414 | * will be added since the umount has begun. Finally, | |
f24075bd | 415 | * iprune_mutex keeps shrink_icache_memory() away. |
0eeca283 RL |
416 | */ |
417 | spin_unlock(&inode_lock); | |
418 | ||
419 | if (need_iput_tmp) | |
420 | iput(need_iput_tmp); | |
421 | ||
422 | /* for each watch, send IN_UNMOUNT and then remove it */ | |
d4f9af9d | 423 | mutex_lock(&inode->inotify_mutex); |
0eeca283 RL |
424 | watches = &inode->inotify_watches; |
425 | list_for_each_entry_safe(watch, next_w, watches, i_list) { | |
2d9048e2 | 426 | struct inotify_handle *ih= watch->ih; |
6ee5a399 | 427 | get_inotify_watch(watch); |
2d9048e2 AG |
428 | mutex_lock(&ih->mutex); |
429 | ih->in_ops->handle_event(watch, watch->wd, IN_UNMOUNT, 0, | |
7c297722 | 430 | NULL, NULL); |
3ca10067 | 431 | inotify_remove_watch_locked(ih, watch); |
2d9048e2 | 432 | mutex_unlock(&ih->mutex); |
6ee5a399 | 433 | put_inotify_watch(watch); |
0eeca283 | 434 | } |
d4f9af9d | 435 | mutex_unlock(&inode->inotify_mutex); |
0eeca283 RL |
436 | iput(inode); |
437 | ||
438 | spin_lock(&inode_lock); | |
439 | } | |
440 | } | |
441 | EXPORT_SYMBOL_GPL(inotify_unmount_inodes); | |
442 | ||
443 | /** | |
444 | * inotify_inode_is_dead - an inode has been deleted, cleanup any watches | |
445 | * @inode: inode that is about to be removed | |
446 | */ | |
447 | void inotify_inode_is_dead(struct inode *inode) | |
448 | { | |
449 | struct inotify_watch *watch, *next; | |
450 | ||
d4f9af9d | 451 | mutex_lock(&inode->inotify_mutex); |
0eeca283 | 452 | list_for_each_entry_safe(watch, next, &inode->inotify_watches, i_list) { |
2d9048e2 AG |
453 | struct inotify_handle *ih = watch->ih; |
454 | mutex_lock(&ih->mutex); | |
3ca10067 | 455 | inotify_remove_watch_locked(ih, watch); |
2d9048e2 | 456 | mutex_unlock(&ih->mutex); |
0eeca283 | 457 | } |
d4f9af9d | 458 | mutex_unlock(&inode->inotify_mutex); |
0eeca283 RL |
459 | } |
460 | EXPORT_SYMBOL_GPL(inotify_inode_is_dead); | |
461 | ||
2d9048e2 | 462 | /* Kernel Consumer API */ |
0eeca283 | 463 | |
2d9048e2 AG |
464 | /** |
465 | * inotify_init - allocate and initialize an inotify instance | |
466 | * @ops: caller's inotify operations | |
467 | */ | |
468 | struct inotify_handle *inotify_init(const struct inotify_operations *ops) | |
0eeca283 | 469 | { |
2d9048e2 | 470 | struct inotify_handle *ih; |
0eeca283 | 471 | |
2d9048e2 AG |
472 | ih = kmalloc(sizeof(struct inotify_handle), GFP_KERNEL); |
473 | if (unlikely(!ih)) | |
474 | return ERR_PTR(-ENOMEM); | |
0eeca283 | 475 | |
2d9048e2 AG |
476 | idr_init(&ih->idr); |
477 | INIT_LIST_HEAD(&ih->watches); | |
478 | mutex_init(&ih->mutex); | |
479 | ih->last_wd = 0; | |
480 | ih->in_ops = ops; | |
481 | atomic_set(&ih->count, 0); | |
482 | get_inotify_handle(ih); | |
0eeca283 | 483 | |
2d9048e2 | 484 | return ih; |
0eeca283 | 485 | } |
2d9048e2 | 486 | EXPORT_SYMBOL_GPL(inotify_init); |
0eeca283 | 487 | |
a9dc971d AG |
488 | /** |
489 | * inotify_init_watch - initialize an inotify watch | |
490 | * @watch: watch to initialize | |
491 | */ | |
492 | void inotify_init_watch(struct inotify_watch *watch) | |
493 | { | |
494 | INIT_LIST_HEAD(&watch->h_list); | |
495 | INIT_LIST_HEAD(&watch->i_list); | |
496 | atomic_set(&watch->count, 0); | |
497 | get_inotify_watch(watch); /* initial get */ | |
498 | } | |
499 | EXPORT_SYMBOL_GPL(inotify_init_watch); | |
500 | ||
8f7b0ba1 AV |
501 | /* |
502 | * Watch removals suck violently. To kick the watch out we need (in this | |
503 | * order) inode->inotify_mutex and ih->mutex. That's fine if we have | |
504 | * a hold on inode; however, for all other cases we need to make damn sure | |
505 | * we don't race with umount. We can *NOT* just grab a reference to a | |
506 | * watch - inotify_unmount_inodes() will happily sail past it and we'll end | |
507 | * with reference to inode potentially outliving its superblock. Ideally | |
508 | * we just want to grab an active reference to superblock if we can; that | |
509 | * will make sure we won't go into inotify_umount_inodes() until we are | |
510 | * done. Cleanup is just deactivate_super(). However, that leaves a messy | |
511 | * case - what if we *are* racing with umount() and active references to | |
512 | * superblock can't be acquired anymore? We can bump ->s_count, grab | |
1712ac8f AV |
513 | * ->s_umount, which will wait until the superblock is shut down and the |
514 | * watch in question is pining for fjords. | |
8f7b0ba1 AV |
515 | * |
516 | * And yes, this is far beyond mere "not very pretty"; so's the entire | |
517 | * concept of inotify to start with. | |
518 | */ | |
519 | ||
520 | /** | |
521 | * pin_to_kill - pin the watch down for removal | |
522 | * @ih: inotify handle | |
523 | * @watch: watch to kill | |
524 | * | |
525 | * Called with ih->mutex held, drops it. Possible return values: | |
526 | * 0 - nothing to do, it has died | |
527 | * 1 - remove it, drop the reference and deactivate_super() | |
8f7b0ba1 AV |
528 | */ |
529 | static int pin_to_kill(struct inotify_handle *ih, struct inotify_watch *watch) | |
530 | { | |
531 | struct super_block *sb = watch->inode->i_sb; | |
8f7b0ba1 | 532 | |
b20bd1a5 | 533 | if (atomic_inc_not_zero(&sb->s_active)) { |
8f7b0ba1 AV |
534 | get_inotify_watch(watch); |
535 | mutex_unlock(&ih->mutex); | |
536 | return 1; /* the best outcome */ | |
537 | } | |
b20bd1a5 | 538 | spin_lock(&sb_lock); |
8f7b0ba1 AV |
539 | sb->s_count++; |
540 | spin_unlock(&sb_lock); | |
541 | mutex_unlock(&ih->mutex); /* can't grab ->s_umount under it */ | |
542 | down_read(&sb->s_umount); | |
1712ac8f AV |
543 | /* fs is already shut down; the watch is dead */ |
544 | drop_super(sb); | |
545 | return 0; | |
8f7b0ba1 AV |
546 | } |
547 | ||
1712ac8f | 548 | static void unpin_and_kill(struct inotify_watch *watch) |
8f7b0ba1 AV |
549 | { |
550 | struct super_block *sb = watch->inode->i_sb; | |
551 | put_inotify_watch(watch); | |
1712ac8f | 552 | deactivate_super(sb); |
8f7b0ba1 AV |
553 | } |
554 | ||
2d9048e2 AG |
555 | /** |
556 | * inotify_destroy - clean up and destroy an inotify instance | |
557 | * @ih: inotify handle | |
558 | */ | |
559 | void inotify_destroy(struct inotify_handle *ih) | |
0eeca283 | 560 | { |
0eeca283 | 561 | /* |
2d9048e2 | 562 | * Destroy all of the watches for this handle. Unfortunately, not very |
0eeca283 RL |
563 | * pretty. We cannot do a simple iteration over the list, because we |
564 | * do not know the inode until we iterate to the watch. But we need to | |
2d9048e2 | 565 | * hold inode->inotify_mutex before ih->mutex. The following works. |
8f7b0ba1 AV |
566 | * |
567 | * AV: it had to become even uglier to start working ;-/ | |
0eeca283 RL |
568 | */ |
569 | while (1) { | |
570 | struct inotify_watch *watch; | |
571 | struct list_head *watches; | |
8f7b0ba1 | 572 | struct super_block *sb; |
0eeca283 RL |
573 | struct inode *inode; |
574 | ||
2d9048e2 AG |
575 | mutex_lock(&ih->mutex); |
576 | watches = &ih->watches; | |
0eeca283 | 577 | if (list_empty(watches)) { |
2d9048e2 | 578 | mutex_unlock(&ih->mutex); |
0eeca283 RL |
579 | break; |
580 | } | |
b5e61818 | 581 | watch = list_first_entry(watches, struct inotify_watch, h_list); |
8f7b0ba1 | 582 | sb = watch->inode->i_sb; |
1712ac8f | 583 | if (!pin_to_kill(ih, watch)) |
8f7b0ba1 | 584 | continue; |
0eeca283 RL |
585 | |
586 | inode = watch->inode; | |
d4f9af9d | 587 | mutex_lock(&inode->inotify_mutex); |
2d9048e2 | 588 | mutex_lock(&ih->mutex); |
66055a4e AG |
589 | |
590 | /* make sure we didn't race with another list removal */ | |
2d9048e2 AG |
591 | if (likely(idr_find(&ih->idr, watch->wd))) { |
592 | remove_watch_no_event(watch, ih); | |
593 | put_inotify_watch(watch); | |
594 | } | |
66055a4e | 595 | |
2d9048e2 | 596 | mutex_unlock(&ih->mutex); |
d4f9af9d | 597 | mutex_unlock(&inode->inotify_mutex); |
1712ac8f | 598 | unpin_and_kill(watch); |
0eeca283 RL |
599 | } |
600 | ||
2d9048e2 AG |
601 | /* free this handle: the put matching the get in inotify_init() */ |
602 | put_inotify_handle(ih); | |
0eeca283 | 603 | } |
2d9048e2 | 604 | EXPORT_SYMBOL_GPL(inotify_destroy); |
0eeca283 | 605 | |
a9dc971d AG |
606 | /** |
607 | * inotify_find_watch - find an existing watch for an (ih,inode) pair | |
608 | * @ih: inotify handle | |
609 | * @inode: inode to watch | |
610 | * @watchp: pointer to existing inotify_watch | |
611 | * | |
612 | * Caller must pin given inode (via nameidata). | |
613 | */ | |
614 | s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode, | |
615 | struct inotify_watch **watchp) | |
616 | { | |
617 | struct inotify_watch *old; | |
618 | int ret = -ENOENT; | |
619 | ||
620 | mutex_lock(&inode->inotify_mutex); | |
621 | mutex_lock(&ih->mutex); | |
622 | ||
623 | old = inode_find_handle(inode, ih); | |
624 | if (unlikely(old)) { | |
625 | get_inotify_watch(old); /* caller must put watch */ | |
626 | *watchp = old; | |
627 | ret = old->wd; | |
628 | } | |
629 | ||
630 | mutex_unlock(&ih->mutex); | |
631 | mutex_unlock(&inode->inotify_mutex); | |
632 | ||
633 | return ret; | |
634 | } | |
635 | EXPORT_SYMBOL_GPL(inotify_find_watch); | |
636 | ||
2d9048e2 AG |
637 | /** |
638 | * inotify_find_update_watch - find and update the mask of an existing watch | |
639 | * @ih: inotify handle | |
640 | * @inode: inode's watch to update | |
641 | * @mask: mask of events to watch | |
0eeca283 | 642 | * |
2d9048e2 | 643 | * Caller must pin given inode (via nameidata). |
0eeca283 | 644 | */ |
2d9048e2 AG |
645 | s32 inotify_find_update_watch(struct inotify_handle *ih, struct inode *inode, |
646 | u32 mask) | |
0eeca283 | 647 | { |
2d9048e2 AG |
648 | struct inotify_watch *old; |
649 | int mask_add = 0; | |
650 | int ret; | |
0eeca283 | 651 | |
2d9048e2 AG |
652 | if (mask & IN_MASK_ADD) |
653 | mask_add = 1; | |
654 | ||
655 | /* don't allow invalid bits: we don't want flags set */ | |
656 | mask &= IN_ALL_EVENTS | IN_ONESHOT; | |
657 | if (unlikely(!mask)) | |
0eeca283 | 658 | return -EINVAL; |
0eeca283 | 659 | |
d4f9af9d | 660 | mutex_lock(&inode->inotify_mutex); |
2d9048e2 | 661 | mutex_lock(&ih->mutex); |
0eeca283 | 662 | |
2d9048e2 AG |
663 | /* |
664 | * Handle the case of re-adding a watch on an (inode,ih) pair that we | |
665 | * are already watching. We just update the mask and return its wd. | |
666 | */ | |
667 | old = inode_find_handle(inode, ih); | |
668 | if (unlikely(!old)) { | |
669 | ret = -ENOENT; | |
670 | goto out; | |
0eeca283 RL |
671 | } |
672 | ||
2d9048e2 AG |
673 | if (mask_add) |
674 | old->mask |= mask; | |
675 | else | |
676 | old->mask = mask; | |
677 | ret = old->wd; | |
678 | out: | |
679 | mutex_unlock(&ih->mutex); | |
680 | mutex_unlock(&inode->inotify_mutex); | |
0eeca283 RL |
681 | return ret; |
682 | } | |
2d9048e2 | 683 | EXPORT_SYMBOL_GPL(inotify_find_update_watch); |
0eeca283 | 684 | |
2d9048e2 AG |
685 | /** |
686 | * inotify_add_watch - add a watch to an inotify instance | |
687 | * @ih: inotify handle | |
688 | * @watch: caller allocated watch structure | |
689 | * @inode: inode to watch | |
690 | * @mask: mask of events to watch | |
691 | * | |
692 | * Caller must pin given inode (via nameidata). | |
693 | * Caller must ensure it only calls inotify_add_watch() once per watch. | |
694 | * Calls inotify_handle_get_wd() so may sleep. | |
695 | */ | |
696 | s32 inotify_add_watch(struct inotify_handle *ih, struct inotify_watch *watch, | |
697 | struct inode *inode, u32 mask) | |
0eeca283 | 698 | { |
2d9048e2 | 699 | int ret = 0; |
d599e36a | 700 | int newly_watched; |
0eeca283 | 701 | |
2d9048e2 AG |
702 | /* don't allow invalid bits: we don't want flags set */ |
703 | mask &= IN_ALL_EVENTS | IN_ONESHOT; | |
704 | if (unlikely(!mask)) | |
705 | return -EINVAL; | |
706 | watch->mask = mask; | |
783bc29b | 707 | |
2d9048e2 AG |
708 | mutex_lock(&inode->inotify_mutex); |
709 | mutex_lock(&ih->mutex); | |
8140a500 | 710 | |
2d9048e2 AG |
711 | /* Initialize a new watch */ |
712 | ret = inotify_handle_get_wd(ih, watch); | |
b680716e | 713 | if (unlikely(ret)) |
2d9048e2 AG |
714 | goto out; |
715 | ret = watch->wd; | |
0eeca283 | 716 | |
2d9048e2 AG |
717 | /* save a reference to handle and bump the count to make it official */ |
718 | get_inotify_handle(ih); | |
719 | watch->ih = ih; | |
0eeca283 RL |
720 | |
721 | /* | |
2d9048e2 AG |
722 | * Save a reference to the inode and bump the ref count to make it |
723 | * official. We hold a reference to nameidata, which makes this safe. | |
0eeca283 | 724 | */ |
2d9048e2 | 725 | watch->inode = igrab(inode); |
0eeca283 | 726 | |
2d9048e2 | 727 | /* Add the watch to the handle's and the inode's list */ |
d599e36a | 728 | newly_watched = !inotify_inode_watched(inode); |
2d9048e2 | 729 | list_add(&watch->h_list, &ih->watches); |
0eeca283 | 730 | list_add(&watch->i_list, &inode->inotify_watches); |
d599e36a NP |
731 | /* |
732 | * Set child flags _after_ adding the watch, so there is no race | |
733 | * windows where newly instantiated children could miss their parent's | |
734 | * watched flag. | |
735 | */ | |
736 | if (newly_watched) | |
737 | set_dentry_child_flags(inode, 1); | |
738 | ||
0eeca283 | 739 | out: |
2d9048e2 | 740 | mutex_unlock(&ih->mutex); |
d4f9af9d | 741 | mutex_unlock(&inode->inotify_mutex); |
0eeca283 RL |
742 | return ret; |
743 | } | |
2d9048e2 | 744 | EXPORT_SYMBOL_GPL(inotify_add_watch); |
0eeca283 | 745 | |
b9efe8a2 AV |
746 | /** |
747 | * inotify_clone_watch - put the watch next to existing one | |
748 | * @old: already installed watch | |
749 | * @new: new watch | |
750 | * | |
751 | * Caller must hold the inotify_mutex of inode we are dealing with; | |
752 | * it is expected to remove the old watch before unlocking the inode. | |
753 | */ | |
754 | s32 inotify_clone_watch(struct inotify_watch *old, struct inotify_watch *new) | |
755 | { | |
756 | struct inotify_handle *ih = old->ih; | |
757 | int ret = 0; | |
758 | ||
759 | new->mask = old->mask; | |
760 | new->ih = ih; | |
761 | ||
762 | mutex_lock(&ih->mutex); | |
763 | ||
764 | /* Initialize a new watch */ | |
765 | ret = inotify_handle_get_wd(ih, new); | |
766 | if (unlikely(ret)) | |
767 | goto out; | |
768 | ret = new->wd; | |
769 | ||
770 | get_inotify_handle(ih); | |
771 | ||
772 | new->inode = igrab(old->inode); | |
773 | ||
774 | list_add(&new->h_list, &ih->watches); | |
775 | list_add(&new->i_list, &old->inode->inotify_watches); | |
776 | out: | |
777 | mutex_unlock(&ih->mutex); | |
778 | return ret; | |
779 | } | |
780 | ||
455434d4 AV |
781 | void inotify_evict_watch(struct inotify_watch *watch) |
782 | { | |
783 | get_inotify_watch(watch); | |
784 | mutex_lock(&watch->ih->mutex); | |
785 | inotify_remove_watch_locked(watch->ih, watch); | |
786 | mutex_unlock(&watch->ih->mutex); | |
787 | } | |
788 | ||
2d9048e2 AG |
789 | /** |
790 | * inotify_rm_wd - remove a watch from an inotify instance | |
791 | * @ih: inotify handle | |
792 | * @wd: watch descriptor to remove | |
793 | * | |
794 | * Can sleep. | |
795 | */ | |
796 | int inotify_rm_wd(struct inotify_handle *ih, u32 wd) | |
0eeca283 | 797 | { |
2d9048e2 | 798 | struct inotify_watch *watch; |
8f7b0ba1 | 799 | struct super_block *sb; |
2d9048e2 | 800 | struct inode *inode; |
783bc29b | 801 | |
2d9048e2 AG |
802 | mutex_lock(&ih->mutex); |
803 | watch = idr_find(&ih->idr, wd); | |
804 | if (unlikely(!watch)) { | |
805 | mutex_unlock(&ih->mutex); | |
806 | return -EINVAL; | |
783bc29b | 807 | } |
8f7b0ba1 | 808 | sb = watch->inode->i_sb; |
1712ac8f | 809 | if (!pin_to_kill(ih, watch)) |
8f7b0ba1 AV |
810 | return 0; |
811 | ||
2d9048e2 | 812 | inode = watch->inode; |
783bc29b | 813 | |
2d9048e2 AG |
814 | mutex_lock(&inode->inotify_mutex); |
815 | mutex_lock(&ih->mutex); | |
9a556e89 | 816 | |
2d9048e2 AG |
817 | /* make sure that we did not race */ |
818 | if (likely(idr_find(&ih->idr, wd) == watch)) | |
3ca10067 | 819 | inotify_remove_watch_locked(ih, watch); |
0eeca283 | 820 | |
2d9048e2 AG |
821 | mutex_unlock(&ih->mutex); |
822 | mutex_unlock(&inode->inotify_mutex); | |
1712ac8f | 823 | unpin_and_kill(watch); |
0eeca283 | 824 | |
2d9048e2 AG |
825 | return 0; |
826 | } | |
827 | EXPORT_SYMBOL_GPL(inotify_rm_wd); | |
0eeca283 | 828 | |
a9dc971d AG |
829 | /** |
830 | * inotify_rm_watch - remove a watch from an inotify instance | |
831 | * @ih: inotify handle | |
832 | * @watch: watch to remove | |
833 | * | |
834 | * Can sleep. | |
835 | */ | |
836 | int inotify_rm_watch(struct inotify_handle *ih, | |
837 | struct inotify_watch *watch) | |
838 | { | |
839 | return inotify_rm_wd(ih, watch->wd); | |
840 | } | |
841 | EXPORT_SYMBOL_GPL(inotify_rm_watch); | |
842 | ||
0eeca283 | 843 | /* |
2d9048e2 | 844 | * inotify_setup - core initialization function |
0eeca283 | 845 | */ |
b680716e | 846 | static int __init inotify_setup(void) |
0eeca283 | 847 | { |
90586523 EP |
848 | BUILD_BUG_ON(IN_ACCESS != FS_ACCESS); |
849 | BUILD_BUG_ON(IN_MODIFY != FS_MODIFY); | |
850 | BUILD_BUG_ON(IN_ATTRIB != FS_ATTRIB); | |
851 | BUILD_BUG_ON(IN_CLOSE_WRITE != FS_CLOSE_WRITE); | |
852 | BUILD_BUG_ON(IN_CLOSE_NOWRITE != FS_CLOSE_NOWRITE); | |
853 | BUILD_BUG_ON(IN_OPEN != FS_OPEN); | |
854 | BUILD_BUG_ON(IN_MOVED_FROM != FS_MOVED_FROM); | |
855 | BUILD_BUG_ON(IN_MOVED_TO != FS_MOVED_TO); | |
856 | BUILD_BUG_ON(IN_CREATE != FS_CREATE); | |
857 | BUILD_BUG_ON(IN_DELETE != FS_DELETE); | |
858 | BUILD_BUG_ON(IN_DELETE_SELF != FS_DELETE_SELF); | |
859 | BUILD_BUG_ON(IN_MOVE_SELF != FS_MOVE_SELF); | |
860 | BUILD_BUG_ON(IN_Q_OVERFLOW != FS_Q_OVERFLOW); | |
861 | ||
862 | BUILD_BUG_ON(IN_UNMOUNT != FS_UNMOUNT); | |
863 | BUILD_BUG_ON(IN_ISDIR != FS_IN_ISDIR); | |
864 | BUILD_BUG_ON(IN_IGNORED != FS_IN_IGNORED); | |
865 | BUILD_BUG_ON(IN_ONESHOT != FS_IN_ONESHOT); | |
866 | ||
0eeca283 RL |
867 | atomic_set(&inotify_cookie, 0); |
868 | ||
0eeca283 RL |
869 | return 0; |
870 | } | |
871 | ||
b680716e | 872 | module_init(inotify_setup); |