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