include/linux/fsnotify.h

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