Skip to contentSkip to conversation

inotify fixes

PATCH New Amy Griffis 1 participant 1 message May 22, 2006

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 inotify fixes

This patch includes several fixes and some new features for the inotify kernel API.

Fixes:
- always call event handler for IN_IGNORED last, in case caller frees watch memory
- don't leak memory with IN_ONESHOT events
- don't leak memory in inotify_destroy()
- fix memory management: make {get,put}_inotify_watch public
- have caller register a destroy_watch op to free watch memory on last put_inotify_watch

Features:
- make inotify_remove_watch_locked() public for use in event callback
- add inotify_init_watch() so caller can grab a reference before calling inotify_add_watch(), after which the watch is subject to auto-removal
- in inotify_find_watch(), grab a ref for caller if watch is found

Other:
- update inotify documentation

Signature · 5 lines
 Documentation/filesystems/inotify.txt |  130 ++++++++++++++++++++++++++++++++--
 fs/inotify.c                          |  124 ++++++++++++++++++--------------
 fs/inotify_user.c                     |   34 +++++---
 include/linux/inotify.h               |   42 ++++++++--
 4 files changed, 251 insertions(+), 79 deletions(-)
Documentation/filesystems/inotify.txt +124 -6
index 6d50190..59a919f 100644
@@ -69,17 +69,135 @@ Prototypes:
 	int inotify_rm_watch (int fd, __u32 mask);
 
 
-(iii) Internal Kernel Implementation
+(iii) Kernel Interface
 
-Each inotify instance is associated with an inotify_device structure.
+Inotify's kernel API consists a set of functions for managing watches and an
+event callback.
+
+To use the kernel API, you must first initialize an inotify instance with a set
+of inotify_operations.  You are given an opaque inotify_handle, which you use
+for any further calls to inotify.
+
+    struct inotify_handle *ih = inotify_init(my_event_handler);
+
+You must provide a function for processing events and a function for destroying
+the inotify watch.
+
+    void handle_event(struct inotify_watch *watch, u32 wd, u32 mask,
+    	              u32 cookie, const char *name, struct inode *inode)
+
+	watch - the pointer to the inotify_watch that triggered this call
+	wd - the watch descriptor
+	mask - describes the event that occurred
+	cookie - an identifier for synchronizing events
+	name - the dentry name for affected files in a directory-based event
+	inode - the affected inode in a directory-based event
+
+    void destroy_watch(struct inotify_watch *watch)
+
+You may add watches by providing a pre-allocated and initialized inotify_watch
+structure and specifying the inode to watch along with an inotify event mask.
+You must pin the inode during the call.  You will likely wish to embed the
+inotify_watch structure in a structure of your own which contains other
+information about the watch.  Once you add an inotify watch, it is immediately
+subject to removal depending on filesystem events.  You must grab a reference if
+you depend on the watch hanging around after the call.
+
+    inotify_init_watch(&my_watch->iwatch);
+    inotify_get_watch(&my_watch->iwatch);	// optional
+    s32 wd = inotify_add_watch(ih, &my_watch->iwatch, inode, mask);
+    inotify_put_watch(&my_watch->iwatch);	// optional
+
+You may use the watch descriptor (wd) or the address of the inotify_watch for
+other inotify operations.  You must not directly read or manipulate data in the
+inotify_watch.  Additionally, you must not call inotify_add_watch() more than
+once for a given inotify_watch structure, unless you have first called either
+inotify_rm_watch() or inotify_rm_wd().
+
+To determine if you have already registered a watch for a given inode, you may
+call inotify_find_watch(), which gives you both the wd and the watch pointer for
+the inotify_watch, or an error if the watch does not exist.
+
+    wd = inotify_find_watch(ih, inode, &watchp);
+
+You may use container_of() on the watch pointer to access your own data
+associated with a given watch.  When an existing watch is found,
+inotify_find_watch() bumps the refcount before releasing its locks.  You must
+put that reference with:
+
+    put_inotify_watch(watchp);
+
+Call inotify_find_update_watch() to update the event mask for an existing watch.
+inotify_find_update_watch() returns the wd of the updated watch, or an error if
+the watch does not exist.
+
+    wd = inotify_find_update_watch(ih, inode, mask);
+
+An existing watch may be removed by calling either inotify_rm_watch() or
+inotify_rm_wd().
+
+    int ret = inotify_rm_watch(ih, &my_watch->iwatch);
+    int ret = inotify_rm_wd(ih, wd);
+
+A watch may be removed while executing your event handler with the following:
+
+    inotify_remove_watch_locked(ih, iwatch);
+
+Call inotify_destroy() to remove all watches from your inotify instance and
+release it.  If there are no outstanding references, inotify_destroy() will call
+your destroy_watch op for each watch.
+
+    inotify_destroy(ih);
+
+When inotify removes a watch, it sends an IN_IGNORED event to your callback.
+You may use this event as an indication to free the watch memory.  Note that
+inotify may remove a watch due to filesystem events, as well as by your request.
+If you use IN_ONESHOT, inotify will remove the watch after the first event, at
+which point you may call the final inotify_put_watch.
+
+(iv) Kernel Interface Prototypes
+
+	struct inotify_handle *inotify_init(struct inotify_operations *ops);
+
+	inotify_init_watch(struct inotify_watch *watch);
+
+	s32 inotify_add_watch(struct inotify_handle *ih,
+		              struct inotify_watch *watch,
+			      struct inode *inode, u32 mask);
+
+	s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode,
+			       struct inotify_watch **watchp);
+
+	s32 inotify_find_update_watch(struct inotify_handle *ih,
+				      struct inode *inode, u32 mask);
+
+	int inotify_rm_wd(struct inotify_handle *ih, u32 wd);
+
+	int inotify_rm_watch(struct inotify_handle *ih,
+			     struct inotify_watch *watch);
+
+	void inotify_remove_watch_locked(struct inotify_handle *ih,
+					 struct inotify_watch *watch);
+
+	void inotify_destroy(struct inotify_handle *ih);
+
+	void get_inotify_watch(struct inotify_watch *watch);
+	void put_inotify_watch(struct inotify_watch *watch);
+
+
+(v) Internal Kernel Implementation
+
+Each inotify instance is represented by an inotify_handle structure.
+Inotify's userspace consumers also have an inotify_device which is
+associated with the inotify_handle, and on which events are queued.
 
 Each watch is associated with an inotify_watch structure.  Watches are chained
-off of each associated device and each associated inode.
+off of each associated inotify_handle and each associated inode.
 
-See fs/inotify.c for the locking and lifetime rules.
+See fs/inotify.c and fs/inotify_user.c for the locking and lifetime rules.
 
 
-(iv) Rationale
+(vi) Rationale
 
 Q: What is the design decision behind not tying the watch to the open fd of
    the watched object?
@@ -145,7 +263,7 @@ A: The poor user-space interface is the 
    file descriptor-based one that allows basic file I/O and poll/select.
    Obtaining the fd and managing the watches could have been done either via a
    device file or a family of new system calls.  We decided to implement a
-   family of system calls because that is the preffered approach for new kernel
+   family of system calls because that is the preferred approach for new kernel
    interfaces.  The only real difference was whether we wanted to use open(2)
    and ioctl(2) or a couple of new system calls.  System calls beat ioctls.
 
fs/inotify.c +71 -53

284 lines not on this page · raw message

fs/inotify_user.c +22 -12
index 1ed17ae..9e9931e 100644
@@ -1,11 +1,12 @@
 /*
- * fs/inotify.c - inode-based file event notifications
+ * fs/inotify_user.c - inotify support for userspace
  *
  * Authors:
  *	John McCutchan	<[email protected]>
  *	Robert Love	<[email protected]>
  *
  * Copyright (C) 2005 John McCutchan
+ * Copyright 2006 Hewlett-Packard Development Company, L.P.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -60,7 +61,8 @@ int inotify_max_queued_events __read_mos
  * via get_inotify_dev() and drop the count via put_inotify_dev().
  *
  * inotify_user_watch: Lifetime is from create_watch() to the receipt of an
- * IN_IGNORED event from inotify.
+ * IN_IGNORED event from inotify, or when using IN_ONESHOT, to receipt of the
+ * first event, or to inotify_destroy().
  */
 
 /*
@@ -160,11 +162,15 @@ static inline void put_inotify_dev(struc
 }
 
 /*
- * free_inotify_user_watch - * cleans up the watch and its references
+ * free_inotify_user_watch - cleans up the watch and its references
  */
-static inline void free_inotify_user_watch(struct inotify_user_watch *watch)
+static void free_inotify_user_watch(struct inotify_watch *w)
 {
-	struct inotify_device *dev = watch->dev;
+	struct inotify_user_watch *watch;
+	struct inotify_device *dev;
+
+	watch = container_of(w, struct inotify_user_watch, wdata);
+	dev = watch->dev;
 
 	atomic_dec(&dev->user->inotify_watches);
 	put_inotify_dev(dev);
@@ -241,7 +247,7 @@ inotify_dev_get_event(struct inotify_dev
 }
 
 /*
- * inotify_dev_queue_event - event callback registered with core inotify, adds
+ * inotify_dev_queue_event - event handler registered with core inotify, adds
  * a new event to the given device
  *
  * Can sleep (calls kernel_event()).
@@ -262,8 +268,8 @@ static void inotify_dev_queue_event(stru
 	/* we can safely put the watch as we don't reference it while
 	 * generating the event
 	 */
-	if (mask & IN_IGNORED)
-		free_inotify_user_watch(watch);
+	if (mask & IN_IGNORED || mask & IN_ONESHOT)
+		put_inotify_watch(w); /* final put */
 
 	/* coalescing: drop this event if it is a dupe of the previous */
 	last = inotify_dev_get_event(dev);
@@ -374,15 +380,14 @@ static int create_watch(struct inotify_d
 
 	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);
+		free_inotify_user_watch(&watch->wdata);
 
 	return ret;
 }
 
-/* Kernel API */
-
 /* Device Interface */
 
 static unsigned int inotify_poll(struct file *file, poll_table *wait)
@@ -521,6 +526,11 @@ static const struct file_operations inot
 	.compat_ioctl	= inotify_ioctl,
 };
 
+static const struct inotify_operations inotify_user_ops = {
+	.handle_event	= inotify_dev_queue_event,
+	.destroy_watch	= free_inotify_user_watch,
+};
+
 asmlinkage long sys_inotify_init(void)
 {
 	struct inotify_device *dev;
@@ -552,7 +562,7 @@ asmlinkage long sys_inotify_init(void)
 		goto out_free_uid;
 	}
 
-	ih = inotify_init(inotify_dev_queue_event);
+	ih = inotify_init(&inotify_user_ops);
 	if (unlikely(IS_ERR(ih))) {
 		ret = PTR_ERR(ih);
 		goto out_free_dev;
include/linux/inotify.h +34 -8

82 lines not on this page · raw message