mutex: add atomic_dec_and_mutex_lock
Subsystems (5)
PATCH 1/12 mutex: add atomic_dec_and_mutex_lock
Much like the atomic_dec_and_lock() function in which we take and hold a spin_lock if we drop the atomic to 0 this function takes and holds the mutex if we dec the atomic to 0.
LKML-Reference: <[email protected]>
---
include/linux/mutex.h | 23 +++++++++++++++++++++++ 1 files changed, 23 insertions(+), 0 deletions(-)
include/linux/mutex.h +23 -0
@@ -151,4 +151,27 @@ extern int __must_check mutex_lock_killable(struct mutex *lock);extern int mutex_trylock (struct mutex *lock);extern void mutex_unlock (struct mutex *lock); +/** +* atomic_dec_and_mutex_lock - return holding mutex if we dec to 0 +* @cnt: the atomic which we are to dec +* @lock: the mutex to return holding if we dec to 0 +* +* return true and hold lock if we dec to 0, return false otherwise +*/ +static inline int atomic_dec_and_mutex_lock (atomic_t *cnt,struct mutex *lock) +{ +/* dec if we can't possibly hit 0 */ +if (atomic_add_unless (cnt,-1 ,1 )) +return 0 ; +/* we might hit 0, so take the lock */ +mutex_lock (lock); +if (!atomic_dec_and_test (cnt)) { +/* when we actually did the dec, we didn't hit 0 */ +mutex_unlock (lock); +return 0 ; + } +/* we hit 0, and we hold the lock */ +return 1 ; +} +#endif
PATCH 2/12 fsnotify: unified filesystem notification backend
fsnotify is a backend for filesystem notification. fsnotify does not provide any userspace interface but does provide the basis needed for other notification schemes such as dnotify. fsnotify can be extended to be the backend for inotify or the upcoming fanotify. fsnotify provides a mechanism for "groups" to register for some set of filesystem events and to then deliver those events to those groups for processing.
fsnotify has a number of benefits, the first being actually shrinking the size of an inode. Before fsnotify to support both dnotify and inotify an inode had
unsigned long i_dnotify_mask; /* Directory notify events */
struct dnotify_struct *i_dnotify; /* for directory notifications */
struct list_head inotify_watches; /* watches on this inode */
struct mutex inotify_mutex; /* protects the watches listBut with fsnotify this same functionallity (and more) is done with just
__u32 i_fsnotify_mask; /* all events for this inode */
struct hlist_head i_fsnotify_mark_entries; /* marks on this inode */
That's right, inotify, dnotify, and fanotify all in 64 bits. We used that much space just in inotify_watches alone, before this patch set.
fsnotify object lifetime and locking is MUCH better than what we have today. inotify locking is incredibly complex. See 8f7b0ba1c8539 as an example of what's been busted since inception. inotify needs to know internal semantics of superblock destruction and unmounting to function. The inode pinning and vfs contortions are horrible.
no fsnotify implementers do allocation under locks. This means things like f04b30de3 which (due to an overabundance of caution) changes GFP_KERNEL to GFP_NOFS can be reverted. There are no longer any allocation rules when using or implementing your own fsnotify listener.
fsnotify paves the way for fanotify. In brief fanotify is a notification mechanism that delivers the lisener both an 'event' and an open file descriptor to the object in question. This means that fanotify is pathname agnostic. Some on lkml may not care for the original companies or users that pushed for TALPA, but fanotify was designed with flexibility and input for other users in mind. The readahead group expressed interest in fanotify as it could be used to profile disk access on boot without breaking the audit system. The desktop search groups have also expressed interest in fanotify as it solves a number of the race conditions and problems present with managing inotify when more than a limited number of specific files are of interest. fanotify can provide for a userspace access control system which makes it a clean interface for AV vendors to hook without trying to do binary patching on the syscall table, LSM, and everywhere else they do their things today. With this patch series fanotify can be implemented in less than 1200 lines of easy to review code. Almost all of which is the socket based user interface.
This patch series builds fsnotify to the point that it can implement dnotify and inotify_user. Patches exist and will be sent soon after acceptance to finish the in kernel inotify conversion (audit) and implement fanotify.
---
fs/notify/Kconfig | 13 ++ fs/notify/Makefile | 2 fs/notify/fsnotify.c | 79 +++++++++++++++ fs/notify/fsnotify.h | 15 +++ fs/notify/group.c | 198 ++++++++++++++++++++++++++++++++++++++ fs/notify/inotify/inotify.c | 20 ++++ fs/notify/notification.c | 121 +++++++++++++++++++++++ include/linux/fsnotify.h | 115 +++++++++++++++------- include/linux/fsnotify_backend.h | 177 ++++++++++++++++++++++++++++++++++ 9 files changed, 705 insertions(+), 35 deletions(-) create mode 100644 fs/notify/fsnotify.c create mode 100644 fs/notify/fsnotify.h create mode 100644 fs/notify/group.c create mode 100644 fs/notify/notification.c create mode 100644 include/linux/fsnotify_backend.h
fs/notify/Kconfig +13 -0
@@ -1,2 +1,15 @@ +config FSNOTIFY + bool "Filesystem notification backend" + default y + ---help--- + fsnotify is a backend for filesystem notification. fsnotify does + not provide any userspace interface but does provide the basis + needed for other notification schemes such as dnotify, inotify, + and fanotify. + + Say Y here to enable fsnotify suport. + + If unsure, say Y. + source "fs/notify/dnotify/Kconfig" source "fs/notify/inotify/Kconfig"
fs/notify/Makefile +2 -0
@@ -1,2 +1,4 @@ +obj-$(CONFIG_FSNOTIFY) += fsnotify.o notification.o group.o + obj-y += dnotify/ obj-y += inotify/
fs/notify/fsnotify.c new file +79 -0
79 lines not on this page · raw message
fs/notify/fsnotify.h new file +15 -0
@@ -0,0 +1,15 @@ +#ifndef __FS_NOTIFY_FSNOTIFY_H_ +#define __FS_NOTIFY_FSNOTIFY_H_ + +#include <linux/list.h> +#include <linux/fsnotify.h> +#include <linux/srcu.h> +#include <linux/types.h> + +/* protects reads of fsnotify_groups */ +extern struct srcu_struct fsnotify_grp_srcu; +/* all groups which receive fsnotify events */ +extern struct list_head fsnotify_groups; +/* all bitwise OR of all event types (FS_*) for all fsnotify_groups */ +extern __u32 fsnotify_mask; +#endif /* __FS_NOTIFY_FSNOTIFY_H_ */
fs/notify/group.c new file +198 -0
198 lines not on this page · raw message
fs/notify/inotify/inotify.c +20 -0
@@ -32,6 +32,7 @@#include <linux/list.h> #include <linux/writeback.h> #include <linux/inotify.h> +#include <linux/fsnotify_backend.h> static atomic_t inotify_cookie;
@@ -905,6 +906,25 @@ EXPORT_SYMBOL_GPL(inotify_rm_watch);*/ static int __init inotify_setup (void ) { +BUILD_BUG_ON (IN_ACCESS !=FS_ACCESS ); +BUILD_BUG_ON (IN_MODIFY !=FS_MODIFY ); +BUILD_BUG_ON (IN_ATTRIB !=FS_ATTRIB ); +BUILD_BUG_ON (IN_CLOSE_WRITE !=FS_CLOSE_WRITE ); +BUILD_BUG_ON (IN_CLOSE_NOWRITE !=FS_CLOSE_NOWRITE ); +BUILD_BUG_ON (IN_OPEN !=FS_OPEN ); +BUILD_BUG_ON (IN_MOVED_FROM !=FS_MOVED_FROM ); +BUILD_BUG_ON (IN_MOVED_TO !=FS_MOVED_TO ); +BUILD_BUG_ON (IN_CREATE !=FS_CREATE ); +BUILD_BUG_ON (IN_DELETE !=FS_DELETE ); +BUILD_BUG_ON (IN_DELETE_SELF !=FS_DELETE_SELF ); +BUILD_BUG_ON (IN_MOVE_SELF !=FS_MOVE_SELF ); +BUILD_BUG_ON (IN_Q_OVERFLOW !=FS_Q_OVERFLOW ); + +BUILD_BUG_ON (IN_UNMOUNT !=FS_UNMOUNT ); +BUILD_BUG_ON (IN_ISDIR !=FS_IN_ISDIR ); +BUILD_BUG_ON (IN_IGNORED !=FS_IN_IGNORED ); +BUILD_BUG_ON (IN_ONESHOT !=FS_IN_ONESHOT ); +atomic_set (&inotify_cookie,0 );return 0 ;
fs/notify/notification.c new file +121 -0
121 lines not on this page · raw message
include/linux/fsnotify.h +80 -35
288 lines not on this page · raw message
include/linux/fsnotify_backend.h new file +177 -0
177 lines not on this page · raw message
PATCH 3/12 fsnotify: add marks to inodes so groups can interpret how to handle those inodes
In reply to Eric ParisThis patch creates a way for fsnotify groups to attach marks to inodes. These marks have little meaning to the generic fsnotify infrastructure and thus their meaning should be interpreted by the group that attached them to the inode's list.
dnotify and inotify will make use of these markings to indicate which inodes are of interest to their respective groups. But this implementation has the useful property that in the future other listeners could actually use the marks for the exact opposite reason, aka to indicate which inodes it had NO interest in.
---
fs/inode.c | 9 + fs/notify/Makefile | 2 fs/notify/fsnotify.c | 13 ++ fs/notify/fsnotify.h | 5 + fs/notify/group.c | 49 ++++++ fs/notify/inode_mark.c | 329 ++++++++++++++++++++++++++++++++++++++ include/linux/fs.h | 5 + include/linux/fsnotify.h | 8 + include/linux/fsnotify_backend.h | 65 +++++++- 9 files changed, 482 insertions(+), 3 deletions(-) create mode 100644 fs/notify/inode_mark.c
fs/inode.c +9 -0
@@ -22,6 +22,7 @@#include <linux/cdev.h> #include <linux/bootmem.h> #include <linux/inotify.h> +#include <linux/fsnotify.h> #include <linux/mount.h> #include <linux/async.h>
@@ -189,6 +190,10 @@ struct inode *inode_init_always(struct super_block *sb, struct inode *inode) inode->i_private =NULL ; inode->i_mapping = mapping; +#ifdef CONFIG_FSNOTIFY + inode->i_fsnotify_mask =0 ; +#endif +return inode; out_free_security:
@@ -220,6 +225,7 @@ void destroy_inode(struct inode *inode) {BUG_ON (inode_has_buffers (inode));security_inode_free (inode); +fsnotify_inode_delete (inode);if (inode->i_sb->s_op->destroy_inode) inode->i_sb->s_op->destroy_inode (inode);else
@@ -251,6 +257,9 @@ void inode_init_once(struct inode *inode)INIT_LIST_HEAD (&inode->inotify_watches);mutex_init (&inode->inotify_mutex);#endif +#ifdef CONFIG_FSNOTIFY +INIT_HLIST_HEAD (&inode->i_fsnotify_mark_entries); +#endif }EXPORT_SYMBOL (inode_init_once);
fs/notify/Makefile +1 -1
@@ -1,4 +1,4 @@ -obj-$(CONFIG_FSNOTIFY) += fsnotify.o notification.o group.o +obj-$(CONFIG_FSNOTIFY) += fsnotify.o notification.o group.o inode_mark.o obj-y += dnotify/ obj-y += inotify/
fs/notify/fsnotify.c +13 -0
@@ -26,6 +26,15 @@#include "fsnotify.h" /* +* Clear all of the marks on an inode when it is being evicted from core +*/ +void __fsnotify_inode_delete (struct inode *inode) +{ +fsnotify_clear_marks_by_inode (inode); +} +EXPORT_SYMBOL_GPL (__fsnotify_inode_delete); + +/* * This is the main call to fsnotify. The VFS calls into hook specific functions * in linux/fsnotify.h. Those functions then in turn call here. Here will call * out to all of the registered fsnotify_group. Those groups can then use the
@@ -43,6 +52,8 @@ void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is)if (!(mask & fsnotify_mask))return ; +if (!(mask & to_tell->i_fsnotify_mask)) +return ;/* * SRCU!! the groups list is very very much read only and the path is * very hot. The VAST majority of events are not going to need to do
@@ -51,6 +62,8 @@ void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is) idx =srcu_read_lock (&fsnotify_grp_srcu);list_for_each_entry_rcu (group, &fsnotify_groups, group_list) {if (mask & group->mask) { +if (!group->ops->should_send_event (group, to_tell, mask)) +continue ;if (!event) { event =fsnotify_create_event (to_tell, mask, data, data_is);/* shit, we OOM'd and now we can't tell, maybe
fs/notify/fsnotify.h +5 -0
@@ -12,4 +12,9 @@ extern struct srcu_struct fsnotify_grp_srcu;extern struct list_head fsnotify_groups;/* all bitwise OR of all event types (FS_*) for all fsnotify_groups */ extern __u32 fsnotify_mask; + +/* final kfree of a group */ +extern void fsnotify_final_destroy_group (struct fsnotify_group *group); +/* run the list of all marks associated with inode and flag them to be freed */ +extern void fsnotify_clear_marks_by_inode (struct inode *inode);#endif /* __FS_NOTIFY_FSNOTIFY_H_ */
fs/notify/group.c +48 -1
79 lines not on this page · raw message
fs/notify/inode_mark.c new file +329 -0
329 lines not on this page · raw message
include/linux/fs.h +5 -0
@@ -755,6 +755,11 @@ struct inode {__u32 i_generation; +#ifdef CONFIG_FSNOTIFY +__u32 i_fsnotify_mask;/* all events this inode cares about */ +struct hlist_head i_fsnotify_mark_entries;/* fsnotify mark entries */ +#endif +#ifdef CONFIG_DNOTIFY unsigned long i_dnotify_mask;/* Directory notify events */ struct dnotify_struct *i_dnotify;/* for directory notifications */
include/linux/fsnotify.h +8 -0
@@ -100,6 +100,14 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir, }/* +* 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_nameremove - a filename was removed from a directory */ static inline void fsnotify_nameremove (struct dentry *dentry,int isdir)
include/linux/fsnotify_backend.h +64 -1
118 lines not on this page · raw message
PATCH 4/12 fsnotify: parent event notification
In reply to Eric Parisinotify and dnotify both use a similar parent notification mechanism. We add a generic parent notification mechanism to fsnotify for both of these to use. This new machanism also adds the dentry flag optimization which exists for inotify to dnotify.
---
fs/notify/fsnotify.c | 91 ++++++++++++++++++++++++++++++++++++++ fs/notify/fsnotify.h | 5 ++ fs/notify/inode_mark.c | 17 +++++++ include/linux/dcache.h | 3 + include/linux/fsnotify.h | 34 ++++++++++---- include/linux/fsnotify_backend.h | 64 +++++++++++++++++++++++++++ 6 files changed, 204 insertions(+), 10 deletions(-)
fs/notify/fsnotify.c +91 -0
@@ -35,6 +35,97 @@ void __fsnotify_inode_delete(struct inode *inode)EXPORT_SYMBOL_GPL (__fsnotify_inode_delete);/* +* Given an inode, first check if we care what happens to our children. Inotify +* and dnotify both tell their parents about events. If we care about any event +* on a child we run all of our children and set a dentry flag saying that the +* parent cares. Thus when an event happens on a child it can quickly tell if +* if there is a need to find a parent and send the event to the parent. +*/ +void __fsnotify_update_child_dentry_flags (struct inode *inode) +{ +struct dentry *alias; +int watched; + +if (!S_ISDIR (inode->i_mode)) +return ; + +/* determine if the children should tell inode about their events */ + watched =fsnotify_inode_watches_children (inode); + +spin_lock (&dcache_lock); +/* run all of the dentries associated with this inode. Since this is a +* directory, there damn well better only be one item on this list */ +list_for_each_entry (alias, &inode->i_dentry, d_alias) { +struct dentry *child; + +/* run all of the children of the original inode and fix their +* d_flags to indicate parental interest (their parent is the +* original inode) */ +list_for_each_entry (child, &alias->d_subdirs, d_u.d_child) { +if (!child->d_inode) +continue ; + +spin_lock (&child->d_lock); +if (watched) + child->d_flags |=DCACHE_FSNOTIFY_PARENT_WATCHED ; +else + child->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED ; +spin_unlock (&child->d_lock); + } + } +spin_unlock (&dcache_lock); +} + +/* Notify this dentry's parent about a child's events. */ +void __fsnotify_parent (struct dentry *dentry,__u32 mask) +{ +struct dentry *parent; +struct inode *p_inode; +bool send = false; +bool should_update_children = false; + +if (!(dentry->d_flags |DCACHE_FSNOTIFY_PARENT_WATCHED )) +return ; + +spin_lock (&dentry->d_lock); + parent = dentry->d_parent; + p_inode = parent->d_inode; + +if (fsnotify_inode_watches_children (p_inode)) { +if (p_inode->i_fsnotify_mask & mask) { +dget (parent); + send = true; + } + }else { +/* +* The parent doesn't care about events on it's children but +* at least one child thought it did. We need to run all the +* children and update their d_flags to let them know p_inode +* doesn't care about them any more. +*/ +dget (parent); + should_update_children = true; + } + +spin_unlock (&dentry->d_lock); + +if (send) { +/* we are notifying a parent so come up with the new mask which +* specifies these are events which came from a child. */ + mask |=FS_EVENT_ON_CHILD ; + +fsnotify (p_inode, mask, dentry->d_inode,FSNOTIFY_EVENT_INODE ); +dput (parent); + } + +if (unlikely (should_update_children)) { +__fsnotify_update_child_dentry_flags (p_inode); +dput (parent); + } +} +EXPORT_SYMBOL_GPL (__fsnotify_parent); + +/* * This is the main call to fsnotify. The VFS calls into hook specific functions * in linux/fsnotify.h. Those functions then in turn call here. Here will call * out to all of the registered fsnotify_group. Those groups can then use the
fs/notify/fsnotify.h +5 -0
@@ -17,4 +17,9 @@ extern __u32 fsnotify_mask;extern void fsnotify_final_destroy_group (struct fsnotify_group *group);/* run the list of all marks associated with inode and flag them to be freed */ extern void fsnotify_clear_marks_by_inode (struct inode *inode); +/* +* update the dentry->d_flags of all of inode's children to indicate if inode cares +* about events that happen to its children. +*/ +extern void __fsnotify_update_child_dentry_flags (struct inode *inode);#endif /* __FS_NOTIFY_FSNOTIFY_H_ */
fs/notify/inode_mark.c +17 -0
@@ -131,6 +131,8 @@ void fsnotify_recalc_inode_mask(struct inode *inode)spin_lock (&inode->i_lock);fsnotify_recalc_inode_mask_locked (inode);spin_unlock (&inode->i_lock); + +__fsnotify_update_child_dentry_flags (inode); }/*
@@ -190,6 +192,19 @@ void fsnotify_destroy_mark_by_entry(struct fsnotify_mark_entry *entry) group->ops->freeing_mark (entry, group);/* +* __fsnotify_update_child_dentry_flags(inode); +* +* I really want to call that, but we can't, we have no idea if the inode +* still exists the second we drop the entry->lock. +* +* The next time an event arrive to this inode from one of it's children +* __fsnotify_parent will see that the inode doesn't care about it's +* children and will update all of these flags then. So really this +* is just a lazy update (and could be a perf win...) +*/ + + +/* * it's possible that this group tried to destroy itself, but this * this mark was simultaneously being freed by inode. If that's the * case, we finish freeing the group here.
@@ -323,6 +338,8 @@ int fsnotify_add_mark(struct fsnotify_mark_entry *entry,if (lentry) { ret = -EEXIST ;fsnotify_put_mark (lentry); + }else { +__fsnotify_update_child_dentry_flags (inode); }return ret;
include/linux/dcache.h +2 -1
@@ -180,7 +180,8 @@ d_iput: no no no yes#define DCACHE_REFERENCED 0x0008/* Recently used, don't discard. */ #define DCACHE_UNHASHED 0x0010 -#define DCACHE_INOTIFY_PARENT_WATCHED 0x0020/* Parent inode is watched */ +#define DCACHE_INOTIFY_PARENT_WATCHED 0x0020/* Parent inode is watched by inotify */ +#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x0040/* Parent inode is watched by some fsnotify listener */ #define DCACHE_COOKIE 0x0040/* For use by dcookie subsystem */
include/linux/fsnotify.h +25 -9
@@ -23,15 +23,31 @@static inline void fsnotify_d_instantiate (struct dentry *entry,struct inode *inode) { +__fsnotify_d_instantiate (entry, inode); +inotify_d_instantiate (entry, inode); } +/* Notify this dentry's parent about a child's events. */ +static inline void fsnotify_parent (struct dentry *dentry,__u32 mask) +{ +__fsnotify_parent (dentry, mask); + +inotify_dentry_parent_queue_event (dentry, mask,0 , dentry->d_name.name); +} +/* * fsnotify_d_move - entry has been moved * Called with dcache_lock and entry->d_lock held. */ static inline void fsnotify_d_move (struct dentry *entry) { +/* +* On move we need to update entry->d_flags to indicate if the new parent +* cares about events from this entry. +*/ +__fsnotify_update_dcache_flags (entry); +inotify_d_move (entry); }
@@ -117,7 +133,8 @@ static inline void fsnotify_nameremove(struct dentry *dentry, int isdir)if (isdir) mask |=FS_IN_ISDIR ;dnotify_parent (dentry,DN_DELETE ); -inotify_dentry_parent_queue_event (dentry, mask,0 , dentry->d_name.name); + +fsnotify_parent (dentry, mask); }/*
@@ -187,9 +204,9 @@ static inline void fsnotify_access(struct dentry *dentry) mask |=FS_IN_ISDIR ;dnotify_parent (dentry,DN_ACCESS ); -inotify_dentry_parent_queue_event (dentry, mask,0 , dentry->d_name.name);inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL ); +fsnotify_parent (dentry, mask);fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ); }
@@ -205,9 +222,9 @@ static inline void fsnotify_modify(struct dentry *dentry) mask |=FS_IN_ISDIR ;dnotify_parent (dentry,DN_MODIFY ); -inotify_dentry_parent_queue_event (dentry, mask,0 , dentry->d_name.name);inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL ); +fsnotify_parent (dentry, mask);fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ); }
@@ -222,9 +239,9 @@ static inline void fsnotify_open(struct dentry *dentry)if (S_ISDIR (inode->i_mode)) mask |=FS_IN_ISDIR ; -inotify_dentry_parent_queue_event (dentry, mask,0 , dentry->d_name.name);inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL ); +fsnotify_parent (dentry, mask);fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ); }
@@ -235,16 +252,15 @@ static inline void fsnotify_close(struct file *file) {struct dentry *dentry = file->f_path.dentry;struct inode *inode = dentry->d_inode; -const char *name = dentry->d_name.name;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_IN_ISDIR ; -inotify_dentry_parent_queue_event (dentry, mask,0 , name);inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL ); +fsnotify_parent (dentry, mask);fsnotify (inode, mask, file,FSNOTIFY_EVENT_FILE ); }
@@ -259,9 +275,9 @@ static inline void fsnotify_xattr(struct dentry *dentry)if (S_ISDIR (inode->i_mode)) mask |=FS_IN_ISDIR ; -inotify_dentry_parent_queue_event (dentry, mask,0 , dentry->d_name.name);inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL ); +fsnotify_parent (dentry, mask);fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ); }
@@ -310,8 +326,8 @@ static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)if (S_ISDIR (inode->i_mode)) in_mask |=FS_IN_ISDIR ;inotify_inode_queue_event (inode, in_mask,0 ,NULL ,NULL ); -inotify_dentry_parent_queue_event (dentry, in_mask,0 , - dentry->d_name.name); + +fsnotify_parent (dentry, in_mask);fsnotify (inode, in_mask, inode,FSNOTIFY_EVENT_INODE ); } }
include/linux/fsnotify_backend.h +64 -0
87 lines not on this page · raw message
PATCH 5/12 dnotify: reimplement dnotify using fsnotify
In reply to Eric ParisReimplement dnotify using fsnotify.
---
MAINTAINERS | 2 fs/notify/dnotify/Kconfig | 1 fs/notify/dnotify/dnotify.c | 469 +++++++++++++++++++++++++++++--------- include/linux/dnotify.h | 29 +- include/linux/fs.h | 5 include/linux/fsnotify.h | 68 ++---- include/linux/fsnotify_backend.h | 3 7 files changed, 397 insertions(+), 180 deletions(-)
MAINTAINERS +2 -0
@@ -1792,6 +1792,8 @@ F: drivers/char/digi* DIRECTORY NOTIFICATION (DNOTIFY) P: Stephen Rothwell M: [email protected] +P: Eric Paris +M: [email protected] L: [email protected] S: Supported F: Documentation/filesystems/dnotify.txt
fs/notify/dnotify/Kconfig +1 -0
@@ -1,5 +1,6 @@ config DNOTIFY bool "Dnotify support" + depends on FSNOTIFY default y help Dnotify is a directory-based per-fd file change notification system
fs/notify/dnotify/dnotify.c +362 -107
537 lines not on this page · raw message
include/linux/dnotify.h +8 -21
@@ -10,7 +10,7 @@struct dnotify_struct {struct dnotify_struct * dn_next; -unsigned long dn_mask; +__u32 dn_mask;int dn_fd;struct file * dn_filp;fl_owner_t dn_owner;
@@ -21,23 +21,18 @@ struct dnotify_struct {#ifdef CONFIG_DNOTIFY -extern void __inode_dir_notify (struct inode *,unsigned long ); +#define DNOTIFY_ALL_EVENTS (FS_DELETE | FS_DELETE_CHILD |\ + FS_MODIFY | FS_MODIFY_CHILD |\ + FS_ACCESS | FS_ACCESS_CHILD |\ + FS_ATTRIB | FS_ATTRIB_CHILD |\ + FS_CREATE | FS_DN_RENAME |\ + FS_MOVED_FROM | FS_MOVED_TO) +extern void dnotify_flush (struct file *,fl_owner_t );extern int fcntl_dirnotify (int ,struct file *,unsigned long ); -extern void dnotify_parent (struct dentry *,unsigned long ); - -static inline void inode_dir_notify (struct inode *inode,unsigned long event) -{ -if (inode->i_dnotify_mask & (event)) -__inode_dir_notify (inode, event); -}#else -static inline void __inode_dir_notify (struct inode *inode,unsigned long event) -{ -} -static inline void dnotify_flush (struct file *filp,fl_owner_t id) { }
@@ -47,14 +42,6 @@ static inline int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)return -EINVAL ; } -static inline void dnotify_parent (struct dentry *dentry,unsigned long event) -{ -} - -static inline void inode_dir_notify (struct inode *inode,unsigned long event) -{ -} -#endif /* CONFIG_DNOTIFY */ #endif /* __KERNEL __ */
include/linux/fs.h +0 -5
@@ -760,11 +760,6 @@ struct inode {struct hlist_head i_fsnotify_mark_entries;/* fsnotify mark entries */ #endif -#ifdef CONFIG_DNOTIFY -unsigned long i_dnotify_mask;/* Directory notify events */ -struct dnotify_struct *i_dnotify;/* for directory notifications */ -#endif -#ifdef CONFIG_INOTIFY struct list_head inotify_watches;/* watches on this inode */ struct mutex inotify_mutex;/* protects the watches list */
include/linux/fsnotify.h +21 -47
123 lines not on this page · raw message
include/linux/fsnotify_backend.h +3 -0
@@ -57,6 +57,9 @@ FS_MOVED_FROM | FS_MOVED_TO | FS_CREATE |\ FS_DELETE) +/* listeners that hard code group numbers near the top */ +#define DNOTIFY_GROUP_NUM UINT_MAX +struct fsnotify_group ;struct fsnotify_event ;struct fsnotify_mark_entry ;
Re: [PATCH 05/12] dnotify: reimplement dnotify using fsnotify
Hi Eric,
MAINTAINERS F: drivers/char/digi* · line 1796
Quoted 9 lines · On Mon, 27 Apr 2009 17:53:28 -0400 Eric Paris <[email protected]> wrote:
MAINTAINERS +2
-0@@ -1792,6 +1792,8 @@ F: drivers/char/digi* DIRECTORY NOTIFICATION (DNOTIFY) P: Stephen Rothwell M: [email protected] +P: Eric Paris +M: [email protected]
At this point, you might as well remove me as a maintainer of dnotify.
Signature · 3 lines
Cheers, Stephen Rothwell [email protected] http://www.canb.auug.org.au/~sfr/
PATCH 6/12 fsnotify: generic notification queue and waitq
In reply to Eric Parisinotify needs to do asyc notification in which event information is stored on a queue until the listener is ready to receive it. This patch implements a generic notification queue for inotify (and later fanotify) to store events to be sent at a later time.
---
fs/notify/fsnotify.h | 9 + fs/notify/group.c | 9 + fs/notify/notification.c | 230 +++++++++++++++++++++++++++++++++++++- include/linux/fsnotify_backend.h | 37 ++++++ 4 files changed, 278 insertions(+), 7 deletions(-)
fs/notify/fsnotify.h +9 -0
@@ -13,8 +13,12 @@ extern struct list_head fsnotify_groups;/* all bitwise OR of all event types (FS_*) for all fsnotify_groups */ extern __u32 fsnotify_mask; +/* destroy all events sitting in this groups notification queue */ +extern void fsnotify_flush_notify (struct fsnotify_group *group); +/* final kfree of a group */ extern void fsnotify_final_destroy_group (struct fsnotify_group *group); +/* run the list of all marks associated with inode and flag them to be freed */ extern void fsnotify_clear_marks_by_inode (struct inode *inode);/*
@@ -22,4 +26,9 @@ extern void fsnotify_clear_marks_by_inode(struct inode *inode);* about events that happen to its children. */ extern void __fsnotify_update_child_dentry_flags (struct inode *inode); + +/* allocate and destroy and event holder to attach events to notification/access queues */ +extern struct fsnotify_event_holder *fsnotify_alloc_event_holder (void ); +extern void fsnotify_destroy_event_holder (struct fsnotify_event_holder *holder); +#endif /* __FS_NOTIFY_FSNOTIFY_H_ */
fs/notify/group.c +9 -0
@@ -91,6 +91,9 @@ static void fsnotify_get_group(struct fsnotify_group *group)*/ void fsnotify_final_destroy_group (struct fsnotify_group *group) { +/* clear the notification queue of all events */ +fsnotify_flush_notify (group); +if (group->ops->free_group_priv) group->ops->free_group_priv (group);
@@ -214,6 +217,12 @@ struct fsnotify_group *fsnotify_obtain_group(unsigned int group_num, __u32 mask, group->group_num = group_num; group->mask = mask; +mutex_init (&group->notification_mutex); +INIT_LIST_HEAD (&group->notification_list); +init_waitqueue_head (&group->notification_waitq); + group->q_len =0 ; + group->max_events =UINT_MAX ; +spin_lock_init (&group->mark_lock);atomic_set (&group->num_marks,0 );INIT_LIST_HEAD (&group->mark_entries);
fs/notify/notification.c +223 -7
267 lines not on this page · raw message
include/linux/fsnotify_backend.h +37 -0
@@ -119,6 +119,13 @@ struct fsnotify_group {const struct fsnotify_ops *ops;/* how this group handles things */ +/* needed to send notification to userspace */ +struct mutex notification_mutex;/* protect the notification_list */ +struct list_head notification_list;/* list of event_holder this group needs to send to userspace */ +wait_queue_head_t notification_waitq;/* read() on the notification file blocks on this waitq */ +unsigned int q_len;/* events on the queue */ +unsigned int max_events;/* maximum events allowed on the list */ +/* stores all fastapth entries assoc with this group so they can be cleaned on unregister */ spinlock_t mark_lock;/* protect mark_entries list */ atomic_t num_marks;/* 1 for each mark entry and 1 for not being
@@ -136,11 +143,32 @@ struct fsnotify_group { };/* +* A single event can be queued in multiple group->notification_lists. +* +* each group->notification_list will point to an event_holder which in turns points +* to the actual event that needs to be sent to userspace. +* +* Seemed cheaper to create a refcnt'd event and a small holder for every group +* than create a different event for every group +* +*/ +struct fsnotify_event_holder { +struct fsnotify_event *event; +struct list_head event_list; +}; + +/* * all of the information about the original object we want to now send to * a group. If you want to carry more info from the accessing task to the * listener this structure is where you need to be adding fields. */ struct fsnotify_event { +/* +* If we create an event we are also likely going to need a holder +* to link to a group. So embed one holder in the event. Means only +* one allocation for the common case where we only have one group +*/ +struct fsnotify_event_holder holder;spinlock_t lock;/* protection for the associated event_holder and private_list */ /* to_tell may ONLY be dereferenced during handle_event(). */ struct inode *to_tell;/* either the inode the event happened to or its parent */
@@ -264,6 +292,15 @@ extern void fsnotify_put_event(struct fsnotify_event *event);extern struct fsnotify_event_private_data *fsnotify_get_priv_from_event (struct fsnotify_group *group,struct fsnotify_event *event); +/* attach the event to the group notification queue */ +extern int fsnotify_add_notify_event (struct fsnotify_group *group,struct fsnotify_event *event); +/* true if the group notification queue is empty */ +extern bool fsnotify_notify_queue_is_empty (struct fsnotify_group *group); +/* return, but do not dequeue the first event on the notification queue */ +extern struct fsnotify_event *fsnotify_peek_notify_event (struct fsnotify_group *group); +/* reutnr AND dequeue the first event on the notification queue */ +extern struct fsnotify_event *fsnotify_remove_notify_event (struct fsnotify_group *group); +/* functions used to manipulate the marks attached to inodes */ /* run all marks associated with an inode and update inode->i_fsnotify_mask */
PATCH 7/12 fsnotify: include pathnames with entries when possible
In reply to Eric ParisWhen inotify wants to send events to a directory about a child it includes the name of the original file. This patch collects that filename and makes it available for notification.
---
fs/notify/fsnotify.c | 7 ++++--- fs/notify/notification.c | 16 ++++++++++++++- include/linux/fsnotify.h | 40 +++++++++++++++++++++++++------------- include/linux/fsnotify_backend.h | 11 ++++++++-- 4 files changed, 53 insertions(+), 21 deletions(-)
fs/notify/fsnotify.c +4 -3
@@ -114,7 +114,8 @@ void __fsnotify_parent(struct dentry *dentry, __u32 mask)* specifies these are events which came from a child. */ mask |=FS_EVENT_ON_CHILD ; -fsnotify (p_inode, mask, dentry->d_inode,FSNOTIFY_EVENT_INODE ); +fsnotify (p_inode, mask, dentry->d_inode,FSNOTIFY_EVENT_INODE , + dentry->d_name.name);dput (parent); }
@@ -131,7 +132,7 @@ EXPORT_SYMBOL_GPL(__fsnotify_parent);* out to all of the registered fsnotify_group. Those groups can then use the * notification event in whatever means they feel necessary. */ -void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is) +void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is,const char *file_name) {struct fsnotify_group *group;struct fsnotify_event *event =NULL ;
@@ -156,7 +157,7 @@ void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is)if (!group->ops->should_send_event (group, to_tell, mask))continue ;if (!event) { - event =fsnotify_create_event (to_tell, mask, data, data_is); + event =fsnotify_create_event (to_tell, mask, data, data_is, file_name);/* shit, we OOM'd and now we can't tell, maybe * someday someone else will want to do something * here */
fs/notify/notification.c +15 -1
@@ -78,6 +78,7 @@ void fsnotify_put_event(struct fsnotify_event *event)if (event->data_type ==FSNOTIFY_EVENT_PATH )path_put (&event->path); +kfree (event->file_name);kmem_cache_free (fsnotify_event_cachep, event); } }
@@ -262,6 +263,9 @@ static void initialize_event(struct fsnotify_event *event) event->data_type =FSNOTIFY_EVENT_NONE ; event->to_tell =NULL ; + + event->file_name =NULL ; + event->name_len =0 ; }/*
@@ -274,9 +278,10 @@ static void initialize_event(struct fsnotify_event *event)* @mask what actually happened. * @data pointer to the object which was actually affected * @data_type flag indication if the data is a file, path, inode, nothing... +* @name the filename, if available */ struct fsnotify_event *fsnotify_create_event (struct inode *to_tell,__u32 mask, -void *data,int data_type) +void *data,int data_type,const char *name) {struct fsnotify_event *event;
@@ -285,6 +290,15 @@ struct fsnotify_event *fsnotify_create_event(struct inode *to_tell, __u32 mask,return NULL ;initialize_event (event); + +if (name) { + event->file_name =kstrdup (name,GFP_KERNEL ); +if (!event->file_name) { +kmem_cache_free (fsnotify_event_cachep, event); +return NULL ; + } + event->name_len =strlen (event->file_name); + } event->to_tell = to_tell;switch (data_type) {
include/linux/fsnotify.h +26 -14
@@ -58,7 +58,19 @@ static inline void fsnotify_link_count(struct inode *inode) {inotify_inode_queue_event (inode,IN_ATTRIB ,0 ,NULL ,NULL ); -fsnotify (inode,FS_ATTRIB , inode,FSNOTIFY_EVENT_INODE ); +fsnotify (inode,FS_ATTRIB , inode,FSNOTIFY_EVENT_INODE ,NULL ); +} + +/* +* fsnotify_inode_remove - an inode is going away +*/ +static inline void fsnotify_inode_remove (struct inode *inode) +{ +inotify_inode_queue_event (inode,IN_DELETE_SELF ,0 ,NULL ,NULL ); +inotify_inode_is_dead (inode); + +fsnotify (inode,FS_DELETE_SELF , inode,FSNOTIFY_EVENT_INODE ,NULL ); +__fsnotify_inode_delete (inode); }/*
@@ -91,8 +103,8 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,inotify_inode_queue_event (new_dir,IN_MOVED_TO |isdir, cookie, new_name, source); -fsnotify (old_dir, old_dir_mask, old_dir,FSNOTIFY_EVENT_INODE ); -fsnotify (new_dir, new_dir_mask, new_dir,FSNOTIFY_EVENT_INODE ); +fsnotify (old_dir, old_dir_mask, old_dir,FSNOTIFY_EVENT_INODE , old_name); +fsnotify (new_dir, new_dir_mask, new_dir,FSNOTIFY_EVENT_INODE , new_name);if (target) {inotify_inode_queue_event (target,IN_DELETE_SELF ,0 ,NULL ,NULL );
@@ -104,7 +116,7 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,if (source) {inotify_inode_queue_event (source,IN_MOVE_SELF ,0 ,NULL ,NULL ); -fsnotify (source,FS_MOVE_SELF , moved->d_inode,FSNOTIFY_EVENT_INODE ); +fsnotify (source,FS_MOVE_SELF , moved->d_inode,FSNOTIFY_EVENT_INODE ,NULL ); }audit_inode_child (new_name, moved, new_dir); }
@@ -138,7 +150,7 @@ static inline void fsnotify_inoderemove(struct inode *inode)inotify_inode_queue_event (inode,IN_DELETE_SELF ,0 ,NULL ,NULL );inotify_inode_is_dead (inode); -fsnotify (inode,FS_DELETE_SELF , inode,FSNOTIFY_EVENT_INODE ); +fsnotify (inode,FS_DELETE_SELF , inode,FSNOTIFY_EVENT_INODE ,NULL ); }/*
@@ -150,7 +162,7 @@ static inline void fsnotify_create(struct inode *inode, struct dentry *dentry) dentry->d_inode);audit_inode_child (dentry->d_name.name, dentry, inode); -fsnotify (inode,FS_CREATE , dentry->d_inode,FSNOTIFY_EVENT_INODE ); +fsnotify (inode,FS_CREATE , dentry->d_inode,FSNOTIFY_EVENT_INODE , dentry->d_name.name); }/*
@@ -165,7 +177,7 @@ static inline void fsnotify_link(struct inode *dir, struct inode *inode, structfsnotify_link_count (inode);audit_inode_child (new_dentry->d_name.name, new_dentry, dir); -fsnotify (dir,FS_CREATE , inode,FSNOTIFY_EVENT_INODE ); +fsnotify (dir,FS_CREATE , inode,FSNOTIFY_EVENT_INODE , new_dentry->d_name.name); }/*
@@ -179,7 +191,7 @@ static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)inotify_inode_queue_event (inode, mask,0 , dentry->d_name.name, d_inode);audit_inode_child (dentry->d_name.name, dentry, inode); -fsnotify (inode, mask, d_inode,FSNOTIFY_EVENT_INODE ); +fsnotify (inode, mask, d_inode,FSNOTIFY_EVENT_INODE , dentry->d_name.name); }/*
@@ -196,7 +208,7 @@ static inline void fsnotify_access(struct dentry *dentry)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ); +fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ); }/*
@@ -213,7 +225,7 @@ static inline void fsnotify_modify(struct dentry *dentry)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ); +fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ); }/*
@@ -230,7 +242,7 @@ static inline void fsnotify_open(struct dentry *dentry)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ); +fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ); }/*
@@ -249,7 +261,7 @@ static inline void fsnotify_close(struct file *file)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, file,FSNOTIFY_EVENT_FILE ); +fsnotify (inode, mask, file,FSNOTIFY_EVENT_FILE ,NULL ); }/*
@@ -266,7 +278,7 @@ static inline void fsnotify_xattr(struct dentry *dentry)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ); +fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ); }/*
@@ -302,7 +314,7 @@ static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ); +fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ); } }
include/linux/fsnotify_backend.h +8 -3
@@ -192,6 +192,9 @@ struct fsnotify_event {int data_type;/* which of the above union we have */ atomic_t refcnt;/* how many groups still are using/need to send this event */ __u32 mask;/* the type of access, bitwise OR for FS_* event types */ + +char *file_name; +size_t name_len; };/*
@@ -224,7 +227,7 @@ struct fsnotify_mark_entry {/* called from the vfs helpers */ /* main fsnotify call to send events */ -extern void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is); +extern void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is,const char *name);extern void __fsnotify_parent (struct dentry *dentry,__u32 mask);extern void __fsnotify_inode_delete (struct inode *inode);
@@ -319,10 +322,12 @@ extern void fsnotify_put_mark(struct fsnotify_mark_entry *entry);/* put here because inotify does some weird stuff when destroying watches */ extern struct fsnotify_event *fsnotify_create_event (struct inode *to_tell,__u32 mask, -void *data,int data_is); +void *data,int data_is,const char *name); +#else -static inline void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is) +static inline void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is, +const char *name); {}static inline void __fsnotify_parent (struct dentry *dentry,__u32 mask)
PATCH 8/12 fsnotify: add correlations between events
In reply to Eric ParisAs part of the standard inotify events it includes a correlation cookie between two dentry move operations. This patch includes the same behaviour in fsnotify events. It is needed so that inotify userspace can be implemented on top of fsnotify.
---
fs/notify/fsnotify.c | 6 +++--- fs/notify/notification.c | 20 ++++++++++++++++++-- include/linux/fsnotify.h | 37 +++++++++++++++++++------------------ include/linux/fsnotify_backend.h | 15 ++++++++++++--- 4 files changed, 52 insertions(+), 26 deletions(-)
fs/notify/fsnotify.c +3 -3
@@ -115,7 +115,7 @@ void __fsnotify_parent(struct dentry *dentry, __u32 mask) mask |=FS_EVENT_ON_CHILD ;fsnotify (p_inode, mask, dentry->d_inode,FSNOTIFY_EVENT_INODE , - dentry->d_name.name); + dentry->d_name.name,0 );dput (parent); }
@@ -132,7 +132,7 @@ EXPORT_SYMBOL_GPL(__fsnotify_parent);* out to all of the registered fsnotify_group. Those groups can then use the * notification event in whatever means they feel necessary. */ -void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is,const char *file_name) +void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is,const char *file_name,u32 cookie) {struct fsnotify_group *group;struct fsnotify_event *event =NULL ;
@@ -157,7 +157,7 @@ void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is, constif (!group->ops->should_send_event (group, to_tell, mask))continue ;if (!event) { - event =fsnotify_create_event (to_tell, mask, data, data_is, file_name); + event =fsnotify_create_event (to_tell, mask, data, data_is, file_name, cookie);/* shit, we OOM'd and now we can't tell, maybe * someday someone else will want to do something * here */
fs/notify/notification.c +18 -2
@@ -35,6 +35,7 @@#include <linux/init.h> #include <linux/kernel.h> #include <linux/list.h> +#include <linux/module.h> #include <linux/mount.h> #include <linux/mutex.h> #include <linux/namei.h>
@@ -56,6 +57,17 @@ static struct kmem_cache *fsnotify_event_holder_cachep;* get set to 0 so it will never get 'freed' */ static struct fsnotify_event q_overflow_event; +static atomic_t fsnotify_sync_cookie =ATOMIC_INIT (0 ); + +/** +* fsnotify_get_cookie - return a unique cookie for use in synchronizing events. +* Called from fsnotify_move, which is inlined into filesystem modules. +*/ +u32 fsnotify_get_cookie (void ) +{ +return atomic_inc_return (&fsnotify_sync_cookie); +} +EXPORT_SYMBOL_GPL (fsnotify_get_cookie);/* return true if the notify queue is empty, false otherwise */ bool fsnotify_notify_queue_is_empty (struct fsnotify_group *group)
@@ -266,6 +278,8 @@ static void initialize_event(struct fsnotify_event *event) event->file_name =NULL ; event->name_len =0 ; + + event->sync_cookie =0 ; }/*
@@ -280,8 +294,8 @@ static void initialize_event(struct fsnotify_event *event)* @data_type flag indication if the data is a file, path, inode, nothing... * @name the filename, if available */ -struct fsnotify_event *fsnotify_create_event (struct inode *to_tell,__u32 mask, -void *data,int data_type,const char *name) +struct fsnotify_event *fsnotify_create_event (struct inode *to_tell,__u32 mask,void *data, +int data_type,const char *name,u32 cookie) {struct fsnotify_event *event;
@@ -299,6 +313,8 @@ struct fsnotify_event *fsnotify_create_event(struct inode *to_tell, __u32 mask, } event->name_len =strlen (event->file_name); } + + event->sync_cookie = cookie; event->to_tell = to_tell;switch (data_type) {
include/linux/fsnotify.h +19 -18
@@ -58,7 +58,7 @@ static inline void fsnotify_link_count(struct inode *inode) {inotify_inode_queue_event (inode,IN_ATTRIB ,0 ,NULL ,NULL ); -fsnotify (inode,FS_ATTRIB , inode,FSNOTIFY_EVENT_INODE ,NULL ); +fsnotify (inode,FS_ATTRIB , inode,FSNOTIFY_EVENT_INODE ,NULL ,0 ); }/*
@@ -69,7 +69,7 @@ static inline void fsnotify_inode_remove(struct inode *inode)inotify_inode_queue_event (inode,IN_DELETE_SELF ,0 ,NULL ,NULL );inotify_inode_is_dead (inode); -fsnotify (inode,FS_DELETE_SELF , inode,FSNOTIFY_EVENT_INODE ,NULL ); +fsnotify (inode,FS_DELETE_SELF , inode,FSNOTIFY_EVENT_INODE ,NULL ,0 );__fsnotify_inode_delete (inode); }
@@ -81,7 +81,8 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir, int isdir, struct inode *target, struct dentry *moved) { struct inode *source = moved->d_inode; -u32 cookie =inotify_get_cookie (); +u32 in_cookie =inotify_get_cookie (); +u32 fs_cookie =fsnotify_get_cookie ();__u32 old_dir_mask =0 ;__u32 new_dir_mask =0 ;
@@ -98,13 +99,13 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir, old_dir_mask |=FS_MOVED_FROM ; new_dir_mask |=FS_MOVED_TO ; -inotify_inode_queue_event (old_dir,IN_MOVED_FROM |isdir,cookie,old_name, +inotify_inode_queue_event (old_dir,IN_MOVED_FROM |isdir, in_cookie, old_name, source); -inotify_inode_queue_event (new_dir,IN_MOVED_TO |isdir, cookie, new_name, +inotify_inode_queue_event (new_dir,IN_MOVED_TO |isdir, in_cookie, new_name, source); -fsnotify (old_dir, old_dir_mask, old_dir,FSNOTIFY_EVENT_INODE , old_name); -fsnotify (new_dir, new_dir_mask, new_dir,FSNOTIFY_EVENT_INODE , new_name); +fsnotify (old_dir, old_dir_mask, old_dir,FSNOTIFY_EVENT_INODE , old_name, fs_cookie); +fsnotify (new_dir, new_dir_mask, new_dir,FSNOTIFY_EVENT_INODE , new_name, fs_cookie);if (target) {inotify_inode_queue_event (target,IN_DELETE_SELF ,0 ,NULL ,NULL );
@@ -116,7 +117,7 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,if (source) {inotify_inode_queue_event (source,IN_MOVE_SELF ,0 ,NULL ,NULL ); -fsnotify (source,FS_MOVE_SELF , moved->d_inode,FSNOTIFY_EVENT_INODE ,NULL ); +fsnotify (source,FS_MOVE_SELF , moved->d_inode,FSNOTIFY_EVENT_INODE ,NULL ,0 ); }audit_inode_child (new_name, moved, new_dir); }
@@ -150,7 +151,7 @@ static inline void fsnotify_inoderemove(struct inode *inode)inotify_inode_queue_event (inode,IN_DELETE_SELF ,0 ,NULL ,NULL );inotify_inode_is_dead (inode); -fsnotify (inode,FS_DELETE_SELF , inode,FSNOTIFY_EVENT_INODE ,NULL ); +fsnotify (inode,FS_DELETE_SELF , inode,FSNOTIFY_EVENT_INODE ,NULL ,0 ); }/*
@@ -162,7 +163,7 @@ static inline void fsnotify_create(struct inode *inode, struct dentry *dentry) dentry->d_inode);audit_inode_child (dentry->d_name.name, dentry, inode); -fsnotify (inode,FS_CREATE , dentry->d_inode,FSNOTIFY_EVENT_INODE , dentry->d_name.name); +fsnotify (inode,FS_CREATE , dentry->d_inode,FSNOTIFY_EVENT_INODE , dentry->d_name.name,0 ); }/*
@@ -177,7 +178,7 @@ static inline void fsnotify_link(struct inode *dir, struct inode *inode, structfsnotify_link_count (inode);audit_inode_child (new_dentry->d_name.name, new_dentry, dir); -fsnotify (dir,FS_CREATE , inode,FSNOTIFY_EVENT_INODE , new_dentry->d_name.name); +fsnotify (dir,FS_CREATE , inode,FSNOTIFY_EVENT_INODE , new_dentry->d_name.name,0 ); }/*
@@ -191,7 +192,7 @@ static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)inotify_inode_queue_event (inode, mask,0 , dentry->d_name.name, d_inode);audit_inode_child (dentry->d_name.name, dentry, inode); -fsnotify (inode, mask, d_inode,FSNOTIFY_EVENT_INODE , dentry->d_name.name); +fsnotify (inode, mask, d_inode,FSNOTIFY_EVENT_INODE , dentry->d_name.name,0 ); }/*
@@ -208,7 +209,7 @@ static inline void fsnotify_access(struct dentry *dentry)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ); +fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ,0 ); }/*
@@ -225,7 +226,7 @@ static inline void fsnotify_modify(struct dentry *dentry)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ); +fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ,0 ); }/*
@@ -242,7 +243,7 @@ static inline void fsnotify_open(struct dentry *dentry)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ); +fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ,0 ); }/*
@@ -261,7 +262,7 @@ static inline void fsnotify_close(struct file *file)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, file,FSNOTIFY_EVENT_FILE ,NULL ); +fsnotify (inode, mask, file,FSNOTIFY_EVENT_FILE ,NULL ,0 ); }/*
@@ -278,7 +279,7 @@ static inline void fsnotify_xattr(struct dentry *dentry)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ); +fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ,0 ); }/*
@@ -314,7 +315,7 @@ static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)inotify_inode_queue_event (inode, mask,0 ,NULL ,NULL );fsnotify_parent (dentry, mask); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ); +fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ,0 ); } }
include/linux/fsnotify_backend.h +12 -3
@@ -193,6 +193,7 @@ struct fsnotify_event {atomic_t refcnt;/* how many groups still are using/need to send this event */ __u32 mask;/* the type of access, bitwise OR for FS_* event types */ +u32 sync_cookie;/* used to corrolate events, namely inotify mv events */ char *file_name;size_t name_len; };
@@ -227,9 +228,11 @@ struct fsnotify_mark_entry {/* called from the vfs helpers */ /* main fsnotify call to send events */ -extern void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is,const char *name); +extern void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is, +const char *name,u32 cookie);extern void __fsnotify_parent (struct dentry *dentry,__u32 mask);extern void __fsnotify_inode_delete (struct inode *inode); +extern u32 fsnotify_get_cookie (void );static inline int fsnotify_inode_watches_children (struct inode *inode) {
@@ -322,12 +325,13 @@ extern void fsnotify_put_mark(struct fsnotify_mark_entry *entry);/* put here because inotify does some weird stuff when destroying watches */ extern struct fsnotify_event *fsnotify_create_event (struct inode *to_tell,__u32 mask, -void *data,int data_is,const char *name); +void *data,int data_is,const char *name, +u32 cookie);#else static inline void fsnotify (struct inode *to_tell,__u32 mask,void *data,int data_is, -const char *name); +const char *name,u32 cookie) {}static inline void __fsnotify_parent (struct dentry *dentry,__u32 mask)
@@ -342,6 +346,11 @@ static inline void __fsnotify_update_dcache_flags(struct dentry *dentry)static inline void __fsnotify_d_instantiate (struct dentry *dentry,struct inode *inode) {} +static inline u32 fsnotify_get_cookie (void ) +{ +return 0 ; +} +#endif /* CONFIG_FSNOTIFY */ #endif /* __KERNEL __ */
PATCH 9/12 fsnotify: allow groups to add private data to events
In reply to Eric Parisinotify needs per group information attached to events. This patch allows groups to attach private information and implements a callback so that information can be freed when an event is being destroyed.
---
fs/notify/dnotify/dnotify.c | 1 + fs/notify/notification.c | 37 ++++++++++++++++++++++++++++++++++--- include/linux/fsnotify_backend.h | 17 ++++++++++++++++- 3 files changed, 51 insertions(+), 4 deletions(-)
fs/notify/dnotify/dnotify.c +1 -0
@@ -183,6 +183,7 @@ static struct fsnotify_ops dnotify_fsnotify_ops = { .should_send_event = dnotify_should_send_event, .free_group_priv = NULL, .freeing_mark = dnotify_freeing_mark, + .free_event_priv = NULL, };/*
fs/notify/notification.c +34 -3
@@ -90,6 +90,8 @@ void fsnotify_put_event(struct fsnotify_event *event)if (event->data_type ==FSNOTIFY_EVENT_PATH )path_put (&event->path); +BUG_ON (!list_empty (&event->private_data_list)); +kfree (event->file_name);kmem_cache_free (fsnotify_event_cachep, event); }
@@ -106,7 +108,26 @@ void fsnotify_destroy_event_holder(struct fsnotify_event_holder *holder) }/* -* check if 2 events contain the same information. +* Find the private data that the group previously attached to this event when +* the group added the event to the notification queue (fsnotify_add_notify_event) +*/ +struct fsnotify_event_private_data *fsnotify_get_priv_from_event (struct fsnotify_group *group,struct fsnotify_event *event) +{ +struct fsnotify_event_private_data *lpriv; +struct fsnotify_event_private_data *priv =NULL ; + +list_for_each_entry (lpriv, &event->private_data_list, event_list) { +if (lpriv->group == group) { + priv = lpriv; +break ; + } + } +return priv; +} + +/* +* Check if 2 events contain the same information. We do not compare private data +* but at this moment that isn't a problem for any know fsnotify listeners. */ static bool event_compare (struct fsnotify_event *old,struct fsnotify_event *new) {
@@ -134,13 +155,17 @@ static bool event_compare(struct fsnotify_event *old, struct fsnotify_event *new* event off the queue to deal with. If the event is successfully added to the * group's notification queue, a reference is taken on event. */ -int fsnotify_add_notify_event (struct fsnotify_group *group,struct fsnotify_event *event) +int fsnotify_add_notify_event (struct fsnotify_group *group,struct fsnotify_event *event, +struct fsnotify_event_private_data *priv) {struct fsnotify_event_holder *holder =NULL ;struct list_head *list = &group->notification_list;struct fsnotify_event_holder *last_holder;struct fsnotify_event *last_event; +/* easy to tell if priv was attached to the event */ +INIT_LIST_HEAD (&priv->event_list); +/* * There is one fsnotify_event_holder embedded inside each fsnotify_event. * Check if we expect to be able to use that holder. If not alloc a new
@@ -183,7 +208,7 @@ alloc_holder:mutex_unlock (&group->notification_mutex);if (holder != &event->holder)fsnotify_destroy_event_holder (holder); -return 0 ; +return -EEXIST ; } }
@@ -192,6 +217,8 @@ alloc_holder:fsnotify_get_event (event);list_add_tail (&holder->event_list, list); +if (priv) +list_add_tail (&priv->event_list, &event->private_data_list);spin_unlock (&event->lock);mutex_unlock (&group->notification_mutex);
@@ -256,6 +283,8 @@ void fsnotify_flush_notify(struct fsnotify_group *group)mutex_lock (&group->notification_mutex);while (!fsnotify_notify_queue_is_empty (group)) { event =fsnotify_remove_notify_event (group); +if (group->ops->free_event_priv) + group->ops->free_event_priv (group, event);fsnotify_put_event (event);/* matches fsnotify_add_notify_event */ }mutex_unlock (&group->notification_mutex);
@@ -274,6 +303,8 @@ static void initialize_event(struct fsnotify_event *event) event->inode =NULL ; event->data_type =FSNOTIFY_EVENT_NONE ; +INIT_LIST_HEAD (&event->private_data_list); + event->to_tell =NULL ; event->file_name =NULL ;
include/linux/fsnotify_backend.h +16 -1
@@ -81,6 +81,7 @@ struct fsnotify_ops {int (*handle_event)(struct fsnotify_group *group,struct fsnotify_event *event);void (*free_group_priv)(struct fsnotify_group *group);void (*freeing_mark)(struct fsnotify_mark_entry *entry,struct fsnotify_group *group); +void (*free_event_priv)(struct fsnotify_group *group,struct fsnotify_event *event); };/*
@@ -158,6 +159,15 @@ struct fsnotify_event_holder { };/* +* Inotify needs to tack data onto an event. This struct lets us later find the +* correct private data of the correct group. +*/ +struct fsnotify_event_private_data { +struct fsnotify_group *group; +struct list_head event_list; +}; + +/* * all of the information about the original object we want to now send to * a group. If you want to carry more info from the accessing task to the * listener this structure is where you need to be adding fields.
@@ -196,6 +206,8 @@ struct fsnotify_event {u32 sync_cookie;/* used to corrolate events, namely inotify mv events */ char *file_name;size_t name_len; + +struct list_head private_data_list;/* groups can store private data here */ };/*
@@ -299,13 +311,16 @@ extern struct fsnotify_event_private_data *fsnotify_get_priv_from_event(struct f struct fsnotify_event *event);/* attach the event to the group notification queue */ -extern int fsnotify_add_notify_event (struct fsnotify_group *group,struct fsnotify_event *event); +extern int fsnotify_add_notify_event (struct fsnotify_group *group,struct fsnotify_event *event, +struct fsnotify_event_private_data *priv);/* true if the group notification queue is empty */ extern bool fsnotify_notify_queue_is_empty (struct fsnotify_group *group);/* return, but do not dequeue the first event on the notification queue */ extern struct fsnotify_event *fsnotify_peek_notify_event (struct fsnotify_group *group);/* reutnr AND dequeue the first event on the notification queue */ extern struct fsnotify_event *fsnotify_remove_notify_event (struct fsnotify_group *group); +extern struct fsnotify_event_private_data *fsnotify_get_priv_from_event (struct fsnotify_group *group, +struct fsnotify_event *event);/* functions used to manipulate the marks attached to inodes */
PATCH 10/12 fsnotify: fsnotify marks on inodes pin them in core
In reply to Eric ParisThis patch pins any inodes with an fsnotify mark in core. The idea is that as soon as the mark is removed from the inode->fsnotify_mark_entries list the inode will be iput. In reality is doesn't quite work exactly this way. The igrab will happen when the mark is added to an inode, but the iput will happen when the inode pointer is NULL'd inside the mark.
It's possible that 2 racing things will try to remove the mark from different directions. One may try to remove the mark because of an explicit request and one might try to remove it because the inode was deleted. It's possible that the removal because of inode deletion will remove the mark from the inode's list, but the removal by explicit request will actually set entry->inode == NULL; and call the iput. This is safe.
---
fs/notify/inode_mark.c | 7 +++++++ 1 files changed, 7 insertions(+), 0 deletions(-)
fs/notify/inode_mark.c +7 -0
@@ -204,6 +204,8 @@ void fsnotify_destroy_mark_by_entry(struct fsnotify_mark_entry *entry)*/ +iput (inode); +/* * it's possible that this group tried to destroy itself, but this * this mark was simultaneously being freed by inode. If that's the
@@ -306,6 +308,10 @@ int fsnotify_add_mark(struct fsnotify_mark_entry *entry,struct fsnotify_mark_entry *lentry;int ret =0 ; + inode =igrab (inode); +if (unlikely (!inode)) +return -EINVAL ; +/* * LOCKING ORDER!!!! * entry->lock
@@ -337,6 +343,7 @@ int fsnotify_add_mark(struct fsnotify_mark_entry *entry,if (lentry) { ret = -EEXIST ; +iput (inode);fsnotify_put_mark (lentry); }else {__fsnotify_update_child_dentry_flags (inode);
PATCH 11/12 fsnotify: handle filesystem unmounts with fsnotify marks
In reply to Eric ParisWhen an fs is unmounted with an fsnotify mark entry attached to one of its inodes we need to destroy that mark entry and we also (like inotify) send an unmount event.
---
fs/inode.c | 1 + fs/notify/inode_mark.c | 72 ++++++++++++++++++++++++++++++++++++++ include/linux/fsnotify_backend.h | 4 ++ 3 files changed, 77 insertions(+), 0 deletions(-)
fs/inode.c +1 -0
@@ -408,6 +408,7 @@ int invalidate_inodes(struct super_block * sb)mutex_lock (&iprune_mutex);spin_lock (&inode_lock);inotify_unmount_inodes (&sb->s_inodes); +fsnotify_unmount_inodes (&sb->s_inodes); busy =invalidate_list (&sb->s_inodes, &throw_away);spin_unlock (&inode_lock);
fs/notify/inode_mark.c +72 -0
81 lines not on this page · raw message
include/linux/fsnotify_backend.h +4 -0
@@ -337,6 +337,7 @@ extern void fsnotify_destroy_mark_by_entry(struct fsnotify_mark_entry *entry);extern void fsnotify_clear_marks_by_group (struct fsnotify_group *group);extern void fsnotify_get_mark (struct fsnotify_mark_entry *entry);extern void fsnotify_put_mark (struct fsnotify_mark_entry *entry); +extern void fsnotify_unmount_inodes (struct list_head *list);/* put here because inotify does some weird stuff when destroying watches */ extern struct fsnotify_event *fsnotify_create_event(struct inode *to_tell, __u32 mask,
@@ -366,6 +367,9 @@ static inline u32 fsnotify_get_cookie(void)return 0 ; } +static inline void fsnotify_unmount_inodes (struct list_head *list) +{} +#endif /* CONFIG_FSNOTIFY */ #endif /* __KERNEL __ */
PATCH 12/12 inotify: reimplement inotify using fsnotify
In reply to Eric ParisReimplement inotify_user using fsnotify. This should be feature for feature exactly the same as the original inotify_user. This does not make any changes to the in kernel inotify feature used by audit. Those patches (and the eventual removal of in kernel inotify) will come after the new inotify_user proves to be working correctly.
---
MAINTAINERS | 2 fs/notify/inotify/Kconfig | 20 - fs/notify/inotify/Makefile | 2 fs/notify/inotify/inotify.h | 21 + fs/notify/inotify/inotify_fsnotify.c | 147 ++++++ fs/notify/inotify/inotify_user.c | 829 ++++++++++++++++------------------ include/linux/fsnotify_backend.h | 11 init/Kconfig | 3 8 files changed, 586 insertions(+), 449 deletions(-) create mode 100644 fs/notify/inotify/inotify.h create mode 100644 fs/notify/inotify/inotify_fsnotify.c
MAINTAINERS +2 -0
@@ -2838,6 +2838,8 @@ P: John McCutchan M: [email protected] P: Robert Love M: [email protected] +P: Eric Paris +M: [email protected] L: [email protected] S: Maintained F: Documentation/filesystems/inotify.txt
fs/notify/inotify/Kconfig +12 -8
@@ -1,26 +1,30 @@ config INOTIFY bool "Inotify file change notification support" - default y + default n ---help--- - Say Y here to enable inotify support. Inotify is a file change - notification system and a replacement for dnotify. Inotify fixes - numerous shortcomings in dnotify and introduces several new features - including multiple file events, one-shot support, and unmount - notification. + Say Y here to enable legacy in kernel inotify support. Inotify is a + file change notification system. It is a replacement for dnotify. + This option only provides the legacy inotify in kernel API. There + are no in tree kernel users of this interface since it is deprecated. + You only need this if you are loading an out of tree kernel module + that uses inotify. For more information, see <file:Documentation/filesystems/inotify.txt> - If unsure, say Y. + If unsure, say N. config INOTIFY_USER bool "Inotify support for userspace" - depends on INOTIFY + depends on FSNOTIFY default y ---help--- Say Y here to enable inotify support for userspace, including the associated system calls. Inotify allows monitoring of both files and directories via a single open fd. Events are read from the file descriptor, which is also select()- and poll()-able. + Inotify fixes numerous shortcomings in dnotify and introduces several + new features including multiple file events, one-shot support, and + unmount notification. For more information, see <file:Documentation/filesystems/inotify.txt>
fs/notify/inotify/Makefile +1 -1
@@ -1,2 +1,2 @@ obj-$(CONFIG_INOTIFY) += inotify.o -obj-$(CONFIG_INOTIFY_USER) += inotify_user.o +obj-$(CONFIG_INOTIFY_USER) += inotify_fsnotify.o inotify_user.o
fs/notify/inotify/inotify.h new file +21 -0
@@ -0,0 +1,21 @@ +#include <linux/fsnotify_backend.h> +#include <linux/inotify.h> +#include <linux/slab.h> /* struct kmem_cache */ + +extern struct kmem_cache *event_priv_cachep; + +struct inotify_event_private_data { +struct fsnotify_event_private_data fsnotify_event_priv_data; +int wd; +}; + +struct inotify_inode_mark_entry { +/* fsnotify_mark_entry MUST be the first thing */ +struct fsnotify_mark_entry fsn_entry; +int wd; +}; + +extern void inotify_destroy_mark_entry (struct fsnotify_mark_entry *entry,struct fsnotify_group *group); +extern void __inotify_free_event_priv (struct inotify_event_private_data *event_priv); + +extern const struct fsnotify_ops inotify_fsnotify_ops;
fs/notify/inotify/inotify_fsnotify.c new file +147 -0
147 lines not on this page · raw message
fs/notify/inotify/inotify_user.c +390 -439
1,037 lines not on this page · raw message
include/linux/fsnotify_backend.h +11 -0
@@ -9,6 +9,7 @@#ifdef __KERNEL__ +#include <linux/idr.h> /* inotify uses this */ #include <linux/fs.h> /* struct inode */ #include <linux/list.h> #include <linux/path.h> /* struct path */
@@ -59,6 +60,7 @@/* listeners that hard code group numbers near the top */ #define DNOTIFY_GROUP_NUM UINT_MAX +#define INOTIFY_GROUP_NUM (DNOTIFY_GROUP_NUM-1)struct fsnotify_group ;struct fsnotify_event ;
@@ -140,6 +142,15 @@ struct fsnotify_group {/* groups can define private fields here or use the void *private */ union {void *private; +#ifdef CONFIG_INOTIFY_USER +struct inotify_group_private_data { +spinlock_t idr_lock; +struct idr idr; +u32 last_wd; +struct fasync_struct *fa;/* async notification */ +struct user_struct *user; + } inotify_data; +#endif }; };
init/Kconfig +2 -1
@@ -302,7 +302,8 @@ config AUDITSYSCALL config AUDIT_TREE def_bool y - depends on AUDITSYSCALL && INOTIFY + depends on AUDITSYSCALL + select INOTIFY menu "RCU Subsystem"
Re: [PATCH 12/12] inotify: reimplement inotify using fsnotify
Btw, one thing I noticed is that this adds tons of code despite making dnotify and inotify use command infrastructure. Do you already add features not actually used by inotify and dnotify?
Anyway, real review will follow once I get a little time..
Re: [PATCH 12/12] inotify: reimplement inotify using fsnotify
Quoted 3 lines · Christoph Hellwig
Btw, one thing I noticed is that this adds tons of code despite making dnotify and inotify use command infrastructure. Do you already add features not actually used by inotify and dnotify?
No new unused features.
inotify.c (933 lines) and some other inotify code can be considered dead when the next series converts audit and will then be marked for removal, so that would make the stats look a bit better.
The infrastructure code duplicates everything dnotify did and everything inotify did. So now they both have to handle each other's proclivities. It also means things like dnotify get the benefits of the dentry flag inotify used. That plus the finer grained event type checking before locking should actually make this a performance win.
If you see something that isn't needed let me know. I think I succeeded in separating all of the infrastructure stuff that was originally written for fanotify and some of those vestiges into later unsent patches, "there's history in them-thar patches."
MAINTAINERS | 4 fs/inode.c | 10 fs/notify/Kconfig | 13 fs/notify/Makefile | 4 fs/notify/dnotify/Kconfig | 1 fs/notify/dnotify/dnotify.c | 470 +++++++++++++++---- fs/notify/fsnotify.c | 196 ++++++++ fs/notify/fsnotify.h | 34 + fs/notify/group.c | 256 ++++++++++ fs/notify/inode_mark.c | 425 +++++++++++++++++ fs/notify/inotify/Kconfig | 20 fs/notify/inotify/Makefile | 2 fs/notify/inotify/inotify.c | 20 fs/notify/inotify/inotify.h | 21 fs/notify/inotify/inotify_fsnotify.c | 147 ++++++ fs/notify/inotify/inotify_user.c | 829 ++++++++++++++++------------------- fs/notify/notification.c | 424 +++++++++++++++++ include/linux/dcache.h | 3 include/linux/dnotify.h | 29 - include/linux/fs.h | 10 include/linux/fsnotify.h | 302 +++++++----- include/linux/fsnotify_backend.h | 404 ++++++++++++++++- include/linux/mutex.h | 23 init/Kconfig | 3 24 files changed, 2915 insertions(+), 735 deletions(-)
Quoted 3 lines · On Mon, 27 Apr 2009 17:53:05 -0400 Eric Paris <[email protected]> wrote:
Much like the
atomic_dec_and_lock()function in which we take and hold aspin_lockif we drop the atomic to 0 this function takes and holds the mutex if we dec the atomic to 0.
I sucked these patches into -mm, mainly for a bit of compile-time and runtime testing.
I read through them all on the previous iteration. IIRC my main impression was that the code and the data structures were not sufficiently well commented for that review to have been particularly effective. Hopefully things improved there?
It would be good if Al and/or hch and/or others could review this work. Christoph has indicated that he will be doing this.
You didn't reply to all my review comments from last time, but from a quick random sample I see that some/most comments have been addressed. Hopefully all were at least considered.
It's a little worrisome that my comment against this particular patch was lost, and the patch was verbatim merged into Ingo's perfcounter branch. Did anything else get lost?
Quoted 7 lines · Andrew Morton
Quoted 3 lines · On Mon, 27 Apr 2009 17:53:05 -0400 Eric Paris <[email protected]> wrote:
Much like the
atomic_dec_and_lock()function in which we take and hold aspin_lockif we drop the atomic to 0 this function takes and holds the mutex if we dec the atomic to 0.
Quoted 7 lines
I sucked these patches into -mm, mainly for a bit of compile-time and runtime testing.
I read through them all on the previous iteration. IIRC my main impression was that the code and the data structures were not sufficiently well commented for that review to have been particularly effective. Hopefully things improved there?
I added hundreds of lines of comments where I hope they will be useful.....
Quoted 7 lines
It would be good if Al and/or hch and/or others could review this work. Christoph has indicated that he will be doing this.
You didn't reply to all my review comments from last time, but from a quick random sample I see that some/most comments have been addressed. Hopefully all were at least considered.
Every comment was considered, I promise!
Quoted 3 lines
It's a little worrisome that my comment against this particular patch was lost, and the patch was verbatim merged into Ingo's perfcounter branch. Did anything else get lost?
Actually, by the time you commented on it the patch was already added and in use in Ingo's tree, which was why I didn't make the change I could (and I will) follow up with another patch to make the requested change rather than change this patch.
-Eric
Quoted 9 lines · Andrew Morton
Quoted 3 lines · On Mon, 27 Apr 2009 17:53:05 -0400 Eric Paris <[email protected]> wrote:
Much like the
atomic_dec_and_lock()function in which we take and hold aspin_lockif we drop the atomic to 0 this function takes and holds the mutex if we dec the atomic to 0.I sucked these patches into -mm, mainly for a bit of compile-time and runtime testing.
the locking API bit is already in the locking tree:
9ab772c: mutex: add atomic_dec_and_mutex_lock()
I added it 23 days ago. Please dont add it to -mm a second time ;-)
Ingo
Quoted 4 lines · Stephen Rothwell
Hi Ingo,
Quoted 1 line · On Wed, 29 Apr 2009 13:59:43 +0200 Ingo Molnar <[email protected]> wrote:
Quoted 8 lines
Quoted 5 lines
the locking API bit is already in the locking tree:
9ab772c: mutex: add
atomic_dec_and_mutex_lock()I added it 23 days ago. Please dont add it to -mm a second time ;-)
Where is the locking tree? That commit in the tip tree appears in the middle of a whole lot of perfcounter patches.
Oops, good point. I've put it into tip:core/locking now.
Ingo