inotify fixes
Subsystems (3)
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
@@ -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
@@ -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_datomic_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