linux/include/linux/fsnotify.h
<<
>>
Prefs
   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 */
  22static 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. */
  29static 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 */
  38static 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 */
  66static 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 */
  78static 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 */
  86static 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 */
 118static 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 */
 126static 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 */
 134static 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 */
 147static 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 */
 156static 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 */
 168static 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 */
 179static 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 */
 192static 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 */
 210static 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 */
 228static 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 */
 244static 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 */
 263static 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 */
 279static 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 */
 316static 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 */
 324static inline void fsnotify_oldname_free(const unsigned char *old_name)
 325{
 326        kfree(old_name);
 327}
 328
 329#else   /* CONFIG_FSNOTIFY */
 330
 331static inline const char *fsnotify_oldname_init(const unsigned char *name)
 332{
 333        return NULL;
 334}
 335
 336static inline void fsnotify_oldname_free(const unsigned char *old_name)
 337{
 338}
 339
 340#endif  /*  CONFIG_FSNOTIFY */
 341
 342#endif  /* _LINUX_FS_NOTIFY_H */
 343
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.