1 #ifndef _LINUX_FS_NOTIFY_H 2 #define _LINUX_FS_NOTIFY_H 3 4 /* 5 * include/linux/fsnotify.h - generic hooks for filesystem notification, to 6 * reduce in-source duplication from both dnotify and inotify. 7 * 8 * We don't compile any of this away in some complicated menagerie of ifdefs. 9 * Instead, we rely on the code inside to optimize away as needed. 10 * 11 * (C) Copyright 2005 Robert Love 12 */ 13 14 #include <linux/dnotify.h> 15 #include <linux/inotify.h> 16 #include <linux/fsnotify_backend.h> 17 #include <linux/audit.h> 18 #include <linux/slab.h> 19 20 /* 21 * fsnotify_d_instantiate - instantiate a dentry for inode 22 * Called with dcache_lock held. 23 */ 24 static inline void fsnotify_d_instantiate(struct dentry *entry, 25 struct inode *inode) 26 { 27 __fsnotify_d_instantiate(entry, inode); 28 29 inotify_d_instantiate(entry, inode); 30 } 31 32 /* Notify this dentry's parent about a child's events. */ 33 static inline void fsnotify_parent(struct dentry *dentry, __u32 mask) 34 { 35 __fsnotify_parent(dentry, mask); 36 37 inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name); 38 } 39 40 /* 41 * fsnotify_d_move - entry has been moved 42 * Called with dcache_lock and entry->d_lock held. 43 */ 44 static inline void fsnotify_d_move(struct dentry *entry) 45 { 46 /* 47 * On move we need to update entry->d_flags to indicate if the new parent 48 * cares about events from this entry. 49 */ 50 __fsnotify_update_dcache_flags(entry); 51 52 inotify_d_move(entry); 53 } 54 55 /* 56 * fsnotify_link_count - inode's link count changed 57 */ 58 static inline void fsnotify_link_count(struct inode *inode) 59 { 60 inotify_inode_queue_event(inode, IN_ATTRIB, 0, NULL, NULL); 61 62 fsnotify(inode, FS_ATTRIB, inode, FSNOTIFY_EVENT_INODE, NULL, 0); 63 } 64 65 /* 66 * fsnotify_move - file old_name at old_dir was moved to new_name at new_dir 67 */ 68 static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir, 69 const char *old_name, 70 int isdir, struct inode *target, struct dentry *moved) 71 { 72 struct inode *source = moved->d_inode; 73 u32 in_cookie = inotify_get_cookie(); 74 u32 fs_cookie = fsnotify_get_cookie(); 75 __u32 old_dir_mask = (FS_EVENT_ON_CHILD | FS_MOVED_FROM); 76 __u32 new_dir_mask = (FS_EVENT_ON_CHILD | FS_MOVED_TO); 77 const char *new_name = moved->d_name.name; 78 79 if (old_dir == new_dir) 80 old_dir_mask |= FS_DN_RENAME; 81 82 if (isdir) { 83 isdir = IN_ISDIR; 84 old_dir_mask |= FS_IN_ISDIR; 85 new_dir_mask |= FS_IN_ISDIR; 86 } 87 88 inotify_inode_queue_event(old_dir, IN_MOVED_FROM|isdir, in_cookie, old_name, 89 source); 90 inotify_inode_queue_event(new_dir, IN_MOVED_TO|isdir, in_cookie, new_name, 91 source); 92 93 fsnotify(old_dir, old_dir_mask, old_dir, FSNOTIFY_EVENT_INODE, old_name, fs_cookie); 94 fsnotify(new_dir, new_dir_mask, new_dir, FSNOTIFY_EVENT_INODE, new_name, fs_cookie); 95 96 if (target) { 97 inotify_inode_queue_event(target, IN_DELETE_SELF, 0, NULL, NULL); 98 inotify_inode_is_dead(target); 99 100 /* this is really a link_count change not a removal */ 101 fsnotify_link_count(target); 102 } 103 104 if (source) { 105 inotify_inode_queue_event(source, IN_MOVE_SELF, 0, NULL, NULL); 106 fsnotify(source, FS_MOVE_SELF, moved->d_inode, FSNOTIFY_EVENT_INODE, NULL, 0); 107 } 108 audit_inode_child(moved, new_dir); 109 } 110 111 /* 112 * fsnotify_inode_delete - and inode is being evicted from cache, clean up is needed 113 */ 114 static inline void fsnotify_inode_delete(struct inode *inode) 115 { 116 __fsnotify_inode_delete(inode); 117 } 118 119 /* 120 * fsnotify_nameremove - a filename was removed from a directory 121 */ 122 static inline void fsnotify_nameremove(struct dentry *dentry, int isdir) 123 { 124 __u32 mask = FS_DELETE; 125 126 if (isdir) 127 mask |= FS_IN_ISDIR; 128 129 fsnotify_parent(dentry, mask); 130 } 131 132 /* 133 * fsnotify_inoderemove - an inode is going away 134 */ 135 static inline void fsnotify_inoderemove(struct inode *inode) 136 { 137 inotify_inode_queue_event(inode, IN_DELETE_SELF, 0, NULL, NULL); 138 inotify_inode_is_dead(inode); 139 140 fsnotify(inode, FS_DELETE_SELF, inode, FSNOTIFY_EVENT_INODE, NULL, 0); 141 __fsnotify_inode_delete(inode); 142 } 143 144 /* 145 * fsnotify_create - 'name' was linked in 146 */ 147 static inline void fsnotify_create(struct inode *inode, struct dentry *dentry) 148 { 149 inotify_inode_queue_event(inode, IN_CREATE, 0, dentry->d_name.name, 150 dentry->d_inode); 151 audit_inode_child(dentry, inode); 152 153 fsnotify(inode, FS_CREATE, dentry->d_inode, FSNOTIFY_EVENT_INODE, dentry->d_name.name, 0); 154 } 155 156 /* 157 * fsnotify_link - new hardlink in 'inode' directory 158 * Note: We have to pass also the linked inode ptr as some filesystems leave 159 * new_dentry->d_inode NULL and instantiate inode pointer later 160 */ 161 static inline void fsnotify_link(struct inode *dir, struct inode *inode, struct dentry *new_dentry) 162 { 163 inotify_inode_queue_event(dir, IN_CREATE, 0, new_dentry->d_name.name, 164 inode); 165 fsnotify_link_count(inode); 166 audit_inode_child(new_dentry, dir); 167 168 fsnotify(dir, FS_CREATE, inode, FSNOTIFY_EVENT_INODE, new_dentry->d_name.name, 0); 169 } 170 171 /* 172 * fsnotify_mkdir - directory 'name' was created 173 */ 174 static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry) 175 { 176 __u32 mask = (FS_CREATE | FS_IN_ISDIR); 177 struct inode *d_inode = dentry->d_inode; 178 179 inotify_inode_queue_event(inode, mask, 0, dentry->d_name.name, d_inode); 180 audit_inode_child(dentry, inode); 181 182 fsnotify(inode, mask, d_inode, FSNOTIFY_EVENT_INODE, dentry->d_name.name, 0); 183 } 184 185 /* 186 * fsnotify_access - file was read 187 */ 188 static inline void fsnotify_access(struct dentry *dentry) 189 { 190 struct inode *inode = dentry->d_inode; 191 __u32 mask = FS_ACCESS; 192 193 if (S_ISDIR(inode->i_mode)) 194 mask |= FS_IN_ISDIR; 195 196 inotify_inode_queue_event(inode, mask, 0, NULL, NULL); 197 198 fsnotify_parent(dentry, mask); 199 fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0); 200 } 201 202 /* 203 * fsnotify_modify - file was modified 204 */ 205 static inline void fsnotify_modify(struct dentry *dentry) 206 { 207 struct inode *inode = dentry->d_inode; 208 __u32 mask = FS_MODIFY; 209 210 if (S_ISDIR(inode->i_mode)) 211 mask |= FS_IN_ISDIR; 212 213 inotify_inode_queue_event(inode, mask, 0, NULL, NULL); 214 215 fsnotify_parent(dentry, mask); 216 fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0); 217 } 218 219 /* 220 * fsnotify_open - file was opened 221 */ 222 static inline void fsnotify_open(struct dentry *dentry) 223 { 224 struct inode *inode = dentry->d_inode; 225 __u32 mask = FS_OPEN; 226 227 if (S_ISDIR(inode->i_mode)) 228 mask |= FS_IN_ISDIR; 229 230 inotify_inode_queue_event(inode, mask, 0, NULL, NULL); 231 232 fsnotify_parent(dentry, mask); 233 fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0); 234 } 235 236 /* 237 * fsnotify_close - file was closed 238 */ 239 static inline void fsnotify_close(struct file *file) 240 { 241 struct dentry *dentry = file->f_path.dentry; 242 struct inode *inode = dentry->d_inode; 243 fmode_t mode = file->f_mode; 244 __u32 mask = (mode & FMODE_WRITE) ? FS_CLOSE_WRITE : FS_CLOSE_NOWRITE; 245 246 if (S_ISDIR(inode->i_mode)) 247 mask |= FS_IN_ISDIR; 248 249 inotify_inode_queue_event(inode, mask, 0, NULL, NULL); 250 251 fsnotify_parent(dentry, mask); 252 fsnotify(inode, mask, file, FSNOTIFY_EVENT_FILE, NULL, 0); 253 } 254 255 /* 256 * fsnotify_xattr - extended attributes were changed 257 */ 258 static inline void fsnotify_xattr(struct dentry *dentry) 259 { 260 struct inode *inode = dentry->d_inode; 261 __u32 mask = FS_ATTRIB; 262 263 if (S_ISDIR(inode->i_mode)) 264 mask |= FS_IN_ISDIR; 265 266 inotify_inode_queue_event(inode, mask, 0, NULL, NULL); 267 268 fsnotify_parent(dentry, mask); 269 fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0); 270 } 271 272 /* 273 * fsnotify_change - notify_change event. file was modified and/or metadata 274 * was changed. 275 */ 276 static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid) 277 { 278 struct inode *inode = dentry->d_inode; 279 __u32 mask = 0; 280 281 if (ia_valid & ATTR_UID) 282 mask |= FS_ATTRIB; 283 if (ia_valid & ATTR_GID) 284 mask |= FS_ATTRIB; 285 if (ia_valid & ATTR_SIZE) 286 mask |= FS_MODIFY; 287 288 /* both times implies a utime(s) call */ 289 if ((ia_valid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) 290 mask |= FS_ATTRIB; 291 else if (ia_valid & ATTR_ATIME) 292 mask |= FS_ACCESS; 293 else if (ia_valid & ATTR_MTIME) 294 mask |= FS_MODIFY; 295 296 if (ia_valid & ATTR_MODE) 297 mask |= FS_ATTRIB; 298 299 if (mask) { 300 if (S_ISDIR(inode->i_mode)) 301 mask |= FS_IN_ISDIR; 302 inotify_inode_queue_event(inode, mask, 0, NULL, NULL); 303 304 fsnotify_parent(dentry, mask); 305 fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0); 306 } 307 } 308 309 #if defined(CONFIG_INOTIFY) || defined(CONFIG_FSNOTIFY) /* notify helpers */ 310 311 /* 312 * fsnotify_oldname_init - save off the old filename before we change it 313 */ 314 static inline const char *fsnotify_oldname_init(const char *name) 315 { 316 return kstrdup(name, GFP_KERNEL); 317 } 318 319 /* 320 * fsnotify_oldname_free - free the name we got from fsnotify_oldname_init 321 */ 322 static inline void fsnotify_oldname_free(const char *old_name) 323 { 324 kfree(old_name); 325 } 326 327 #else /* CONFIG_INOTIFY || CONFIG_FSNOTIFY */ 328 329 static inline const char *fsnotify_oldname_init(const char *name) 330 { 331 return NULL; 332 } 333 334 static inline void fsnotify_oldname_free(const char *old_name) 335 { 336 } 337 338 #endif /* ! CONFIG_INOTIFY */ 339 340 #endif /* _LINUX_FS_NOTIFY_H */ 341