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