From 57f0f512b273f60d52568b8c6b77e17f5636edc0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9=20Fabian=20Silva=20Delgado?= Date: Wed, 5 Aug 2015 17:04:01 -0300 Subject: Initial import --- include/linux/fsnotify.h | 344 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 344 insertions(+) create mode 100644 include/linux/fsnotify.h (limited to 'include/linux/fsnotify.h') diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h new file mode 100644 index 000000000..7ee1774ed --- /dev/null +++ b/include/linux/fsnotify.h @@ -0,0 +1,344 @@ +#ifndef _LINUX_FS_NOTIFY_H +#define _LINUX_FS_NOTIFY_H + +/* + * include/linux/fsnotify.h - generic hooks for filesystem notification, to + * reduce in-source duplication from both dnotify and inotify. + * + * We don't compile any of this away in some complicated menagerie of ifdefs. + * Instead, we rely on the code inside to optimize away as needed. + * + * (C) Copyright 2005 Robert Love + */ + +#include +#include +#include +#include + +/* + * fsnotify_d_instantiate - instantiate a dentry for inode + */ +static inline void fsnotify_d_instantiate(struct dentry *dentry, + struct inode *inode) +{ + __fsnotify_d_instantiate(dentry, inode); +} + +/* Notify this dentry's parent about a child's events. */ +static inline int fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask) +{ + if (!dentry) + dentry = path->dentry; + + return __fsnotify_parent(path, dentry, mask); +} + +/* simple call site for access decisions */ +static inline int fsnotify_perm(struct file *file, int mask) +{ + struct path *path = &file->f_path; + struct inode *inode = file_inode(file); + __u32 fsnotify_mask = 0; + int ret; + + if (file->f_mode & FMODE_NONOTIFY) + return 0; + if (!(mask & (MAY_READ | MAY_OPEN))) + return 0; + if (mask & MAY_OPEN) + fsnotify_mask = FS_OPEN_PERM; + else if (mask & MAY_READ) + fsnotify_mask = FS_ACCESS_PERM; + else + BUG(); + + ret = fsnotify_parent(path, NULL, fsnotify_mask); + if (ret) + return ret; + + return fsnotify(inode, fsnotify_mask, path, FSNOTIFY_EVENT_PATH, NULL, 0); +} + +/* + * fsnotify_d_move - dentry has been moved + */ +static inline void fsnotify_d_move(struct dentry *dentry) +{ + /* + * On move we need to update dentry->d_flags to indicate if the new parent + * cares about events from this dentry. + */ + __fsnotify_update_dcache_flags(dentry); +} + +/* + * fsnotify_link_count - inode's link count changed + */ +static inline void fsnotify_link_count(struct inode *inode) +{ + fsnotify(inode, FS_ATTRIB, inode, FSNOTIFY_EVENT_INODE, NULL, 0); +} + +/* + * fsnotify_move - file old_name at old_dir was moved to new_name at new_dir + */ +static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir, + const unsigned char *old_name, + int isdir, struct inode *target, struct dentry *moved) +{ + struct inode *source = moved->d_inode; + u32 fs_cookie = fsnotify_get_cookie(); + __u32 old_dir_mask = (FS_EVENT_ON_CHILD | FS_MOVED_FROM); + __u32 new_dir_mask = (FS_EVENT_ON_CHILD | FS_MOVED_TO); + const unsigned char *new_name = moved->d_name.name; + + if (old_dir == new_dir) + old_dir_mask |= FS_DN_RENAME; + + if (isdir) { + old_dir_mask |= FS_ISDIR; + new_dir_mask |= FS_ISDIR; + } + + fsnotify(old_dir, old_dir_mask, source, FSNOTIFY_EVENT_INODE, old_name, + fs_cookie); + fsnotify(new_dir, new_dir_mask, source, FSNOTIFY_EVENT_INODE, new_name, + fs_cookie); + + if (target) + fsnotify_link_count(target); + + if (source) + fsnotify(source, FS_MOVE_SELF, moved->d_inode, FSNOTIFY_EVENT_INODE, NULL, 0); + audit_inode_child(new_dir, moved, AUDIT_TYPE_CHILD_CREATE); +} + +/* + * fsnotify_inode_delete - and inode is being evicted from cache, clean up is needed + */ +static inline void fsnotify_inode_delete(struct inode *inode) +{ + __fsnotify_inode_delete(inode); +} + +/* + * fsnotify_vfsmount_delete - a vfsmount is being destroyed, clean up is needed + */ +static inline void fsnotify_vfsmount_delete(struct vfsmount *mnt) +{ + __fsnotify_vfsmount_delete(mnt); +} + +/* + * fsnotify_nameremove - a filename was removed from a directory + */ +static inline void fsnotify_nameremove(struct dentry *dentry, int isdir) +{ + __u32 mask = FS_DELETE; + + if (isdir) + mask |= FS_ISDIR; + + fsnotify_parent(NULL, dentry, mask); +} + +/* + * fsnotify_inoderemove - an inode is going away + */ +static inline void fsnotify_inoderemove(struct inode *inode) +{ + fsnotify(inode, FS_DELETE_SELF, inode, FSNOTIFY_EVENT_INODE, NULL, 0); + __fsnotify_inode_delete(inode); +} + +/* + * fsnotify_create - 'name' was linked in + */ +static inline void fsnotify_create(struct inode *inode, struct dentry *dentry) +{ + audit_inode_child(inode, dentry, AUDIT_TYPE_CHILD_CREATE); + + fsnotify(inode, FS_CREATE, dentry->d_inode, FSNOTIFY_EVENT_INODE, dentry->d_name.name, 0); +} + +/* + * fsnotify_link - new hardlink in 'inode' directory + * Note: We have to pass also the linked inode ptr as some filesystems leave + * new_dentry->d_inode NULL and instantiate inode pointer later + */ +static inline void fsnotify_link(struct inode *dir, struct inode *inode, struct dentry *new_dentry) +{ + fsnotify_link_count(inode); + audit_inode_child(dir, new_dentry, AUDIT_TYPE_CHILD_CREATE); + + fsnotify(dir, FS_CREATE, inode, FSNOTIFY_EVENT_INODE, new_dentry->d_name.name, 0); +} + +/* + * fsnotify_mkdir - directory 'name' was created + */ +static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry) +{ + __u32 mask = (FS_CREATE | FS_ISDIR); + struct inode *d_inode = dentry->d_inode; + + audit_inode_child(inode, dentry, AUDIT_TYPE_CHILD_CREATE); + + fsnotify(inode, mask, d_inode, FSNOTIFY_EVENT_INODE, dentry->d_name.name, 0); +} + +/* + * fsnotify_access - file was read + */ +static inline void fsnotify_access(struct file *file) +{ + struct path *path = &file->f_path; + struct inode *inode = file_inode(file); + __u32 mask = FS_ACCESS; + + if (S_ISDIR(inode->i_mode)) + mask |= FS_ISDIR; + + if (!(file->f_mode & FMODE_NONOTIFY)) { + fsnotify_parent(path, NULL, mask); + fsnotify(inode, mask, path, FSNOTIFY_EVENT_PATH, NULL, 0); + } +} + +/* + * fsnotify_modify - file was modified + */ +static inline void fsnotify_modify(struct file *file) +{ + struct path *path = &file->f_path; + struct inode *inode = file_inode(file); + __u32 mask = FS_MODIFY; + + if (S_ISDIR(inode->i_mode)) + mask |= FS_ISDIR; + + if (!(file->f_mode & FMODE_NONOTIFY)) { + fsnotify_parent(path, NULL, mask); + fsnotify(inode, mask, path, FSNOTIFY_EVENT_PATH, NULL, 0); + } +} + +/* + * fsnotify_open - file was opened + */ +static inline void fsnotify_open(struct file *file) +{ + struct path *path = &file->f_path; + struct inode *inode = file_inode(file); + __u32 mask = FS_OPEN; + + if (S_ISDIR(inode->i_mode)) + mask |= FS_ISDIR; + + fsnotify_parent(path, NULL, mask); + fsnotify(inode, mask, path, FSNOTIFY_EVENT_PATH, NULL, 0); +} + +/* + * fsnotify_close - file was closed + */ +static inline void fsnotify_close(struct file *file) +{ + struct path *path = &file->f_path; + struct inode *inode = file_inode(file); + fmode_t mode = file->f_mode; + __u32 mask = (mode & FMODE_WRITE) ? FS_CLOSE_WRITE : FS_CLOSE_NOWRITE; + + if (S_ISDIR(inode->i_mode)) + mask |= FS_ISDIR; + + if (!(file->f_mode & FMODE_NONOTIFY)) { + fsnotify_parent(path, NULL, mask); + fsnotify(inode, mask, path, FSNOTIFY_EVENT_PATH, NULL, 0); + } +} + +/* + * fsnotify_xattr - extended attributes were changed + */ +static inline void fsnotify_xattr(struct dentry *dentry) +{ + struct inode *inode = dentry->d_inode; + __u32 mask = FS_ATTRIB; + + if (S_ISDIR(inode->i_mode)) + mask |= FS_ISDIR; + + fsnotify_parent(NULL, dentry, mask); + fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0); +} + +/* + * fsnotify_change - notify_change event. file was modified and/or metadata + * was changed. + */ +static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid) +{ + struct inode *inode = dentry->d_inode; + __u32 mask = 0; + + if (ia_valid & ATTR_UID) + mask |= FS_ATTRIB; + if (ia_valid & ATTR_GID) + mask |= FS_ATTRIB; + if (ia_valid & ATTR_SIZE) + mask |= FS_MODIFY; + + /* both times implies a utime(s) call */ + if ((ia_valid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) + mask |= FS_ATTRIB; + else if (ia_valid & ATTR_ATIME) + mask |= FS_ACCESS; + else if (ia_valid & ATTR_MTIME) + mask |= FS_MODIFY; + + if (ia_valid & ATTR_MODE) + mask |= FS_ATTRIB; + + if (mask) { + if (S_ISDIR(inode->i_mode)) + mask |= FS_ISDIR; + + fsnotify_parent(NULL, dentry, mask); + fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0); + } +} + +#if defined(CONFIG_FSNOTIFY) /* notify helpers */ + +/* + * fsnotify_oldname_init - save off the old filename before we change it + */ +static inline const unsigned char *fsnotify_oldname_init(const unsigned char *name) +{ + return kstrdup(name, GFP_KERNEL); +} + +/* + * fsnotify_oldname_free - free the name we got from fsnotify_oldname_init + */ +static inline void fsnotify_oldname_free(const unsigned char *old_name) +{ + kfree(old_name); +} + +#else /* CONFIG_FSNOTIFY */ + +static inline const char *fsnotify_oldname_init(const unsigned char *name) +{ + return NULL; +} + +static inline void fsnotify_oldname_free(const unsigned char *old_name) +{ +} + +#endif /* CONFIG_FSNOTIFY */ + +#endif /* _LINUX_FS_NOTIFY_H */ -- cgit v1.2.3