[PATCH] inotify (3/5): add interfaces to kernel API

Add inotify_init_watch() so caller can use inotify_watch refcounts
before calling inotify_add_watch().

Add inotify_find_watch() to find an existing watch for an (ih,inode)
pair.  This is similar to inotify_find_update_watch(), but does not
update the watch's mask if one is found.

Add inotify_rm_watch() to remove a watch via the watch pointer instead
of the watch descriptor.

Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Acked-by: Robert Love <rml@novell.com>
Acked-by: John McCutchan <john@johnmccutchan.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/inotify.c b/fs/inotify.c
index f25c21801fdccac2114a72b150b3fdfa99baa2fa..8477c4fbecb45ff7a181c05ac835e8238c086dcd 100644 (file)
--- a/fs/inotify.c
+++ b/fs/inotify.c
@@ -467,6 +467,19 @@ struct inotify_handle *inotify_init(const struct inotify_operations *ops)
 }
 EXPORT_SYMBOL_GPL(inotify_init);
 
+/**
+ * inotify_init_watch - initialize an inotify watch
+ * @watch: watch to initialize
+ */
+void inotify_init_watch(struct inotify_watch *watch)
+{
+       INIT_LIST_HEAD(&watch->h_list);
+       INIT_LIST_HEAD(&watch->i_list);
+       atomic_set(&watch->count, 0);
+       get_inotify_watch(watch); /* initial get */
+}
+EXPORT_SYMBOL_GPL(inotify_init_watch);
+
 /**
  * inotify_destroy - clean up and destroy an inotify instance
  * @ih: inotify handle
@@ -514,6 +527,37 @@ void inotify_destroy(struct inotify_handle *ih)
 }
 EXPORT_SYMBOL_GPL(inotify_destroy);
 
+/**
+ * inotify_find_watch - find an existing watch for an (ih,inode) pair
+ * @ih: inotify handle
+ * @inode: inode to watch
+ * @watchp: pointer to existing inotify_watch
+ *
+ * Caller must pin given inode (via nameidata).
+ */
+s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode,
+                      struct inotify_watch **watchp)
+{
+       struct inotify_watch *old;
+       int ret = -ENOENT;
+
+       mutex_lock(&inode->inotify_mutex);
+       mutex_lock(&ih->mutex);
+
+       old = inode_find_handle(inode, ih);
+       if (unlikely(old)) {
+               get_inotify_watch(old); /* caller must put watch */
+               *watchp = old;
+               ret = old->wd;
+       }
+
+       mutex_unlock(&ih->mutex);
+       mutex_unlock(&inode->inotify_mutex);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(inotify_find_watch);
+
 /**
  * inotify_find_update_watch - find and update the mask of an existing watch
  * @ih: inotify handle
@@ -593,10 +637,6 @@ s32 inotify_add_watch(struct inotify_handle *ih, struct inotify_watch *watch,
                goto out;
        ret = watch->wd;
 
-       atomic_set(&watch->count, 0);
-       INIT_LIST_HEAD(&watch->h_list);
-       INIT_LIST_HEAD(&watch->i_list);
-
        /* save a reference to handle and bump the count to make it official */
        get_inotify_handle(ih);
        watch->ih = ih;
@@ -607,8 +647,6 @@ s32 inotify_add_watch(struct inotify_handle *ih, struct inotify_watch *watch,
         */
        watch->inode = igrab(inode);
 
-       get_inotify_watch(watch); /* initial get */
-
        if (!inotify_inode_watched(inode))
                set_dentry_child_flags(inode, 1);
 
@@ -659,6 +697,20 @@ int inotify_rm_wd(struct inotify_handle *ih, u32 wd)
 }
 EXPORT_SYMBOL_GPL(inotify_rm_wd);
 
+/**
+ * inotify_rm_watch - remove a watch from an inotify instance
+ * @ih: inotify handle
+ * @watch: watch to remove
+ *
+ * Can sleep.
+ */
+int inotify_rm_watch(struct inotify_handle *ih,
+                    struct inotify_watch *watch)
+{
+       return inotify_rm_wd(ih, watch->wd);
+}
+EXPORT_SYMBOL_GPL(inotify_rm_watch);
+
 /*
  * inotify_setup - core initialization function
  */

diff --git a/fs/inotify_user.c b/fs/inotify_user.c
index 8b83c7190067bdd52faac7c9ea018102c4999c1d..9e9931e2badde80d57629c479b4f415fceb7953a 100644 (file)
--- a/fs/inotify_user.c
+++ b/fs/inotify_user.c
@@ -380,6 +380,7 @@ static int create_watch(struct inotify_device *dev, struct inode *inode,
 
        atomic_inc(&dev->user->inotify_watches);
 
+       inotify_init_watch(&watch->wdata);
        ret = inotify_add_watch(dev->ih, &watch->wdata, inode, mask);
        if (ret < 0)
                free_inotify_user_watch(&watch->wdata);

diff --git a/include/linux/inotify.h b/include/linux/inotify.h
index e7899e7d83addd83f16fe46379265d5170c28dc5..e7e7fb7fc778d414f05df646bb02da04a6b0c026 100644 (file)
--- a/include/linux/inotify.h
+++ b/include/linux/inotify.h
@@ -112,11 +112,15 @@ extern u32 inotify_get_cookie(void);
 /* Kernel Consumer API */
 
 extern struct inotify_handle *inotify_init(const struct inotify_operations *);
+extern void inotify_init_watch(struct inotify_watch *);
 extern void inotify_destroy(struct inotify_handle *);
+extern __s32 inotify_find_watch(struct inotify_handle *, struct inode *,
+                               struct inotify_watch **);
 extern __s32 inotify_find_update_watch(struct inotify_handle *, struct inode *,
                                       u32);
 extern __s32 inotify_add_watch(struct inotify_handle *, struct inotify_watch *,
                               struct inode *, __u32);
+extern int inotify_rm_watch(struct inotify_handle *, struct inotify_watch *);
 extern int inotify_rm_wd(struct inotify_handle *, __u32);
 extern void get_inotify_watch(struct inotify_watch *);
 extern void put_inotify_watch(struct inotify_watch *);
@@ -163,10 +167,20 @@ static inline struct inotify_handle *inotify_init(const struct inotify_operation
        return ERR_PTR(-EOPNOTSUPP);
 }
 
+static inline void inotify_init_watch(struct inotify_watch *watch)
+{
+}
+
 static inline void inotify_destroy(struct inotify_handle *ih)
 {
 }
 
+static inline __s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode,
+                                      struct inotify_watch **watchp)
+{
+       return -EOPNOTSUPP;
+}
+
 static inline __s32 inotify_find_update_watch(struct inotify_handle *ih,
                                              struct inode *inode, u32 mask)
 {
@@ -180,6 +194,12 @@ static inline __s32 inotify_add_watch(struct inotify_handle *ih,
        return -EOPNOTSUPP;
 }
 
+static inline int inotify_rm_watch(struct inotify_handle *ih,
+                                  struct inotify_watch *watch)
+{
+       return -EOPNOTSUPP;
+}
+
 static inline int inotify_rm_wd(struct inotify_handle *ih, __u32 wd)
 {
        return -EOPNOTSUPP;