]>
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 NP |
379 | /* |
380 | * We cannot __iget() an inode in state I_CLEAR, I_FREEING, | |
381 | * I_WILL_FREE, or I_NEW which is fine because by that point | |
382 | * the inode cannot have any associated watches. | |
383 | */ | |
384 | if (inode->i_state & (I_CLEAR|I_FREEING|I_WILL_FREE|I_NEW)) | |
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) && | |
406 | !(next_i->i_state & (I_CLEAR | I_FREEING | | |
407 | I_WILL_FREE))) { | |
408 | __iget(next_i); | |
409 | need_iput = next_i; | |
410 | } | |
411 | ||
412 | /* | |
413 | * We can safely drop inode_lock here because we hold | |
414 | * references on both inode and next_i. Also no new inodes | |
415 | * will be added since the umount has begun. Finally, | |
f24075bd | 416 | * iprune_mutex keeps shrink_icache_memory() away. |
0eeca283 RL |
417 | */ |
418 | spin_unlock(&inode_lock); | |
419 | ||
420 | if (need_iput_tmp) | |
421 | iput(need_iput_tmp); | |
422 | ||
423 | /* for each watch, send IN_UNMOUNT and then remove it */ | |
d4f9af9d | 424 | mutex_lock(&inode->inotify_mutex); |
0eeca283 RL |
425 | watches = &inode->inotify_watches; |
426 | list_for_each_entry_safe(watch, next_w, watches, i_list) { | |
2d9048e2 | 427 | struct inotify_handle *ih= watch->ih; |
6ee5a399 | 428 | get_inotify_watch(watch); |
2d9048e2 AG |
429 | mutex_lock(&ih->mutex); |
430 | ih->in_ops->handle_event(watch, watch->wd, IN_UNMOUNT, 0, | |
7c297722 | 431 | NULL, NULL); |
3ca10067 | 432 | inotify_remove_watch_locked(ih, watch); |
2d9048e2 | 433 | mutex_unlock(&ih->mutex); |
6ee5a399 | 434 | put_inotify_watch(watch); |
0eeca283 | 435 | } |
d4f9af9d | 436 | mutex_unlock(&inode->inotify_mutex); |
0eeca283 RL |
437 | iput(inode); |
438 | ||
439 | spin_lock(&inode_lock); | |
440 | } | |
441 | } | |
442 | EXPORT_SYMBOL_GPL(inotify_unmount_inodes); | |
443 | ||
444 | /** | |
445 | * inotify_inode_is_dead - an inode has been deleted, cleanup any watches | |
446 | * @inode: inode that is about to be removed | |
447 | */ | |
448 | void inotify_inode_is_dead(struct inode *inode) | |
449 | { | |
450 | struct inotify_watch *watch, *next; | |
451 | ||
d4f9af9d | 452 | mutex_lock(&inode->inotify_mutex); |
0eeca283 | 453 | list_for_each_entry_safe(watch, next, &inode->inotify_watches, i_list) { |
2d9048e2 AG |
454 | struct inotify_handle *ih = watch->ih; |
455 | mutex_lock(&ih->mutex); | |
3ca10067 | 456 | inotify_remove_watch_locked(ih, watch); |
2d9048e2 | 457 | mutex_unlock(&ih->mutex); |
0eeca283 | 458 | } |
d4f9af9d | 459 | mutex_unlock(&inode->inotify_mutex); |
0eeca283 RL |
460 | } |
461 | EXPORT_SYMBOL_GPL(inotify_inode_is_dead); | |
462 | ||
2d9048e2 | 463 | /* Kernel Consumer API */ |
0eeca283 | 464 | |
2d9048e2 AG |
465 | /** |
466 | * inotify_init - allocate and initialize an inotify instance | |
467 | * @ops: caller's inotify operations | |
468 | */ | |
469 | struct inotify_handle *inotify_init(const struct inotify_operations *ops) | |
0eeca283 | 470 | { |
2d9048e2 | 471 | struct inotify_handle *ih; |
0eeca283 | 472 | |
2d9048e2 AG |
473 | ih = kmalloc(sizeof(struct inotify_handle), GFP_KERNEL); |
474 | if (unlikely(!ih)) | |
475 | return ERR_PTR(-ENOMEM); | |
0eeca283 | 476 | |
2d9048e2 AG |
477 | idr_init(&ih->idr); |
478 | INIT_LIST_HEAD(&ih->watches); | |
479 | mutex_init(&ih->mutex); | |
480 | ih->last_wd = 0; | |
481 | ih->in_ops = ops; | |
482 | atomic_set(&ih->count, 0); | |
483 | get_inotify_handle(ih); | |
0eeca283 | 484 | |
2d9048e2 | 485 | return ih; |
0eeca283 | 486 | } |
2d9048e2 | 487 | EXPORT_SYMBOL_GPL(inotify_init); |
0eeca283 | 488 | |
a9dc971d AG |
489 | /** |
490 | * inotify_init_watch - initialize an inotify watch | |
491 | * @watch: watch to initialize | |
492 | */ | |
493 | void inotify_init_watch(struct inotify_watch *watch) | |
494 | { | |
495 | INIT_LIST_HEAD(&watch->h_list); | |
496 | INIT_LIST_HEAD(&watch->i_list); | |
497 | atomic_set(&watch->count, 0); | |
498 | get_inotify_watch(watch); /* initial get */ | |
499 | } | |
500 | EXPORT_SYMBOL_GPL(inotify_init_watch); | |
501 | ||
8f7b0ba1 AV |
502 | /* |
503 | * Watch removals suck violently. To kick the watch out we need (in this | |
504 | * order) inode->inotify_mutex and ih->mutex. That's fine if we have | |
505 | * a hold on inode; however, for all other cases we need to make damn sure | |
506 | * we don't race with umount. We can *NOT* just grab a reference to a | |
507 | * watch - inotify_unmount_inodes() will happily sail past it and we'll end | |
508 | * with reference to inode potentially outliving its superblock. Ideally | |
509 | * we just want to grab an active reference to superblock if we can; that | |
510 | * will make sure we won't go into inotify_umount_inodes() until we are | |
511 | * done. Cleanup is just deactivate_super(). However, that leaves a messy | |
512 | * case - what if we *are* racing with umount() and active references to | |
513 | * superblock can't be acquired anymore? We can bump ->s_count, grab | |
1712ac8f AV |
514 | * ->s_umount, which will wait until the superblock is shut down and the |
515 | * watch in question is pining for fjords. | |
8f7b0ba1 AV |
516 | * |
517 | * And yes, this is far beyond mere "not very pretty"; so's the entire | |
518 | * concept of inotify to start with. | |
519 | */ | |
520 | ||
521 | /** | |
522 | * pin_to_kill - pin the watch down for removal | |
523 | * @ih: inotify handle | |
524 | * @watch: watch to kill | |
525 | * | |
526 | * Called with ih->mutex held, drops it. Possible return values: | |
527 | * 0 - nothing to do, it has died | |
528 | * 1 - remove it, drop the reference and deactivate_super() | |
8f7b0ba1 AV |
529 | */ |
530 | static int pin_to_kill(struct inotify_handle *ih, struct inotify_watch *watch) | |
531 | { | |
532 | struct super_block *sb = watch->inode->i_sb; | |
8f7b0ba1 | 533 | |
b20bd1a5 | 534 | if (atomic_inc_not_zero(&sb->s_active)) { |
8f7b0ba1 AV |
535 | get_inotify_watch(watch); |
536 | mutex_unlock(&ih->mutex); | |
537 | return 1; /* the best outcome */ | |
538 | } | |
b20bd1a5 | 539 | spin_lock(&sb_lock); |
8f7b0ba1 AV |
540 | sb->s_count++; |
541 | spin_unlock(&sb_lock); | |
542 | mutex_unlock(&ih->mutex); /* can't grab ->s_umount under it */ | |
543 | down_read(&sb->s_umount); | |
1712ac8f AV |
544 | /* fs is already shut down; the watch is dead */ |
545 | drop_super(sb); | |
546 | return 0; | |
8f7b0ba1 AV |
547 | } |
548 | ||
1712ac8f | 549 | static void unpin_and_kill(struct inotify_watch *watch) |
8f7b0ba1 AV |
550 | { |
551 | struct super_block *sb = watch->inode->i_sb; | |
552 | put_inotify_watch(watch); | |
1712ac8f | 553 | deactivate_super(sb); |
8f7b0ba1 AV |
554 | } |
555 | ||
2d9048e2 AG |
556 | /** |
557 | * inotify_destroy - clean up and destroy an inotify instance | |
558 | * @ih: inotify handle | |
559 | */ | |
560 | void inotify_destroy(struct inotify_handle *ih) | |
0eeca283 | 561 | { |
0eeca283 | 562 | /* |
2d9048e2 | 563 | * Destroy all of the watches for this handle. Unfortunately, not very |
0eeca283 RL |
564 | * pretty. We cannot do a simple iteration over the list, because we |
565 | * do not know the inode until we iterate to the watch. But we need to | |
2d9048e2 | 566 | * hold inode->inotify_mutex before ih->mutex. The following works. |
8f7b0ba1 AV |
567 | * |
568 | * AV: it had to become even uglier to start working ;-/ | |
0eeca283 RL |
569 | */ |
570 | while (1) { | |
571 | struct inotify_watch *watch; | |
572 | struct list_head *watches; | |
8f7b0ba1 | 573 | struct super_block *sb; |
0eeca283 RL |
574 | struct inode *inode; |
575 | ||
2d9048e2 AG |
576 | mutex_lock(&ih->mutex); |
577 | watches = &ih->watches; | |
0eeca283 | 578 | if (list_empty(watches)) { |
2d9048e2 | 579 | mutex_unlock(&ih->mutex); |
0eeca283 RL |
580 | break; |
581 | } | |
b5e61818 | 582 | watch = list_first_entry(watches, struct inotify_watch, h_list); |
8f7b0ba1 | 583 | sb = watch->inode->i_sb; |
1712ac8f | 584 | if (!pin_to_kill(ih, watch)) |
8f7b0ba1 | 585 | continue; |
0eeca283 RL |
586 | |
587 | inode = watch->inode; | |
d4f9af9d | 588 | mutex_lock(&inode->inotify_mutex); |
2d9048e2 | 589 | mutex_lock(&ih->mutex); |
66055a4e AG |
590 | |
591 | /* make sure we didn't race with another list removal */ | |
2d9048e2 AG |
592 | if (likely(idr_find(&ih->idr, watch->wd))) { |
593 | remove_watch_no_event(watch, ih); | |
594 | put_inotify_watch(watch); | |
595 | } | |
66055a4e | 596 | |
2d9048e2 | 597 | mutex_unlock(&ih->mutex); |
d4f9af9d | 598 | mutex_unlock(&inode->inotify_mutex); |
1712ac8f | 599 | unpin_and_kill(watch); |
0eeca283 RL |
600 | } |
601 | ||
2d9048e2 AG |
602 | /* free this handle: the put matching the get in inotify_init() */ |
603 | put_inotify_handle(ih); | |
0eeca283 | 604 | } |
2d9048e2 | 605 | EXPORT_SYMBOL_GPL(inotify_destroy); |
0eeca283 | 606 | |
a9dc971d AG |
607 | /** |
608 | * inotify_find_watch - find an existing watch for an (ih,inode) pair | |
609 | * @ih: inotify handle | |
610 | * @inode: inode to watch | |
611 | * @watchp: pointer to existing inotify_watch | |
612 | * | |
613 | * Caller must pin given inode (via nameidata). | |
614 | */ | |
615 | s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode, | |
616 | struct inotify_watch **watchp) | |
617 | { | |
618 | struct inotify_watch *old; | |
619 | int ret = -ENOENT; | |
620 | ||
621 | mutex_lock(&inode->inotify_mutex); | |
622 | mutex_lock(&ih->mutex); | |
623 | ||
624 | old = inode_find_handle(inode, ih); | |
625 | if (unlikely(old)) { | |
626 | get_inotify_watch(old); /* caller must put watch */ | |
627 | *watchp = old; | |
628 | ret = old->wd; | |
629 | } | |
630 | ||
631 | mutex_unlock(&ih->mutex); | |
632 | mutex_unlock(&inode->inotify_mutex); | |
633 | ||
634 | return ret; | |
635 | } | |
636 | EXPORT_SYMBOL_GPL(inotify_find_watch); | |
637 | ||
2d9048e2 AG |
638 | /** |
639 | * inotify_find_update_watch - find and update the mask of an existing watch | |
640 | * @ih: inotify handle | |
641 | * @inode: inode's watch to update | |
642 | * @mask: mask of events to watch | |
0eeca283 | 643 | * |
2d9048e2 | 644 | * Caller must pin given inode (via nameidata). |
0eeca283 | 645 | */ |
2d9048e2 AG |
646 | s32 inotify_find_update_watch(struct inotify_handle *ih, struct inode *inode, |
647 | u32 mask) | |
0eeca283 | 648 | { |
2d9048e2 AG |
649 | struct inotify_watch *old; |
650 | int mask_add = 0; | |
651 | int ret; | |
0eeca283 | 652 | |
2d9048e2 AG |
653 | if (mask & IN_MASK_ADD) |
654 | mask_add = 1; | |
655 | ||
656 | /* don't allow invalid bits: we don't want flags set */ | |
657 | mask &= IN_ALL_EVENTS | IN_ONESHOT; | |
658 | if (unlikely(!mask)) | |
0eeca283 | 659 | return -EINVAL; |
0eeca283 | 660 | |
d4f9af9d | 661 | mutex_lock(&inode->inotify_mutex); |
2d9048e2 | 662 | mutex_lock(&ih->mutex); |
0eeca283 | 663 | |
2d9048e2 AG |
664 | /* |
665 | * Handle the case of re-adding a watch on an (inode,ih) pair that we | |
666 | * are already watching. We just update the mask and return its wd. | |
667 | */ | |
668 | old = inode_find_handle(inode, ih); | |
669 | if (unlikely(!old)) { | |
670 | ret = -ENOENT; | |
671 | goto out; | |
0eeca283 RL |
672 | } |
673 | ||
2d9048e2 AG |
674 | if (mask_add) |
675 | old->mask |= mask; | |
676 | else | |
677 | old->mask = mask; | |
678 | ret = old->wd; | |
679 | out: | |
680 | mutex_unlock(&ih->mutex); | |
681 | mutex_unlock(&inode->inotify_mutex); | |
0eeca283 RL |
682 | return ret; |
683 | } | |
2d9048e2 | 684 | EXPORT_SYMBOL_GPL(inotify_find_update_watch); |
0eeca283 | 685 | |
2d9048e2 AG |
686 | /** |
687 | * inotify_add_watch - add a watch to an inotify instance | |
688 | * @ih: inotify handle | |
689 | * @watch: caller allocated watch structure | |
690 | * @inode: inode to watch | |
691 | * @mask: mask of events to watch | |
692 | * | |
693 | * Caller must pin given inode (via nameidata). | |
694 | * Caller must ensure it only calls inotify_add_watch() once per watch. | |
695 | * Calls inotify_handle_get_wd() so may sleep. | |
696 | */ | |
697 | s32 inotify_add_watch(struct inotify_handle *ih, struct inotify_watch *watch, | |
698 | struct inode *inode, u32 mask) | |
0eeca283 | 699 | { |
2d9048e2 | 700 | int ret = 0; |
d599e36a | 701 | int newly_watched; |
0eeca283 | 702 | |
2d9048e2 AG |
703 | /* don't allow invalid bits: we don't want flags set */ |
704 | mask &= IN_ALL_EVENTS | IN_ONESHOT; | |
705 | if (unlikely(!mask)) | |
706 | return -EINVAL; | |
707 | watch->mask = mask; | |
783bc29b | 708 | |
2d9048e2 AG |
709 | mutex_lock(&inode->inotify_mutex); |
710 | mutex_lock(&ih->mutex); | |
8140a500 | 711 | |
2d9048e2 AG |
712 | /* Initialize a new watch */ |
713 | ret = inotify_handle_get_wd(ih, watch); | |
b680716e | 714 | if (unlikely(ret)) |
2d9048e2 AG |
715 | goto out; |
716 | ret = watch->wd; | |
0eeca283 | 717 | |
2d9048e2 AG |
718 | /* save a reference to handle and bump the count to make it official */ |
719 | get_inotify_handle(ih); | |
720 | watch->ih = ih; | |
0eeca283 RL |
721 | |
722 | /* | |
2d9048e2 AG |
723 | * Save a reference to the inode and bump the ref count to make it |
724 | * official. We hold a reference to nameidata, which makes this safe. | |
0eeca283 | 725 | */ |
2d9048e2 | 726 | watch->inode = igrab(inode); |
0eeca283 | 727 | |
2d9048e2 | 728 | /* Add the watch to the handle's and the inode's list */ |
d599e36a | 729 | newly_watched = !inotify_inode_watched(inode); |
2d9048e2 | 730 | list_add(&watch->h_list, &ih->watches); |
0eeca283 | 731 | list_add(&watch->i_list, &inode->inotify_watches); |
d599e36a NP |
732 | /* |
733 | * Set child flags _after_ adding the watch, so there is no race | |
734 | * windows where newly instantiated children could miss their parent's | |
735 | * watched flag. | |
736 | */ | |
737 | if (newly_watched) | |
738 | set_dentry_child_flags(inode, 1); | |
739 | ||
0eeca283 | 740 | out: |
2d9048e2 | 741 | mutex_unlock(&ih->mutex); |
d4f9af9d | 742 | mutex_unlock(&inode->inotify_mutex); |
0eeca283 RL |
743 | return ret; |
744 | } | |
2d9048e2 | 745 | EXPORT_SYMBOL_GPL(inotify_add_watch); |
0eeca283 | 746 | |
b9efe8a2 AV |
747 | /** |
748 | * inotify_clone_watch - put the watch next to existing one | |
749 | * @old: already installed watch | |
750 | * @new: new watch | |
751 | * | |
752 | * Caller must hold the inotify_mutex of inode we are dealing with; | |
753 | * it is expected to remove the old watch before unlocking the inode. | |
754 | */ | |
755 | s32 inotify_clone_watch(struct inotify_watch *old, struct inotify_watch *new) | |
756 | { | |
757 | struct inotify_handle *ih = old->ih; | |
758 | int ret = 0; | |
759 | ||
760 | new->mask = old->mask; | |
761 | new->ih = ih; | |
762 | ||
763 | mutex_lock(&ih->mutex); | |
764 | ||
765 | /* Initialize a new watch */ | |
766 | ret = inotify_handle_get_wd(ih, new); | |
767 | if (unlikely(ret)) | |
768 | goto out; | |
769 | ret = new->wd; | |
770 | ||
771 | get_inotify_handle(ih); | |
772 | ||
773 | new->inode = igrab(old->inode); | |
774 | ||
775 | list_add(&new->h_list, &ih->watches); | |
776 | list_add(&new->i_list, &old->inode->inotify_watches); | |
777 | out: | |
778 | mutex_unlock(&ih->mutex); | |
779 | return ret; | |
780 | } | |
781 | ||
455434d4 AV |
782 | void inotify_evict_watch(struct inotify_watch *watch) |
783 | { | |
784 | get_inotify_watch(watch); | |
785 | mutex_lock(&watch->ih->mutex); | |
786 | inotify_remove_watch_locked(watch->ih, watch); | |
787 | mutex_unlock(&watch->ih->mutex); | |
788 | } | |
789 | ||
2d9048e2 AG |
790 | /** |
791 | * inotify_rm_wd - remove a watch from an inotify instance | |
792 | * @ih: inotify handle | |
793 | * @wd: watch descriptor to remove | |
794 | * | |
795 | * Can sleep. | |
796 | */ | |
797 | int inotify_rm_wd(struct inotify_handle *ih, u32 wd) | |
0eeca283 | 798 | { |
2d9048e2 | 799 | struct inotify_watch *watch; |
8f7b0ba1 | 800 | struct super_block *sb; |
2d9048e2 | 801 | struct inode *inode; |
783bc29b | 802 | |
2d9048e2 AG |
803 | mutex_lock(&ih->mutex); |
804 | watch = idr_find(&ih->idr, wd); | |
805 | if (unlikely(!watch)) { | |
806 | mutex_unlock(&ih->mutex); | |
807 | return -EINVAL; | |
783bc29b | 808 | } |
8f7b0ba1 | 809 | sb = watch->inode->i_sb; |
1712ac8f | 810 | if (!pin_to_kill(ih, watch)) |
8f7b0ba1 AV |
811 | return 0; |
812 | ||
2d9048e2 | 813 | inode = watch->inode; |
783bc29b | 814 | |
2d9048e2 AG |
815 | mutex_lock(&inode->inotify_mutex); |
816 | mutex_lock(&ih->mutex); | |
9a556e89 | 817 | |
2d9048e2 AG |
818 | /* make sure that we did not race */ |
819 | if (likely(idr_find(&ih->idr, wd) == watch)) | |
3ca10067 | 820 | inotify_remove_watch_locked(ih, watch); |
0eeca283 | 821 | |
2d9048e2 AG |
822 | mutex_unlock(&ih->mutex); |
823 | mutex_unlock(&inode->inotify_mutex); | |
1712ac8f | 824 | unpin_and_kill(watch); |
0eeca283 | 825 | |
2d9048e2 AG |
826 | return 0; |
827 | } | |
828 | EXPORT_SYMBOL_GPL(inotify_rm_wd); | |
0eeca283 | 829 | |
a9dc971d AG |
830 | /** |
831 | * inotify_rm_watch - remove a watch from an inotify instance | |
832 | * @ih: inotify handle | |
833 | * @watch: watch to remove | |
834 | * | |
835 | * Can sleep. | |
836 | */ | |
837 | int inotify_rm_watch(struct inotify_handle *ih, | |
838 | struct inotify_watch *watch) | |
839 | { | |
840 | return inotify_rm_wd(ih, watch->wd); | |
841 | } | |
842 | EXPORT_SYMBOL_GPL(inotify_rm_watch); | |
843 | ||
0eeca283 | 844 | /* |
2d9048e2 | 845 | * inotify_setup - core initialization function |
0eeca283 | 846 | */ |
b680716e | 847 | static int __init inotify_setup(void) |
0eeca283 | 848 | { |
90586523 EP |
849 | BUILD_BUG_ON(IN_ACCESS != FS_ACCESS); |
850 | BUILD_BUG_ON(IN_MODIFY != FS_MODIFY); | |
851 | BUILD_BUG_ON(IN_ATTRIB != FS_ATTRIB); | |
852 | BUILD_BUG_ON(IN_CLOSE_WRITE != FS_CLOSE_WRITE); | |
853 | BUILD_BUG_ON(IN_CLOSE_NOWRITE != FS_CLOSE_NOWRITE); | |
854 | BUILD_BUG_ON(IN_OPEN != FS_OPEN); | |
855 | BUILD_BUG_ON(IN_MOVED_FROM != FS_MOVED_FROM); | |
856 | BUILD_BUG_ON(IN_MOVED_TO != FS_MOVED_TO); | |
857 | BUILD_BUG_ON(IN_CREATE != FS_CREATE); | |
858 | BUILD_BUG_ON(IN_DELETE != FS_DELETE); | |
859 | BUILD_BUG_ON(IN_DELETE_SELF != FS_DELETE_SELF); | |
860 | BUILD_BUG_ON(IN_MOVE_SELF != FS_MOVE_SELF); | |
861 | BUILD_BUG_ON(IN_Q_OVERFLOW != FS_Q_OVERFLOW); | |
862 | ||
863 | BUILD_BUG_ON(IN_UNMOUNT != FS_UNMOUNT); | |
864 | BUILD_BUG_ON(IN_ISDIR != FS_IN_ISDIR); | |
865 | BUILD_BUG_ON(IN_IGNORED != FS_IN_IGNORED); | |
866 | BUILD_BUG_ON(IN_ONESHOT != FS_IN_ONESHOT); | |
867 | ||
0eeca283 RL |
868 | atomic_set(&inotify_cookie, 0); |
869 | ||
0eeca283 RL |
870 | return 0; |
871 | } | |
872 | ||
b680716e | 873 | module_init(inotify_setup); |