2 * Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2, or (at your option)
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; see the file COPYING. If not, write to
16 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20 #include <linux/init.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/mutex.h>
24 #include <linux/spinlock.h>
25 #include <linux/writeback.h> /* for inode_lock */
27 #include <asm/atomic.h>
29 #include <linux/fsnotify_backend.h>
33 * Recalculate the mask of events relevant to a given inode locked.
35 static void fsnotify_recalc_inode_mask_locked(struct inode
*inode
)
37 struct fsnotify_mark
*mark
;
38 struct hlist_node
*pos
;
41 assert_spin_locked(&inode
->i_lock
);
43 hlist_for_each_entry(mark
, pos
, &inode
->i_fsnotify_marks
, i
.i_list
)
44 new_mask
|= mark
->mask
;
45 inode
->i_fsnotify_mask
= new_mask
;
49 * Recalculate the inode->i_fsnotify_mask, or the mask of all FS_* event types
50 * any notifier is interested in hearing for this inode.
52 void fsnotify_recalc_inode_mask(struct inode
*inode
)
54 spin_lock(&inode
->i_lock
);
55 fsnotify_recalc_inode_mask_locked(inode
);
56 spin_unlock(&inode
->i_lock
);
58 __fsnotify_update_child_dentry_flags(inode
);
61 void fsnotify_destroy_inode_mark(struct fsnotify_mark
*mark
)
63 struct inode
*inode
= mark
->i
.inode
;
65 assert_spin_locked(&mark
->lock
);
66 assert_spin_locked(&mark
->group
->mark_lock
);
68 spin_lock(&inode
->i_lock
);
70 hlist_del_init(&mark
->i
.i_list
);
74 * this mark is now off the inode->i_fsnotify_marks list and we
75 * hold the inode->i_lock, so this is the perfect time to update the
76 * inode->i_fsnotify_mask
78 fsnotify_recalc_inode_mask_locked(inode
);
80 spin_unlock(&inode
->i_lock
);
84 * Given an inode, destroy all of the marks associated with that inode.
86 void fsnotify_clear_marks_by_inode(struct inode
*inode
)
88 struct fsnotify_mark
*mark
, *lmark
;
89 struct hlist_node
*pos
, *n
;
92 spin_lock(&inode
->i_lock
);
93 hlist_for_each_entry_safe(mark
, pos
, n
, &inode
->i_fsnotify_marks
, i
.i_list
) {
94 list_add(&mark
->i
.free_i_list
, &free_list
);
95 hlist_del_init(&mark
->i
.i_list
);
96 fsnotify_get_mark(mark
);
98 spin_unlock(&inode
->i_lock
);
100 list_for_each_entry_safe(mark
, lmark
, &free_list
, i
.free_i_list
) {
101 fsnotify_destroy_mark(mark
);
102 fsnotify_put_mark(mark
);
107 * Given a group clear all of the inode marks associated with that group.
109 void fsnotify_clear_inode_marks_by_group(struct fsnotify_group
*group
)
111 fsnotify_clear_marks_by_group_flags(group
, FSNOTIFY_MARK_FLAG_INODE
);
115 * given a group and inode, find the mark associated with that combination.
116 * if found take a reference to that mark and return it, else return NULL
118 struct fsnotify_mark
*fsnotify_find_inode_mark_locked(struct fsnotify_group
*group
,
121 struct fsnotify_mark
*mark
;
122 struct hlist_node
*pos
;
124 assert_spin_locked(&inode
->i_lock
);
126 hlist_for_each_entry(mark
, pos
, &inode
->i_fsnotify_marks
, i
.i_list
) {
127 if (mark
->group
== group
) {
128 fsnotify_get_mark(mark
);
136 * given a group and inode, find the mark associated with that combination.
137 * if found take a reference to that mark and return it, else return NULL
139 struct fsnotify_mark
*fsnotify_find_inode_mark(struct fsnotify_group
*group
,
142 struct fsnotify_mark
*mark
;
144 spin_lock(&inode
->i_lock
);
145 mark
= fsnotify_find_inode_mark_locked(group
, inode
);
146 spin_unlock(&inode
->i_lock
);
152 * If we are setting a mark mask on an inode mark we should pin the inode
155 void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark
*mark
,
160 assert_spin_locked(&mark
->lock
);
164 !(mark
->flags
& FSNOTIFY_MARK_FLAG_OBJECT_PINNED
)) {
165 mark
->flags
|= FSNOTIFY_MARK_FLAG_OBJECT_PINNED
;
166 inode
= igrab(mark
->i
.inode
);
168 * we shouldn't be able to get here if the inode wasn't
169 * already safely held in memory. But bug in case it
177 * Attach an initialized mark to a given group and inode.
178 * These marks may be used for the fsnotify backend to determine which
179 * event types should be delivered to which group and for which inodes.
181 int fsnotify_add_inode_mark(struct fsnotify_mark
*mark
,
182 struct fsnotify_group
*group
, struct inode
*inode
,
185 struct fsnotify_mark
*lmark
= NULL
;
188 mark
->flags
= FSNOTIFY_MARK_FLAG_INODE
;
190 assert_spin_locked(&mark
->lock
);
191 assert_spin_locked(&group
->mark_lock
);
193 spin_lock(&inode
->i_lock
);
196 lmark
= fsnotify_find_inode_mark_locked(group
, inode
);
198 mark
->i
.inode
= inode
;
200 hlist_add_head(&mark
->i
.i_list
, &inode
->i_fsnotify_marks
);
202 fsnotify_recalc_inode_mask_locked(inode
);
205 spin_unlock(&inode
->i_lock
);
214 * fsnotify_unmount_inodes - an sb is unmounting. handle any watched inodes.
215 * @list: list of inodes being unmounted (sb->s_inodes)
217 * Called with inode_lock held, protecting the unmounting super block's list
218 * of inodes, and with iprune_mutex held, keeping shrink_icache_memory() at bay.
219 * We temporarily drop inode_lock, however, and CAN block.
221 void fsnotify_unmount_inodes(struct list_head
*list
)
223 struct inode
*inode
, *next_i
, *need_iput
= NULL
;
225 list_for_each_entry_safe(inode
, next_i
, list
, i_sb_list
) {
226 struct inode
*need_iput_tmp
;
229 * We cannot __iget() an inode in state I_CLEAR, I_FREEING,
230 * I_WILL_FREE, or I_NEW which is fine because by that point
231 * the inode cannot have any associated watches.
233 if (inode
->i_state
& (I_CLEAR
|I_FREEING
|I_WILL_FREE
|I_NEW
))
237 * If i_count is zero, the inode cannot have any watches and
238 * doing an __iget/iput with MS_ACTIVE clear would actually
239 * evict all inodes with zero i_count from icache which is
240 * unnecessarily violent and may in fact be illegal to do.
242 if (!atomic_read(&inode
->i_count
))
245 need_iput_tmp
= need_iput
;
248 /* In case fsnotify_inode_delete() drops a reference. */
249 if (inode
!= need_iput_tmp
)
252 need_iput_tmp
= NULL
;
254 /* In case the dropping of a reference would nuke next_i. */
255 if ((&next_i
->i_sb_list
!= list
) &&
256 atomic_read(&next_i
->i_count
) &&
257 !(next_i
->i_state
& (I_CLEAR
| I_FREEING
| I_WILL_FREE
))) {
263 * We can safely drop inode_lock here because we hold
264 * references on both inode and next_i. Also no new inodes
265 * will be added since the umount has begun. Finally,
266 * iprune_mutex keeps shrink_icache_memory() away.
268 spin_unlock(&inode_lock
);
273 /* for each watch, send FS_UNMOUNT and then remove it */
274 fsnotify(inode
, FS_UNMOUNT
, inode
, FSNOTIFY_EVENT_INODE
, NULL
, 0);
276 fsnotify_inode_delete(inode
);
280 spin_lock(&inode_lock
);