fsnotify: parent event notification
Eric Paris [Thu, 21 May 2009 21:01:29 +0000 (17:01 -0400)]
inotify 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.

Signed-off-by: Eric Paris <eparis@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Christoph Hellwig <hch@lst.de>

fs/notify/fsnotify.c
fs/notify/fsnotify.h
fs/notify/inode_mark.c
include/linux/dcache.h
include/linux/fsnotify.h
include/linux/fsnotify_backend.h

index d565462..7fc7600 100644 (file)
@@ -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
index 8ebcbe8..83b8ec0 100644 (file)
@@ -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_ */
index cdc1541..a395348 100644 (file)
@@ -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;
index 1515636..9797800 100644 (file)
@@ -180,10 +180,12 @@ 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_COOKIE          0x0040  /* For use by dcookie subsystem */
 
+#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x0080 /* Parent inode is watched by some fsnotify listener */
+
 extern spinlock_t dcache_lock;
 extern seqlock_t rename_lock;
 
index 3856eb6..6a662ed 100644 (file)
 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);
 }
 
 /*
@@ -188,9 +205,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);
 }
 
@@ -206,9 +223,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);
 }
 
@@ -223,9 +240,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);
 }
 
@@ -236,16 +253,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);
 }
 
@@ -260,9 +276,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);
 }
 
@@ -311,8 +327,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);
        }
 }
index cad5c4d..13d2dd5 100644 (file)
 #define FS_DN_RENAME           0x10000000      /* file renamed */
 #define FS_DN_MULTISHOT                0x20000000      /* dnotify multishot */
 
+/* This inode cares about things that happen to its children.  Always set for
+ * dnotify and inotify. */
+#define FS_EVENT_ON_CHILD      0x08000000
+
+/* This is a list of all events that may get sent to a parernt based on fs event
+ * happening to inodes inside that directory */
+#define FS_EVENTS_POSS_ON_CHILD   (FS_ACCESS | FS_MODIFY | FS_ATTRIB |\
+                                  FS_CLOSE_WRITE | FS_CLOSE_NOWRITE | FS_OPEN |\
+                                  FS_MOVED_FROM | FS_MOVED_TO | FS_CREATE |\
+                                  FS_DELETE)
+
 struct fsnotify_group;
 struct fsnotify_event;
 struct fsnotify_mark_entry;
@@ -183,8 +194,52 @@ struct fsnotify_mark_entry {
 
 /* main fsnotify call to send events */
 extern void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is);
+extern void __fsnotify_parent(struct dentry *dentry, __u32 mask);
 extern void __fsnotify_inode_delete(struct inode *inode);
 
+static inline int fsnotify_inode_watches_children(struct inode *inode)
+{
+       /* FS_EVENT_ON_CHILD is set if the inode may care */
+       if (!(inode->i_fsnotify_mask & FS_EVENT_ON_CHILD))
+               return 0;
+       /* this inode might care about child events, does it care about the
+        * specific set of events that can happen on a child? */
+       return inode->i_fsnotify_mask & FS_EVENTS_POSS_ON_CHILD;
+}
+
+/*
+ * Update the dentry with a flag indicating the interest of its parent to receive
+ * filesystem events when those events happens to this dentry->d_inode.
+ */
+static inline void __fsnotify_update_dcache_flags(struct dentry *dentry)
+{
+       struct dentry *parent;
+
+       assert_spin_locked(&dcache_lock);
+       assert_spin_locked(&dentry->d_lock);
+
+       parent = dentry->d_parent;
+       if (fsnotify_inode_watches_children(parent->d_inode))
+               dentry->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
+       else
+               dentry->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;
+}
+
+/*
+ * fsnotify_d_instantiate - instantiate a dentry for inode
+ * Called with dcache_lock held.
+ */
+static inline void __fsnotify_d_instantiate(struct dentry *dentry, struct inode *inode)
+{
+       if (!inode)
+               return;
+
+       assert_spin_locked(&dcache_lock);
+
+       spin_lock(&dentry->d_lock);
+       __fsnotify_update_dcache_flags(dentry);
+       spin_unlock(&dentry->d_lock);
+}
 
 /* called from fsnotify listeners, such as fanotify or dnotify */
 
@@ -230,9 +285,18 @@ extern struct fsnotify_event *fsnotify_create_event(struct inode *to_tell, __u32
 static inline void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is)
 {}
 
+static inline void __fsnotify_parent(struct dentry *dentry, __u32 mask)
+{}
+
 static inline void __fsnotify_inode_delete(struct inode *inode)
 {}
 
+static inline void __fsnotify_update_dcache_flags(struct dentry *dentry)
+{}
+
+static inline void __fsnotify_d_instantiate(struct dentry *dentry, struct inode *inode)
+{}
+
 #endif /* CONFIG_FSNOTIFY */
 
 #endif /* __KERNEL __ */