2 * fs/inotify.c - inode-based file event notifications
5 * John McCutchan <ttb@tentacle.dhs.org>
6 * Robert Love <rml@novell.com>
8 * Kernel API added by: Amy Griffis <amy.griffis@hp.com>
10 * Copyright (C) 2005 John McCutchan
11 * Copyright 2006 Hewlett-Packard Development Company, L.P.
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
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.
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/spinlock.h>
27 #include <linux/idr.h>
28 #include <linux/slab.h>
30 #include <linux/sched.h>
31 #include <linux/init.h>
32 #include <linux/list.h>
33 #include <linux/writeback.h>
34 #include <linux/inotify.h>
35 #include <linux/fsnotify_backend.h>
37 static atomic_t inotify_cookie;
42 * dentry->d_lock (used to keep d_move() away from dentry->d_parent)
43 * iprune_mutex (synchronize shrink_icache_memory())
44 * inode_lock (protects the super_block->s_inodes list)
45 * inode->inotify_mutex (protects inode->inotify_watches and watches->i_list)
46 * inotify_handle->mutex (protects inotify_handle and watches->h_list)
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
55 * Lifetimes of the three main data structures--inotify_handle, inode, and
56 * inotify_watch--are managed by reference count.
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().
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.
69 * inode: Pinned so long as the inode is associated with a watch, from
70 * inotify_add_watch() to the final put_inotify_watch().
74 * struct inotify_handle - represents an inotify instance
76 * This structure is protected by the mutex 'mutex'.
78 struct inotify_handle {
79 struct idr idr; /* idr mapping wd -> watch */
80 struct mutex mutex; /* protects this bad boy */
81 struct list_head watches; /* list of watches */
82 atomic_t count; /* reference count */
83 u32 last_wd; /* the last wd allocated */
84 const struct inotify_operations *in_ops; /* inotify caller operations */
87 static inline void get_inotify_handle(struct inotify_handle *ih)
89 atomic_inc(&ih->count);
92 static inline void put_inotify_handle(struct inotify_handle *ih)
94 if (atomic_dec_and_test(&ih->count)) {
95 idr_destroy(&ih->idr);
101 * get_inotify_watch - grab a reference to an inotify_watch
102 * @watch: watch to grab
104 void get_inotify_watch(struct inotify_watch *watch)
106 atomic_inc(&watch->count);
108 EXPORT_SYMBOL_GPL(get_inotify_watch);
110 int pin_inotify_watch(struct inotify_watch *watch)
112 struct super_block *sb = watch->inode->i_sb;
113 if (atomic_inc_not_zero(&sb->s_active)) {
114 atomic_inc(&watch->count);
121 * put_inotify_watch - decrements the ref count on a given watch. cleans up
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
126 void put_inotify_watch(struct inotify_watch *watch)
128 if (atomic_dec_and_test(&watch->count)) {
129 struct inotify_handle *ih = watch->ih;
132 ih->in_ops->destroy_watch(watch);
133 put_inotify_handle(ih);
136 EXPORT_SYMBOL_GPL(put_inotify_watch);
138 void unpin_inotify_watch(struct inotify_watch *watch)
140 struct super_block *sb = watch->inode->i_sb;
141 put_inotify_watch(watch);
142 deactivate_super(sb);
146 * inotify_handle_get_wd - returns the next WD for use by the given handle
148 * Callers must hold ih->mutex. This function can sleep.
150 static int inotify_handle_get_wd(struct inotify_handle *ih,
151 struct inotify_watch *watch)
156 if (unlikely(!idr_pre_get(&ih->idr, GFP_NOFS)))
158 ret = idr_get_new_above(&ih->idr, watch, ih->last_wd+1, &watch->wd);
159 } while (ret == -EAGAIN);
162 ih->last_wd = watch->wd;
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.
171 static inline int inotify_inode_watched(struct inode *inode)
173 return !list_empty(&inode->inotify_watches);
177 * Get child dentry flag into synch with parent inode.
178 * Flag should always be clear for negative dentrys.
180 static void set_dentry_child_flags(struct inode *inode, int watched)
182 struct dentry *alias;
184 spin_lock(&dcache_lock);
185 list_for_each_entry(alias, &inode->i_dentry, d_alias) {
186 struct dentry *child;
188 list_for_each_entry(child, &alias->d_subdirs, d_u.d_child) {
192 spin_lock(&child->d_lock);
194 child->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED;
196 child->d_flags &=~DCACHE_INOTIFY_PARENT_WATCHED;
197 spin_unlock(&child->d_lock);
200 spin_unlock(&dcache_lock);
204 * inotify_find_handle - find the watch associated with the given inode and
207 * Callers must hold inode->inotify_mutex.
209 static struct inotify_watch *inode_find_handle(struct inode *inode,
210 struct inotify_handle *ih)
212 struct inotify_watch *watch;
214 list_for_each_entry(watch, &inode->inotify_watches, i_list) {
223 * remove_watch_no_event - remove watch without the IN_IGNORED event.
225 * Callers must hold both inode->inotify_mutex and ih->mutex.
227 static void remove_watch_no_event(struct inotify_watch *watch,
228 struct inotify_handle *ih)
230 list_del(&watch->i_list);
231 list_del(&watch->h_list);
233 if (!inotify_inode_watched(watch->inode))
234 set_dentry_child_flags(watch->inode, 0);
236 idr_remove(&ih->idr, watch->wd);
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
246 * Callers must hold both inode->inotify_mutex and ih->mutex.
248 void inotify_remove_watch_locked(struct inotify_handle *ih,
249 struct inotify_watch *watch)
251 remove_watch_no_event(watch, ih);
252 ih->in_ops->handle_event(watch, watch->wd, IN_IGNORED, 0, NULL, NULL);
254 EXPORT_SYMBOL_GPL(inotify_remove_watch_locked);
256 /* Kernel API for producing events */
259 * inotify_d_instantiate - instantiate dcache entry for inode
261 void inotify_d_instantiate(struct dentry *entry, struct inode *inode)
263 struct dentry *parent;
268 spin_lock(&entry->d_lock);
269 parent = entry->d_parent;
270 if (parent->d_inode && inotify_inode_watched(parent->d_inode))
271 entry->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED;
272 spin_unlock(&entry->d_lock);
276 * inotify_d_move - dcache entry has been moved
278 void inotify_d_move(struct dentry *entry)
280 struct dentry *parent;
282 parent = entry->d_parent;
283 if (inotify_inode_watched(parent->d_inode))
284 entry->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED;
286 entry->d_flags &= ~DCACHE_INOTIFY_PARENT_WATCHED;
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
295 * @n_inode: inode associated with name
297 void inotify_inode_queue_event(struct inode *inode, u32 mask, u32 cookie,
298 const char *name, struct inode *n_inode)
300 struct inotify_watch *watch, *next;
302 if (!inotify_inode_watched(inode))
305 mutex_lock(&inode->inotify_mutex);
306 list_for_each_entry_safe(watch, next, &inode->inotify_watches, i_list) {
307 u32 watch_mask = watch->mask;
308 if (watch_mask & mask) {
309 struct inotify_handle *ih= watch->ih;
310 mutex_lock(&ih->mutex);
311 if (watch_mask & IN_ONESHOT)
312 remove_watch_no_event(watch, ih);
313 ih->in_ops->handle_event(watch, watch->wd, mask, cookie,
315 mutex_unlock(&ih->mutex);
318 mutex_unlock(&inode->inotify_mutex);
320 EXPORT_SYMBOL_GPL(inotify_inode_queue_event);
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
329 void inotify_dentry_parent_queue_event(struct dentry *dentry, u32 mask,
330 u32 cookie, const char *name)
332 struct dentry *parent;
335 if (!(dentry->d_flags & DCACHE_INOTIFY_PARENT_WATCHED))
338 spin_lock(&dentry->d_lock);
339 parent = dentry->d_parent;
340 inode = parent->d_inode;
342 if (inotify_inode_watched(inode)) {
344 spin_unlock(&dentry->d_lock);
345 inotify_inode_queue_event(inode, mask, cookie, name,
349 spin_unlock(&dentry->d_lock);
351 EXPORT_SYMBOL_GPL(inotify_dentry_parent_queue_event);
354 * inotify_get_cookie - return a unique cookie for use in synchronizing events.
356 u32 inotify_get_cookie(void)
358 return atomic_inc_return(&inotify_cookie);
360 EXPORT_SYMBOL_GPL(inotify_get_cookie);
363 * inotify_unmount_inodes - an sb is unmounting. handle any watched inodes.
364 * @list: list of inodes being unmounted (sb->s_inodes)
366 * Called with inode_lock held, protecting the unmounting super block's list
367 * of inodes, and with iprune_mutex held, keeping shrink_icache_memory() at bay.
368 * We temporarily drop inode_lock, however, and CAN block.
370 void inotify_unmount_inodes(struct list_head *list)
372 struct inode *inode, *next_i, *need_iput = NULL;
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;
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.
384 if (inode->i_state & (I_CLEAR|I_FREEING|I_WILL_FREE|I_NEW))
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.
393 if (!atomic_read(&inode->i_count))
396 need_iput_tmp = need_iput;
398 /* In case inotify_remove_watch_locked() drops a reference. */
399 if (inode != need_iput_tmp)
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 |
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,
416 * iprune_mutex keeps shrink_icache_memory() away.
418 spin_unlock(&inode_lock);
423 /* for each watch, send IN_UNMOUNT and then remove it */
424 mutex_lock(&inode->inotify_mutex);
425 watches = &inode->inotify_watches;
426 list_for_each_entry_safe(watch, next_w, watches, i_list) {
427 struct inotify_handle *ih= watch->ih;
428 get_inotify_watch(watch);
429 mutex_lock(&ih->mutex);
430 ih->in_ops->handle_event(watch, watch->wd, IN_UNMOUNT, 0,
432 inotify_remove_watch_locked(ih, watch);
433 mutex_unlock(&ih->mutex);
434 put_inotify_watch(watch);
436 mutex_unlock(&inode->inotify_mutex);
439 spin_lock(&inode_lock);
442 EXPORT_SYMBOL_GPL(inotify_unmount_inodes);
445 * inotify_inode_is_dead - an inode has been deleted, cleanup any watches
446 * @inode: inode that is about to be removed
448 void inotify_inode_is_dead(struct inode *inode)
450 struct inotify_watch *watch, *next;
452 mutex_lock(&inode->inotify_mutex);
453 list_for_each_entry_safe(watch, next, &inode->inotify_watches, i_list) {
454 struct inotify_handle *ih = watch->ih;
455 mutex_lock(&ih->mutex);
456 inotify_remove_watch_locked(ih, watch);
457 mutex_unlock(&ih->mutex);
459 mutex_unlock(&inode->inotify_mutex);
461 EXPORT_SYMBOL_GPL(inotify_inode_is_dead);
463 /* Kernel Consumer API */
466 * inotify_init - allocate and initialize an inotify instance
467 * @ops: caller's inotify operations
469 struct inotify_handle *inotify_init(const struct inotify_operations *ops)
471 struct inotify_handle *ih;
473 ih = kmalloc(sizeof(struct inotify_handle), GFP_KERNEL);
475 return ERR_PTR(-ENOMEM);
478 INIT_LIST_HEAD(&ih->watches);
479 mutex_init(&ih->mutex);
482 atomic_set(&ih->count, 0);
483 get_inotify_handle(ih);
487 EXPORT_SYMBOL_GPL(inotify_init);
490 * inotify_init_watch - initialize an inotify watch
491 * @watch: watch to initialize
493 void inotify_init_watch(struct inotify_watch *watch)
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 */
500 EXPORT_SYMBOL_GPL(inotify_init_watch);
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
514 * ->s_umount, which will almost certainly wait until the superblock is shut
515 * down and the watch in question is pining for fjords. That's fine, but
516 * there is a problem - we might have hit the window between ->s_active
517 * getting to 0 (i.e. the moment when superblock is past the point of no return
518 * and is heading for shutdown) and the moment when deactivate_super() acquires
519 * ->s_umount. We could just do drop_super() yield() and retry, but that's
520 * rather antisocial and this stuff is luser-triggerable. OTOH, having grabbed
521 * ->s_umount and having found that we'd got there first (i.e. that ->s_root is
522 * non-NULL) we know that we won't race with inotify_umount_inodes(). So we
523 * could grab a reference to watch and do the rest as above, just with
524 * drop_super() instead of deactivate_super(), right? Wrong. We had to drop
525 * ih->mutex before we could grab ->s_umount. So the watch could've been gone
528 * That still can be dealt with - we need to save watch->wd, do idr_find()
529 * and compare its result with our pointer. If they match, we either have
530 * the damn thing still alive or we'd lost not one but two races at once,
531 * the watch had been killed and a new one got created with the same ->wd
532 * at the same address. That couldn't have happened in inotify_destroy(),
533 * but inotify_rm_wd() could run into that. Still, "new one got created"
534 * is not a problem - we have every right to kill it or leave it alone,
535 * whatever's more convenient.
537 * So we can use idr_find(...) == watch && watch->inode->i_sb == sb as
538 * "grab it and kill it" check. If it's been our original watch, we are
539 * fine, if it's a newcomer - nevermind, just pretend that we'd won the
540 * race and kill the fscker anyway; we are safe since we know that its
541 * superblock won't be going away.
543 * And yes, this is far beyond mere "not very pretty"; so's the entire
544 * concept of inotify to start with.
548 * pin_to_kill - pin the watch down for removal
549 * @ih: inotify handle
550 * @watch: watch to kill
552 * Called with ih->mutex held, drops it. Possible return values:
553 * 0 - nothing to do, it has died
554 * 1 - remove it, drop the reference and deactivate_super()
555 * 2 - remove it, drop the reference and drop_super(); we tried hard to avoid
556 * that variant, since it involved a lot of PITA, but that's the best that
557 * could've been done.
559 static int pin_to_kill(struct inotify_handle *ih, struct inotify_watch *watch)
561 struct super_block *sb = watch->inode->i_sb;
564 if (atomic_inc_not_zero(&sb->s_active)) {
565 get_inotify_watch(watch);
566 mutex_unlock(&ih->mutex);
567 return 1; /* the best outcome */
571 spin_unlock(&sb_lock);
572 mutex_unlock(&ih->mutex); /* can't grab ->s_umount under it */
573 down_read(&sb->s_umount);
574 if (likely(!sb->s_root)) {
575 /* fs is already shut down; the watch is dead */
579 /* raced with the final deactivate_super() */
580 mutex_lock(&ih->mutex);
581 if (idr_find(&ih->idr, wd) != watch || watch->inode->i_sb != sb) {
582 /* the watch is dead */
583 mutex_unlock(&ih->mutex);
587 /* still alive or freed and reused with the same sb and wd; kill */
588 get_inotify_watch(watch);
589 mutex_unlock(&ih->mutex);
593 static void unpin_and_kill(struct inotify_watch *watch, int how)
595 struct super_block *sb = watch->inode->i_sb;
596 put_inotify_watch(watch);
599 deactivate_super(sb);
607 * inotify_destroy - clean up and destroy an inotify instance
608 * @ih: inotify handle
610 void inotify_destroy(struct inotify_handle *ih)
613 * Destroy all of the watches for this handle. Unfortunately, not very
614 * pretty. We cannot do a simple iteration over the list, because we
615 * do not know the inode until we iterate to the watch. But we need to
616 * hold inode->inotify_mutex before ih->mutex. The following works.
618 * AV: it had to become even uglier to start working ;-/
621 struct inotify_watch *watch;
622 struct list_head *watches;
623 struct super_block *sb;
627 mutex_lock(&ih->mutex);
628 watches = &ih->watches;
629 if (list_empty(watches)) {
630 mutex_unlock(&ih->mutex);
633 watch = list_first_entry(watches, struct inotify_watch, h_list);
634 sb = watch->inode->i_sb;
635 how = pin_to_kill(ih, watch);
639 inode = watch->inode;
640 mutex_lock(&inode->inotify_mutex);
641 mutex_lock(&ih->mutex);
643 /* make sure we didn't race with another list removal */
644 if (likely(idr_find(&ih->idr, watch->wd))) {
645 remove_watch_no_event(watch, ih);
646 put_inotify_watch(watch);
649 mutex_unlock(&ih->mutex);
650 mutex_unlock(&inode->inotify_mutex);
651 unpin_and_kill(watch, how);
654 /* free this handle: the put matching the get in inotify_init() */
655 put_inotify_handle(ih);
657 EXPORT_SYMBOL_GPL(inotify_destroy);
660 * inotify_find_watch - find an existing watch for an (ih,inode) pair
661 * @ih: inotify handle
662 * @inode: inode to watch
663 * @watchp: pointer to existing inotify_watch
665 * Caller must pin given inode (via nameidata).
667 s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode,
668 struct inotify_watch **watchp)
670 struct inotify_watch *old;
673 mutex_lock(&inode->inotify_mutex);
674 mutex_lock(&ih->mutex);
676 old = inode_find_handle(inode, ih);
678 get_inotify_watch(old); /* caller must put watch */
683 mutex_unlock(&ih->mutex);
684 mutex_unlock(&inode->inotify_mutex);
688 EXPORT_SYMBOL_GPL(inotify_find_watch);
691 * inotify_find_update_watch - find and update the mask of an existing watch
692 * @ih: inotify handle
693 * @inode: inode's watch to update
694 * @mask: mask of events to watch
696 * Caller must pin given inode (via nameidata).
698 s32 inotify_find_update_watch(struct inotify_handle *ih, struct inode *inode,
701 struct inotify_watch *old;
705 if (mask & IN_MASK_ADD)
708 /* don't allow invalid bits: we don't want flags set */
709 mask &= IN_ALL_EVENTS | IN_ONESHOT;
713 mutex_lock(&inode->inotify_mutex);
714 mutex_lock(&ih->mutex);
717 * Handle the case of re-adding a watch on an (inode,ih) pair that we
718 * are already watching. We just update the mask and return its wd.
720 old = inode_find_handle(inode, ih);
721 if (unlikely(!old)) {
732 mutex_unlock(&ih->mutex);
733 mutex_unlock(&inode->inotify_mutex);
736 EXPORT_SYMBOL_GPL(inotify_find_update_watch);
739 * inotify_add_watch - add a watch to an inotify instance
740 * @ih: inotify handle
741 * @watch: caller allocated watch structure
742 * @inode: inode to watch
743 * @mask: mask of events to watch
745 * Caller must pin given inode (via nameidata).
746 * Caller must ensure it only calls inotify_add_watch() once per watch.
747 * Calls inotify_handle_get_wd() so may sleep.
749 s32 inotify_add_watch(struct inotify_handle *ih, struct inotify_watch *watch,
750 struct inode *inode, u32 mask)
755 /* don't allow invalid bits: we don't want flags set */
756 mask &= IN_ALL_EVENTS | IN_ONESHOT;
761 mutex_lock(&inode->inotify_mutex);
762 mutex_lock(&ih->mutex);
764 /* Initialize a new watch */
765 ret = inotify_handle_get_wd(ih, watch);
770 /* save a reference to handle and bump the count to make it official */
771 get_inotify_handle(ih);
775 * Save a reference to the inode and bump the ref count to make it
776 * official. We hold a reference to nameidata, which makes this safe.
778 watch->inode = igrab(inode);
780 /* Add the watch to the handle's and the inode's list */
781 newly_watched = !inotify_inode_watched(inode);
782 list_add(&watch->h_list, &ih->watches);
783 list_add(&watch->i_list, &inode->inotify_watches);
785 * Set child flags _after_ adding the watch, so there is no race
786 * windows where newly instantiated children could miss their parent's
790 set_dentry_child_flags(inode, 1);
793 mutex_unlock(&ih->mutex);
794 mutex_unlock(&inode->inotify_mutex);
797 EXPORT_SYMBOL_GPL(inotify_add_watch);
800 * inotify_clone_watch - put the watch next to existing one
801 * @old: already installed watch
804 * Caller must hold the inotify_mutex of inode we are dealing with;
805 * it is expected to remove the old watch before unlocking the inode.
807 s32 inotify_clone_watch(struct inotify_watch *old, struct inotify_watch *new)
809 struct inotify_handle *ih = old->ih;
812 new->mask = old->mask;
815 mutex_lock(&ih->mutex);
817 /* Initialize a new watch */
818 ret = inotify_handle_get_wd(ih, new);
823 get_inotify_handle(ih);
825 new->inode = igrab(old->inode);
827 list_add(&new->h_list, &ih->watches);
828 list_add(&new->i_list, &old->inode->inotify_watches);
830 mutex_unlock(&ih->mutex);
834 void inotify_evict_watch(struct inotify_watch *watch)
836 get_inotify_watch(watch);
837 mutex_lock(&watch->ih->mutex);
838 inotify_remove_watch_locked(watch->ih, watch);
839 mutex_unlock(&watch->ih->mutex);
843 * inotify_rm_wd - remove a watch from an inotify instance
844 * @ih: inotify handle
845 * @wd: watch descriptor to remove
849 int inotify_rm_wd(struct inotify_handle *ih, u32 wd)
851 struct inotify_watch *watch;
852 struct super_block *sb;
856 mutex_lock(&ih->mutex);
857 watch = idr_find(&ih->idr, wd);
858 if (unlikely(!watch)) {
859 mutex_unlock(&ih->mutex);
862 sb = watch->inode->i_sb;
863 how = pin_to_kill(ih, watch);
867 inode = watch->inode;
869 mutex_lock(&inode->inotify_mutex);
870 mutex_lock(&ih->mutex);
872 /* make sure that we did not race */
873 if (likely(idr_find(&ih->idr, wd) == watch))
874 inotify_remove_watch_locked(ih, watch);
876 mutex_unlock(&ih->mutex);
877 mutex_unlock(&inode->inotify_mutex);
878 unpin_and_kill(watch, how);
882 EXPORT_SYMBOL_GPL(inotify_rm_wd);
885 * inotify_rm_watch - remove a watch from an inotify instance
886 * @ih: inotify handle
887 * @watch: watch to remove
891 int inotify_rm_watch(struct inotify_handle *ih,
892 struct inotify_watch *watch)
894 return inotify_rm_wd(ih, watch->wd);
896 EXPORT_SYMBOL_GPL(inotify_rm_watch);
899 * inotify_setup - core initialization function
901 static int __init inotify_setup(void)
903 BUILD_BUG_ON(IN_ACCESS != FS_ACCESS);
904 BUILD_BUG_ON(IN_MODIFY != FS_MODIFY);
905 BUILD_BUG_ON(IN_ATTRIB != FS_ATTRIB);
906 BUILD_BUG_ON(IN_CLOSE_WRITE != FS_CLOSE_WRITE);
907 BUILD_BUG_ON(IN_CLOSE_NOWRITE != FS_CLOSE_NOWRITE);
908 BUILD_BUG_ON(IN_OPEN != FS_OPEN);
909 BUILD_BUG_ON(IN_MOVED_FROM != FS_MOVED_FROM);
910 BUILD_BUG_ON(IN_MOVED_TO != FS_MOVED_TO);
911 BUILD_BUG_ON(IN_CREATE != FS_CREATE);
912 BUILD_BUG_ON(IN_DELETE != FS_DELETE);
913 BUILD_BUG_ON(IN_DELETE_SELF != FS_DELETE_SELF);
914 BUILD_BUG_ON(IN_MOVE_SELF != FS_MOVE_SELF);
915 BUILD_BUG_ON(IN_Q_OVERFLOW != FS_Q_OVERFLOW);
917 BUILD_BUG_ON(IN_UNMOUNT != FS_UNMOUNT);
918 BUILD_BUG_ON(IN_ISDIR != FS_IN_ISDIR);
919 BUILD_BUG_ON(IN_IGNORED != FS_IN_IGNORED);
920 BUILD_BUG_ON(IN_ONESHOT != FS_IN_ONESHOT);
922 atomic_set(&inotify_cookie, 0);
927 module_init(inotify_setup);