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/init.h> 22 #include <linux/module.h> 23 #include <linux/srcu.h> 24 25 #include <linux/fsnotify_backend.h> 26 #include "fsnotify.h" 27 28 /* 29 * Clear all of the marks on an inode when it is being evicted from core 30 */ 31 void __fsnotify_inode_delete(struct inode *inode) 32 { 33 fsnotify_clear_marks_by_inode(inode); 34 } 35 EXPORT_SYMBOL_GPL(__fsnotify_inode_delete); 36 37 /* 38 * Given an inode, first check if we care what happens to our children. Inotify 39 * and dnotify both tell their parents about events. If we care about any event 40 * on a child we run all of our children and set a dentry flag saying that the 41 * parent cares. Thus when an event happens on a child it can quickly tell if 42 * if there is a need to find a parent and send the event to the parent. 43 */ 44 void __fsnotify_update_child_dentry_flags(struct inode *inode) 45 { 46 struct dentry *alias; 47 int watched; 48 49 if (!S_ISDIR(inode->i_mode)) 50 return; 51 52 /* determine if the children should tell inode about their events */ 53 watched = fsnotify_inode_watches_children(inode); 54 55 spin_lock(&dcache_lock); 56 /* run all of the dentries associated with this inode. Since this is a 57 * directory, there damn well better only be one item on this list */ 58 list_for_each_entry(alias, &inode->i_dentry, d_alias) { 59 struct dentry *child; 60 61 /* run all of the children of the original inode and fix their 62 * d_flags to indicate parental interest (their parent is the 63 * original inode) */ 64 list_for_each_entry(child, &alias->d_subdirs, d_u.d_child) { 65 if (!child->d_inode) 66 continue; 67 68 spin_lock(&child->d_lock); 69 if (watched) 70 child->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED; 71 else 72 child->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED; 73 spin_unlock(&child->d_lock); 74 } 75 } 76 spin_unlock(&dcache_lock); 77 } 78 79 /* Notify this dentry's parent about a child's events. */ 80 void __fsnotify_parent(struct dentry *dentry, __u32 mask) 81 { 82 struct dentry *parent; 83 struct inode *p_inode; 84 bool send = false; 85 bool should_update_children = false; 86 87 if (!(dentry->d_flags & DCACHE_FSNOTIFY_PARENT_WATCHED)) 88 return; 89 90 spin_lock(&dentry->d_lock); 91 parent = dentry->d_parent; 92 p_inode = parent->d_inode; 93 94 if (fsnotify_inode_watches_children(p_inode)) { 95 if (p_inode->i_fsnotify_mask & mask) { 96 dget(parent); 97 send = true; 98 } 99 } else { 100 /* 101 * The parent doesn't care about events on it's children but 102 * at least one child thought it did. We need to run all the 103 * children and update their d_flags to let them know p_inode 104 * doesn't care about them any more. 105 */ 106 dget(parent); 107 should_update_children = true; 108 } 109 110 spin_unlock(&dentry->d_lock); 111 112 if (send) { 113 /* we are notifying a parent so come up with the new mask which 114 * specifies these are events which came from a child. */ 115 mask |= FS_EVENT_ON_CHILD; 116 117 fsnotify(p_inode, mask, dentry->d_inode, FSNOTIFY_EVENT_INODE, 118 dentry->d_name.name, 0); 119 dput(parent); 120 } 121 122 if (unlikely(should_update_children)) { 123 __fsnotify_update_child_dentry_flags(p_inode); 124 dput(parent); 125 } 126 } 127 EXPORT_SYMBOL_GPL(__fsnotify_parent); 128 129 /* 130 * This is the main call to fsnotify. The VFS calls into hook specific functions 131 * in linux/fsnotify.h. Those functions then in turn call here. Here will call 132 * out to all of the registered fsnotify_group. Those groups can then use the 133 * notification event in whatever means they feel necessary. 134 */ 135 void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is, const char *file_name, u32 cookie) 136 { 137 struct fsnotify_group *group; 138 struct fsnotify_event *event = NULL; 139 int idx; 140 /* global tests shouldn't care about events on child only the specific event */ 141 __u32 test_mask = (mask & ~FS_EVENT_ON_CHILD); 142 143 if (list_empty(&fsnotify_groups)) 144 return; 145 146 if (!(test_mask & fsnotify_mask)) 147 return; 148 149 if (!(test_mask & to_tell->i_fsnotify_mask)) 150 return; 151 /* 152 * SRCU!! the groups list is very very much read only and the path is 153 * very hot. The VAST majority of events are not going to need to do 154 * anything other than walk the list so it's crazy to pre-allocate. 155 */ 156 idx = srcu_read_lock(&fsnotify_grp_srcu); 157 list_for_each_entry_rcu(group, &fsnotify_groups, group_list) { 158 if (test_mask & group->mask) { 159 if (!group->ops->should_send_event(group, to_tell, mask)) 160 continue; 161 if (!event) { 162 event = fsnotify_create_event(to_tell, mask, data, 163 data_is, file_name, cookie, 164 GFP_KERNEL); 165 /* shit, we OOM'd and now we can't tell, maybe 166 * someday someone else will want to do something 167 * here */ 168 if (!event) 169 break; 170 } 171 group->ops->handle_event(group, event); 172 } 173 } 174 srcu_read_unlock(&fsnotify_grp_srcu, idx); 175 /* 176 * fsnotify_create_event() took a reference so the event can't be cleaned 177 * up while we are still trying to add it to lists, drop that one. 178 */ 179 if (event) 180 fsnotify_put_event(event); 181 } 182 EXPORT_SYMBOL_GPL(fsnotify); 183 184 static __init int fsnotify_init(void) 185 { 186 return init_srcu_struct(&fsnotify_grp_srcu); 187 } 188 subsys_initcall(fsnotify_init); 189