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(&dcache_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 list_for_each_entry(alias, &inode->i_dentry, 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 list_for_each_entry(child, &alias->d_subdirs, d_u.d_child) { 72 if (!child->d_inode) 73 continue; 74 75 spin_lock(&child->d_lock); 76 if (watched) 77 child->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED; 78 else 79 child->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED; 80 spin_unlock(&child->d_lock); 81 } 82 } 83 spin_unlock(&dcache_lock); 84 } 85 86 /* Notify this dentry's parent about a child's events. */ 87 void __fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask) 88 { 89 struct dentry *parent; 90 struct inode *p_inode; 91 bool send = false; 92 bool should_update_children = false; 93 94 if (!dentry) 95 dentry = path->dentry; 96 97 if (!(dentry->d_flags & DCACHE_FSNOTIFY_PARENT_WATCHED)) 98 return; 99 100 spin_lock(&dentry->d_lock); 101 parent = dentry->d_parent; 102 p_inode = parent->d_inode; 103 104 if (fsnotify_inode_watches_children(p_inode)) { 105 if (p_inode->i_fsnotify_mask & mask) { 106 dget(parent); 107 send = true; 108 } 109 } else { 110 /* 111 * The parent doesn't care about events on it's children but 112 * at least one child thought it did. We need to run all the 113 * children and update their d_flags to let them know p_inode 114 * doesn't care about them any more. 115 */ 116 dget(parent); 117 should_update_children = true; 118 } 119 120 spin_unlock(&dentry->d_lock); 121 122 if (send) { 123 /* we are notifying a parent so come up with the new mask which 124 * specifies these are events which came from a child. */ 125 mask |= FS_EVENT_ON_CHILD; 126 127 if (path) 128 fsnotify(p_inode, mask, path, FSNOTIFY_EVENT_PATH, 129 dentry->d_name.name, 0); 130 else 131 fsnotify(p_inode, mask, dentry->d_inode, FSNOTIFY_EVENT_INODE, 132 dentry->d_name.name, 0); 133 dput(parent); 134 } 135 136 if (unlikely(should_update_children)) { 137 __fsnotify_update_child_dentry_flags(p_inode); 138 dput(parent); 139 } 140 } 141 EXPORT_SYMBOL_GPL(__fsnotify_parent); 142 143 static int send_to_group(struct inode *to_tell, struct vfsmount *mnt, 144 struct fsnotify_mark *inode_mark, 145 struct fsnotify_mark *vfsmount_mark, 146 __u32 mask, void *data, 147 int data_is, u32 cookie, 148 const unsigned char *file_name, 149 struct fsnotify_event **event) 150 { 151 struct fsnotify_group *group = NULL; 152 __u32 inode_test_mask = 0; 153 __u32 vfsmount_test_mask = 0; 154 155 if (unlikely(!inode_mark && !vfsmount_mark)) { 156 BUG(); 157 return 0; 158 } 159 160 /* clear ignored on inode modification */ 161 if (mask & FS_MODIFY) { 162 if (inode_mark && 163 !(inode_mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)) 164 inode_mark->ignored_mask = 0; 165 if (vfsmount_mark && 166 !(vfsmount_mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)) 167 vfsmount_mark->ignored_mask = 0; 168 } 169 170 /* does the inode mark tell us to do something? */ 171 if (inode_mark) { 172 group = inode_mark->group; 173 inode_test_mask = (mask & ~FS_EVENT_ON_CHILD); 174 inode_test_mask &= inode_mark->mask; 175 inode_test_mask &= ~inode_mark->ignored_mask; 176 } 177 178 /* does the vfsmount_mark tell us to do something? */ 179 if (vfsmount_mark) { 180 vfsmount_test_mask = (mask & ~FS_EVENT_ON_CHILD); 181 group = vfsmount_mark->group; 182 vfsmount_test_mask &= vfsmount_mark->mask; 183 vfsmount_test_mask &= ~vfsmount_mark->ignored_mask; 184 if (inode_mark) 185 vfsmount_test_mask &= ~inode_mark->ignored_mask; 186 } 187 188 pr_debug("%s: group=%p to_tell=%p mnt=%p mask=%x inode_mark=%p" 189 " inode_test_mask=%x vfsmount_mark=%p vfsmount_test_mask=%x" 190 " data=%p data_is=%d cookie=%d event=%p\n", 191 __func__, group, to_tell, mnt, mask, inode_mark, 192 inode_test_mask, vfsmount_mark, vfsmount_test_mask, data, 193 data_is, cookie, *event); 194 195 if (!inode_test_mask && !vfsmount_test_mask) 196 return 0; 197 198 if (group->ops->should_send_event(group, to_tell, inode_mark, 199 vfsmount_mark, mask, data, 200 data_is) == false) 201 return 0; 202 203 if (!*event) { 204 *event = fsnotify_create_event(to_tell, mask, data, 205 data_is, file_name, 206 cookie, GFP_KERNEL); 207 if (!*event) 208 return -ENOMEM; 209 } 210 return group->ops->handle_event(group, inode_mark, vfsmount_mark, *event); 211 } 212 213 /* 214 * This is the main call to fsnotify. The VFS calls into hook specific functions 215 * in linux/fsnotify.h. Those functions then in turn call here. Here will call 216 * out to all of the registered fsnotify_group. Those groups can then use the 217 * notification event in whatever means they feel necessary. 218 */ 219 int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is, 220 const unsigned char *file_name, u32 cookie) 221 { 222 struct hlist_node *inode_node = NULL, *vfsmount_node = NULL; 223 struct fsnotify_mark *inode_mark = NULL, *vfsmount_mark = NULL; 224 struct fsnotify_group *inode_group, *vfsmount_group; 225 struct fsnotify_event *event = NULL; 226 struct vfsmount *mnt; 227 int idx, ret = 0; 228 /* global tests shouldn't care about events on child only the specific event */ 229 __u32 test_mask = (mask & ~FS_EVENT_ON_CHILD); 230 231 if (data_is == FSNOTIFY_EVENT_PATH) 232 mnt = ((struct path *)data)->mnt; 233 else 234 mnt = NULL; 235 236 /* 237 * if this is a modify event we may need to clear the ignored masks 238 * otherwise return if neither the inode nor the vfsmount care about 239 * this type of event. 240 */ 241 if (!(mask & FS_MODIFY) && 242 !(test_mask & to_tell->i_fsnotify_mask) && 243 !(mnt && test_mask & mnt->mnt_fsnotify_mask)) 244 return 0; 245 246 idx = srcu_read_lock(&fsnotify_mark_srcu); 247 248 if ((mask & FS_MODIFY) || 249 (test_mask & to_tell->i_fsnotify_mask)) 250 inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first, 251 &fsnotify_mark_srcu); 252 253 if (mnt && ((mask & FS_MODIFY) || 254 (test_mask & mnt->mnt_fsnotify_mask))) { 255 vfsmount_node = srcu_dereference(mnt->mnt_fsnotify_marks.first, 256 &fsnotify_mark_srcu); 257 inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first, 258 &fsnotify_mark_srcu); 259 } 260 261 while (inode_node || vfsmount_node) { 262 inode_group = vfsmount_group = NULL; 263 264 if (inode_node) { 265 inode_mark = hlist_entry(srcu_dereference(inode_node, &fsnotify_mark_srcu), 266 struct fsnotify_mark, i.i_list); 267 inode_group = inode_mark->group; 268 } 269 270 if (vfsmount_node) { 271 vfsmount_mark = hlist_entry(srcu_dereference(vfsmount_node, &fsnotify_mark_srcu), 272 struct fsnotify_mark, m.m_list); 273 vfsmount_group = vfsmount_mark->group; 274 } 275 276 if (inode_group > vfsmount_group) { 277 /* handle inode */ 278 send_to_group(to_tell, NULL, inode_mark, NULL, mask, data, 279 data_is, cookie, file_name, &event); 280 /* we didn't use the vfsmount_mark */ 281 vfsmount_group = NULL; 282 } else if (vfsmount_group > inode_group) { 283 send_to_group(to_tell, mnt, NULL, vfsmount_mark, mask, data, 284 data_is, cookie, file_name, &event); 285 inode_group = NULL; 286 } else { 287 send_to_group(to_tell, mnt, inode_mark, vfsmount_mark, 288 mask, data, data_is, cookie, file_name, 289 &event); 290 } 291 292 if (inode_group) 293 inode_node = srcu_dereference(inode_node->next, 294 &fsnotify_mark_srcu); 295 if (vfsmount_group) 296 vfsmount_node = srcu_dereference(vfsmount_node->next, 297 &fsnotify_mark_srcu); 298 } 299 300 srcu_read_unlock(&fsnotify_mark_srcu, idx); 301 /* 302 * fsnotify_create_event() took a reference so the event can't be cleaned 303 * up while we are still trying to add it to lists, drop that one. 304 */ 305 if (event) 306 fsnotify_put_event(event); 307 308 return ret; 309 } 310 EXPORT_SYMBOL_GPL(fsnotify); 311 312 static __init int fsnotify_init(void) 313 { 314 int ret; 315 316 BUG_ON(hweight32(ALL_FSNOTIFY_EVENTS) != 23); 317 318 ret = init_srcu_struct(&fsnotify_mark_srcu); 319 if (ret) 320 panic("initializing fsnotify_mark_srcu"); 321 322 return 0; 323 } 324 core_initcall(fsnotify_init); 325