1 /* 2 * Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com> 3 * 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) 7 * any later version. 8 * 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. 13 * 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. 17 */ 18 19 #include <linux/dcache.h> 20 #include <linux/fs.h> 21 #include <linux/gfp.h> 22 #include <linux/init.h> 23 #include <linux/module.h> 24 #include <linux/mount.h> 25 #include <linux/srcu.h> 26 27 #include <linux/fsnotify_backend.h> 28 #include "fsnotify.h" 29 30 /* 31 * Clear all of the marks on an inode when it is being evicted from core 32 */ 33 void __fsnotify_inode_delete(struct inode *inode) 34 { 35 fsnotify_clear_marks_by_inode(inode); 36 } 37 EXPORT_SYMBOL_GPL(__fsnotify_inode_delete); 38 39 void __fsnotify_vfsmount_delete(struct vfsmount *mnt) 40 { 41 fsnotify_clear_marks_by_mount(mnt); 42 } 43 44 /* 45 * Given an inode, first check if we care what happens to our children. Inotify 46 * and dnotify both tell their parents about events. If we care about any event 47 * on a child we run all of our children and set a dentry flag saying that the 48 * parent cares. Thus when an event happens on a child it can quickly tell if 49 * if there is a need to find a parent and send the event to the parent. 50 */ 51 void __fsnotify_update_child_dentry_flags(struct inode *inode) 52 { 53 struct dentry *alias; 54 int watched; 55 56 if (!S_ISDIR(inode->i_mode)) 57 return; 58 59 /* determine if the children should tell inode about their events */ 60 watched = fsnotify_inode_watches_children(inode); 61 62 spin_lock(&inode->i_lock); 63 /* run all of the dentries associated with this inode. Since this is a 64 * directory, there damn well better only be one item on this list */ 65 hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) { 66 struct dentry *child; 67 68 /* run all of the children of the original inode and fix their 69 * d_flags to indicate parental interest (their parent is the 70 * original inode) */ 71 spin_lock(&alias->d_lock); 72 list_for_each_entry(child, &alias->d_subdirs, d_child) { 73 if (!child->d_inode) 74 continue; 75 76 spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED); 77 if (watched) 78 child->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED; 79 else 80 child->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED; 81 spin_unlock(&child->d_lock); 82 } 83 spin_unlock(&alias->d_lock); 84 } 85 spin_unlock(&inode->i_lock); 86 } 87 88 /* Notify this dentry's parent about a child's events. */ 89 int __fsnotify_parent(const struct path *path, struct dentry *dentry, __u32 mask) 90 { 91 struct dentry *parent; 92 struct inode *p_inode; 93 int ret = 0; 94 95 if (!dentry) 96 dentry = path->dentry; 97 98 if (!(dentry->d_flags & DCACHE_FSNOTIFY_PARENT_WATCHED)) 99 return 0; 100 101 parent = dget_parent(dentry); 102 p_inode = parent->d_inode; 103 104 if (unlikely(!fsnotify_inode_watches_children(p_inode))) 105 __fsnotify_update_child_dentry_flags(p_inode); 106 else if (p_inode->i_fsnotify_mask & mask) { 107 /* we are notifying a parent so come up with the new mask which 108 * specifies these are events which came from a child. */ 109 mask |= FS_EVENT_ON_CHILD; 110 111 if (path) 112 ret = fsnotify(p_inode, mask, path, FSNOTIFY_EVENT_PATH, 113 dentry->d_name.name, 0); 114 else 115 ret = fsnotify(p_inode, mask, dentry->d_inode, FSNOTIFY_EVENT_INODE, 116 dentry->d_name.name, 0); 117 } 118 119 dput(parent); 120 121 return ret; 122 } 123 EXPORT_SYMBOL_GPL(__fsnotify_parent); 124 125 static int send_to_group(struct inode *to_tell, 126 struct fsnotify_mark *inode_mark, 127 struct fsnotify_mark *vfsmount_mark, 128 __u32 mask, const void *data, 129 int data_is, u32 cookie, 130 const unsigned char *file_name) 131 { 132 struct fsnotify_group *group = NULL; 133 __u32 inode_test_mask = 0; 134 __u32 vfsmount_test_mask = 0; 135 136 if (unlikely(!inode_mark && !vfsmount_mark)) { 137 BUG(); 138 return 0; 139 } 140 141 /* clear ignored on inode modification */ 142 if (mask & FS_MODIFY) { 143 if (inode_mark && 144 !(inode_mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)) 145 inode_mark->ignored_mask = 0; 146 if (vfsmount_mark && 147 !(vfsmount_mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)) 148 vfsmount_mark->ignored_mask = 0; 149 } 150 151 /* does the inode mark tell us to do something? */ 152 if (inode_mark) { 153 group = inode_mark->group; 154 inode_test_mask = (mask & ~FS_EVENT_ON_CHILD); 155 inode_test_mask &= inode_mark->mask; 156 inode_test_mask &= ~inode_mark->ignored_mask; 157 } 158 159 /* does the vfsmount_mark tell us to do something? */ 160 if (vfsmount_mark) { 161 vfsmount_test_mask = (mask & ~FS_EVENT_ON_CHILD); 162 group = vfsmount_mark->group; 163 vfsmount_test_mask &= vfsmount_mark->mask; 164 vfsmount_test_mask &= ~vfsmount_mark->ignored_mask; 165 if (inode_mark) 166 vfsmount_test_mask &= ~inode_mark->ignored_mask; 167 } 168 169 pr_debug("%s: group=%p to_tell=%p mask=%x inode_mark=%p" 170 " inode_test_mask=%x vfsmount_mark=%p vfsmount_test_mask=%x" 171 " data=%p data_is=%d cookie=%d\n", 172 __func__, group, to_tell, mask, inode_mark, 173 inode_test_mask, vfsmount_mark, vfsmount_test_mask, data, 174 data_is, cookie); 175 176 if (!inode_test_mask && !vfsmount_test_mask) 177 return 0; 178 179 return group->ops->handle_event(group, to_tell, inode_mark, 180 vfsmount_mark, mask, data, data_is, 181 file_name, cookie); 182 } 183 184 /* 185 * This is the main call to fsnotify. The VFS calls into hook specific functions 186 * in linux/fsnotify.h. Those functions then in turn call here. Here will call 187 * out to all of the registered fsnotify_group. Those groups can then use the 188 * notification event in whatever means they feel necessary. 189 */ 190 int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is, 191 const unsigned char *file_name, u32 cookie) 192 { 193 struct hlist_node *inode_node = NULL, *vfsmount_node = NULL; 194 struct fsnotify_mark *inode_mark = NULL, *vfsmount_mark = NULL; 195 struct fsnotify_group *inode_group, *vfsmount_group; 196 struct mount *mnt; 197 int idx, ret = 0; 198 /* global tests shouldn't care about events on child only the specific event */ 199 __u32 test_mask = (mask & ~FS_EVENT_ON_CHILD); 200 201 if (data_is == FSNOTIFY_EVENT_PATH) 202 mnt = real_mount(((const struct path *)data)->mnt); 203 else 204 mnt = NULL; 205 206 /* 207 * Optimization: srcu_read_lock() has a memory barrier which can 208 * be expensive. It protects walking the *_fsnotify_marks lists. 209 * However, if we do not walk the lists, we do not have to do 210 * SRCU because we have no references to any objects and do not 211 * need SRCU to keep them "alive". 212 */ 213 if (hlist_empty(&to_tell->i_fsnotify_marks) && 214 (!mnt || hlist_empty(&mnt->mnt_fsnotify_marks))) 215 return 0; 216 /* 217 * if this is a modify event we may need to clear the ignored masks 218 * otherwise return if neither the inode nor the vfsmount care about 219 * this type of event. 220 */ 221 if (!(mask & FS_MODIFY) && 222 !(test_mask & to_tell->i_fsnotify_mask) && 223 !(mnt && test_mask & mnt->mnt_fsnotify_mask)) 224 return 0; 225 226 idx = srcu_read_lock(&fsnotify_mark_srcu); 227 228 if ((mask & FS_MODIFY) || 229 (test_mask & to_tell->i_fsnotify_mask)) 230 inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first, 231 &fsnotify_mark_srcu); 232 233 if (mnt && ((mask & FS_MODIFY) || 234 (test_mask & mnt->mnt_fsnotify_mask))) { 235 vfsmount_node = srcu_dereference(mnt->mnt_fsnotify_marks.first, 236 &fsnotify_mark_srcu); 237 inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first, 238 &fsnotify_mark_srcu); 239 } 240 241 /* 242 * We need to merge inode & vfsmount mark lists so that inode mark 243 * ignore masks are properly reflected for mount mark notifications. 244 * That's why this traversal is so complicated... 245 */ 246 while (inode_node || vfsmount_node) { 247 inode_group = NULL; 248 inode_mark = NULL; 249 vfsmount_group = NULL; 250 vfsmount_mark = NULL; 251 252 if (inode_node) { 253 inode_mark = hlist_entry(srcu_dereference(inode_node, &fsnotify_mark_srcu), 254 struct fsnotify_mark, obj_list); 255 inode_group = inode_mark->group; 256 } 257 258 if (vfsmount_node) { 259 vfsmount_mark = hlist_entry(srcu_dereference(vfsmount_node, &fsnotify_mark_srcu), 260 struct fsnotify_mark, obj_list); 261 vfsmount_group = vfsmount_mark->group; 262 } 263 264 if (inode_group && vfsmount_group) { 265 int cmp = fsnotify_compare_groups(inode_group, 266 vfsmount_group); 267 if (cmp > 0) { 268 inode_group = NULL; 269 inode_mark = NULL; 270 } else if (cmp < 0) { 271 vfsmount_group = NULL; 272 vfsmount_mark = NULL; 273 } 274 } 275 ret = send_to_group(to_tell, inode_mark, vfsmount_mark, mask, 276 data, data_is, cookie, file_name); 277 278 if (ret && (mask & ALL_FSNOTIFY_PERM_EVENTS)) 279 goto out; 280 281 if (inode_group) 282 inode_node = srcu_dereference(inode_node->next, 283 &fsnotify_mark_srcu); 284 if (vfsmount_group) 285 vfsmount_node = srcu_dereference(vfsmount_node->next, 286 &fsnotify_mark_srcu); 287 } 288 ret = 0; 289 out: 290 srcu_read_unlock(&fsnotify_mark_srcu, idx); 291 292 return ret; 293 } 294 EXPORT_SYMBOL_GPL(fsnotify); 295 296 static __init int fsnotify_init(void) 297 { 298 int ret; 299 300 BUG_ON(hweight32(ALL_FSNOTIFY_EVENTS) != 23); 301 302 ret = init_srcu_struct(&fsnotify_mark_srcu); 303 if (ret) 304 panic("initializing fsnotify_mark_srcu"); 305 306 return 0; 307 } 308 core_initcall(fsnotify_init); 309