inotify, might as well be called salvationotify.
Documentation/dnotify.txt | 8
drivers/char/Kconfig | 13
drivers/char/Makefile | 1
drivers/char/inotify.c | 968 ++++++++++++++++++++++++++++++++++++++++++++++
fs/Kconfig | 12
fs/Makefile | 13
fs/attr.c | 31 +
fs/dnotify.c | 5
fs/inode.c | 3
fs/namei.c | 21
fs/open.c | 14
fs/read_write.c | 17
fs/super.c | 2
include/linux/dnotify.h | 46 +-
include/linux/fs.h | 9
include/linux/inotify.h | 124 +++++
kernel/sysctl.c | 8
17 files changed, 1263 insertions(+), 32 deletions(-)
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/Documentation/dnotify.txt linux-inotify/Documentation/dnotify.txt
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/Documentation/dnotify.txt 2004-04-03 22:37:23.000000000 -0500
+++ linux-inotify/Documentation/dnotify.txt 2004-10-05 16:15:07.000000000 -0400
@@ -54,6 +54,14 @@
Also, files that are unlinked, will still cause notifications in the
last directory that they were linked to.
+Configuration
+-------------
+
+Dnotify is controlled via the CONFIG_DNOTIFY configuration option. When
+disabled, fcntl(fd, F_NOTIFY, ...) will return -EINVAL.
+
+Dnotify is deprecated in favor of inotify (CONFIG_INOTIFY).
+
Example
-------
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/drivers/char/inotify.c linux-inotify/drivers/char/inotify.c
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/drivers/char/inotify.c 1969-12-31 19:00:00.000000000 -0500
+++ linux-inotify/drivers/char/inotify.c 2004-10-05 17:56:33.314470152 -0400
@@ -0,0 +1,968 @@
+/*
+ * Inode based directory notifications for Linux.
+ *
+ * Copyright (C) 2004 John McCutchan
+ *
+ * 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
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ */
+
+/* TODO:
+ * unmount events don't get sent if filesystem is mounted in two places
+ * MOVED_TO/MOVED_FROM filename is wrong
+ * dynamically allocate event filename
+ * need a way to connect MOVED_TO/MOVED_FROM events in user space
+ * use slab cache for inotify_inode_data structures
+ * watcher -> watch in the release notes
+ */
+
+#include <linux/bitmap.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/namei.h>
+#include <linux/poll.h>
+#include <linux/miscdevice.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/writeback.h>
+#include <linux/inotify.h>
+
+#define MAX_INOTIFY_DEVS 8 /* max open inotify devices */
+#define MAX_INOTIFY_DEV_WATCHES 8192 /* max total watches */
+#define MAX_INOTIFY_QUEUED_EVENTS 256 /* max events queued on the dev */
+
+static atomic_t watch_count;
+static kmem_cache_t *watch_cachep;
+static kmem_cache_t *event_cachep;
+
+/* For debugging */
+static int inotify_debug_flags;
+#define iprintk(f, str...) if (inotify_debug_flags & f) printk (KERN_ALERT str)
+
+/*
+ * struct inotify_device - represents an open instance of an inotify device
+ *
+ * For each inotify device, we need to keep track of the events queued on it,
+ * a list of the inodes that we are watching, and so on.
+ *
+ * 'bitmask' holds one bit for each possible watch descriptor: a set bit
+ * implies that the given WD is valid, unset implies it is not.
+ *
+ * This structure is protected by 'lock'. Lock ordering:
+ *
+ * inode->i_lock
+ * dev->lock
+ * dev->wait->lock
+ *
+ * FIXME: Look at replacing i_lock with i_sem.
+ */
+struct inotify_device {
+ DECLARE_BITMAP(bitmask, MAX_INOTIFY_DEV_WATCHES);
+ wait_queue_head_t wait;
+ struct list_head events;
+ struct list_head watches;
+ spinlock_t lock;
+ unsigned int event_count;
+ unsigned int nr_watches;
+};
+
+struct inotify_watch {
+ __s32 wd; /* watch descriptor */
+ __u32 mask;
+ struct inode * inode;
+ struct inotify_device * dev;
+ struct list_head d_list; /* device list */
+ struct list_head i_list; /* inode list */
+ struct list_head u_list; /* unmount list */
+};
+#define inotify_watch_d_list(pos) list_entry((pos), struct inotify_watch, d_list)
+#define inotify_watch_i_list(pos) list_entry((pos), struct inotify_watch, i_list)
+#define inotify_watch_u_list(pos) list_entry((pos), struct inotify_watch, u_list)
+
+/*
+ * A list of these is attached to each instance of the driver
+ * when the drivers read() gets called, this list is walked and
+ * all events that can fit in the buffer get delivered
+ */
+struct inotify_kernel_event {
+ struct list_head list;
+ struct inotify_event event;
+};
+
+/*
+ * find_inode - resolve a user-given path to a specific inode and iget() it
+ */
+static struct inode * find_inode(const char __user *dirname)
+{
+ struct inode *inode;
+ struct nameidata nd;
+ int error;
+
+ error = __user_walk(dirname, LOOKUP_FOLLOW, &nd, NULL);
+ if (error) {
+ iprintk(INOTIFY_DEBUG_INODE, "could not find inode\n");
+ inode = ERR_PTR(error);
+ goto out;
+ }
+
+ inode = nd.dentry->d_inode;
+ __iget(inode);
+ iprintk(INOTIFY_DEBUG_INODE, "ref'd inode\n");
+ path_release(&nd);
+out:
+ return inode;
+}
+
+static void unref_inode(struct inode *inode)
+{
+ iprintk(INOTIFY_DEBUG_INODE, "unref'd inode\n");
+ iput(inode);
+}
+
+struct inotify_kernel_event *kernel_event(int wd, __u32 mask,
+ const char *filename)
+{
+ struct inotify_kernel_event *kevent;
+
+ kevent = kmem_cache_alloc(event_cachep, GFP_ATOMIC);
+ if (!kevent) {
+ iprintk(INOTIFY_DEBUG_ALLOC,
+ "failed to alloc kevent (%d,%d)\n", wd, mask);
+ goto out;
+ }
+
+ iprintk(INOTIFY_DEBUG_ALLOC, "alloced kevent %p (%d,%d)\n",
+ kevent, wd, mask);
+
+ kevent->event.wd = wd;
+ kevent->event.mask = mask;
+ INIT_LIST_HEAD(&kevent->list);
+
+ if (filename) {
+ iprintk(INOTIFY_DEBUG_FILEN,
+ "filename for event was %p %s\n", filename, filename);
+ strncpy(kevent->event.filename, filename,
+ INOTIFY_FILENAME_MAX);
+ kevent->event.filename[INOTIFY_FILENAME_MAX-1] = '\0';
+ iprintk(INOTIFY_DEBUG_FILEN,
+ "filename after copying %s\n", kevent->event.filename);
+ } else {
+ iprintk(INOTIFY_DEBUG_FILEN, "no filename for event\n");
+ kevent->event.filename[0] = '\0';
+ }
+
+
+out:
+ return kevent;
+}
+
+void delete_kernel_event(struct inotify_kernel_event *kevent)
+{
+ if (!kevent)
+ return;
+ iprintk(INOTIFY_DEBUG_ALLOC, "free'd kevent %p\n", kevent);
+ kmem_cache_free(event_cachep, kevent);
+}
+
+#define list_to_inotify_kernel_event(pos) list_entry((pos), struct inotify_kernel_event, list)
+#define inotify_dev_get_event(dev) (list_to_inotify_kernel_event(dev->events.next))
+#define inotify_dev_has_events(dev) (!list_empty(&dev->events))
+
+/* Does this events mask get sent to the watch ? */
+#define event_and(event_mask,watches_mask) ((event_mask == IN_UNMOUNT) || \
+ (event_mask == IN_IGNORED) || \
+ (event_mask & watches_mask))
+
+/*
+ * inotify_dev_queue_event - add a new event to the given device
+ *
+ * Caller must hold dev->lock.
+ */
+static void inotify_dev_queue_event(struct inotify_device *dev,
+ struct inotify_watch *watch,
+ __u32 mask, const char *filename)
+{
+ struct inotify_kernel_event *kevent, *last;
+
+ /*
+ * Check if the new event is a duplicate of the last event queued.
+ */
+ last = inotify_dev_get_event(dev);
+ if (dev->event_count && last->event.mask == mask &&
+ last->event.wd == watch->wd) {
+ /* Check if the filenames match */
+ if (!filename && last->event.filename[0] == '\0')
+ return;
+ if (filename && !strcmp(last->event.filename, filename))
+ return;
+ }
+
+ /*
+ * the queue has already overflowed and we have already sent the
+ * Q_OVERFLOW event
+ */
+ if (dev->event_count > MAX_INOTIFY_QUEUED_EVENTS) {
+ iprintk(INOTIFY_DEBUG_EVENTS,
+ "event queue for %p overflowed\n", dev);
+ return;
+ }
+
+ /* the queue has just overflowed and we need to notify user space */
+ if (dev->event_count == MAX_INOTIFY_QUEUED_EVENTS) {
+ dev->event_count++;
+ kevent = kernel_event(-1, IN_Q_OVERFLOW, NULL);
+ iprintk(INOTIFY_DEBUG_EVENTS, "sending IN_Q_OVERFLOW to %p\n",
+ dev);
+ goto add_event_to_queue;
+ }
+
+ if (!event_and(mask, watch->inode->inotify_data->watch_mask) ||
+ !event_and(mask, watch->mask))
+ return;
+
+ dev->event_count++;
+ kevent = kernel_event(watch->wd, mask, filename);
+
+add_event_to_queue:
+ if (!kevent) {
+ iprintk(INOTIFY_DEBUG_EVENTS, "failed to queue event for %p"
+ " -- could not allocate kevent\n", dev);
+ dev->event_count--;
+ return;
+ }
+
+ /* queue the event and wake up anyone waiting */
+ list_add_tail(&kevent->list, &dev->events);
+ iprintk(INOTIFY_DEBUG_EVENTS,
+ "queued event %x for %p\n", kevent->event.mask, dev);
+ wake_up_interruptible(&dev->wait);
+}
+
+/*
+ * inotify_dev_event_dequeue - destroy an event on the given device
+ *
+ * Caller must hold dev->lock.
+ */
+static void inotify_dev_event_dequeue(struct inotify_device *dev)
+{
+ struct inotify_kernel_event *kevent;
+
+ if (!inotify_dev_has_events(dev))
+ return;
+
+ kevent = inotify_dev_get_event(dev);
+ list_del(&kevent->list);
+ dev->event_count--;
+ delete_kernel_event(kevent);
+
+ iprintk(INOTIFY_DEBUG_EVENTS, "dequeued event on %p\n", dev);
+}
+
+/*
+ * inotify_dev_get_wd - returns the next WD for use by the given dev
+ *
+ * Caller must hold dev->lock before calling.
+ */
+static int inotify_dev_get_wd(struct inotify_device *dev)
+{
+ int wd;
+
+ if (!dev || dev->nr_watches == MAX_INOTIFY_DEV_WATCHES)
+ return -1;
+
+ dev->nr_watches++;
+ wd = find_first_zero_bit(dev->bitmask, MAX_INOTIFY_DEV_WATCHES);
+ set_bit(wd, dev->bitmask);
+
+ return wd;
+}
+
+/*
+ * inotify_dev_put_wd - release the given WD on the given device
+ *
+ * Caller must hold dev->lock.
+ */
+static int inotify_dev_put_wd(struct inotify_device *dev, int wd)
+{
+ if (!dev || wd < 0)
+ return -1;
+
+ dev->nr_watches--;
+ clear_bit(wd, dev->bitmask);
+
+ return 0;
+}
+
+/*
+ * create_watch - creates a watch on the given device.
+ *
+ * Grabs dev->lock, so the caller must not hold it.
+ */
+static struct inotify_watch *create_watch(struct inotify_device *dev,
+ __u32 mask, struct inode *inode)
+{
+ struct inotify_watch *watch;
+
+ watch = kmem_cache_alloc(watch_cachep, GFP_KERNEL);
+ if (!watch) {
+ iprintk(INOTIFY_DEBUG_ALLOC,
+ "failed to allocate watch (%p,%d)\n", inode, mask);
+ return NULL;
+ }
+
+ watch->mask = mask;
+ watch->inode = inode;
+ watch->dev = dev;
+ INIT_LIST_HEAD(&watch->d_list);
+ INIT_LIST_HEAD(&watch->i_list);
+ INIT_LIST_HEAD(&watch->u_list);
+
+ spin_lock(&dev->lock);
+ watch->wd = inotify_dev_get_wd(dev);
+ spin_unlock(&dev->lock);
+
+ if (watch->wd < 0) {
+ iprintk(INOTIFY_DEBUG_ERRORS,
+ "Could not get wd for watch %p\n", watch);
+ iprintk(INOTIFY_DEBUG_ALLOC, "free'd watch %p\n", watch);
+ kmem_cache_free(watch_cachep, watch);
+ return NULL;
+ }
+
+ return watch;
+}
+
+/*
+ * delete_watch - removes the given 'watch' from the given 'dev'
+ *
+ * Caller must hold dev->lock.
+ */
+static void delete_watch(struct inotify_device *dev,
+ struct inotify_watch *watch)
+{
+ inotify_dev_put_wd(dev, watch->wd);
+ iprintk(INOTIFY_DEBUG_ALLOC, "free'd watch %p\n", watch);
+ kmem_cache_free(watch_cachep, watch);
+}
+
+/*
+ * inotify_find_dev - find the watch associated with the given inode and dev
+ *
+ * Caller must hold dev->lock.
+ */
+static struct inotify_watch *inode_find_dev(struct inode *inode,
+ struct inotify_device *dev)
+{
+ struct inotify_watch *watch;
+
+ if (!inode->inotify_data)
+ return NULL;
+
+ list_for_each_entry(watch, &inode->inotify_data->watches, i_list) {
+ if (watch->dev == dev)
+ return watch;
+ }
+
+ return NULL;
+}
+
+static struct inotify_watch *dev_find_wd(struct inotify_device *dev, int wd)
+{
+ struct inotify_watch *watch;
+
+ list_for_each_entry(watch, &dev->watches, d_list) {
+ if (watch->wd == wd)
+ return watch;
+ }
+
+ return NULL;
+}
+
+static int inotify_dev_is_watching_inode(struct inotify_device *dev,
+ struct inode *inode)
+{
+ struct inotify_watch *watch;
+
+ list_for_each_entry(watch, &dev->watches, d_list) {
+ if (watch->inode == inode)
+ return 1;
+ }
+
+ return 0;
+}
+
+/*
+ * inotify_dev_add_watcher - add the given watcher to the given device instance
+ *
+ * Caller must hold dev->lock.
+ */
+static int inotify_dev_add_watch(struct inotify_device *dev,
+ struct inotify_watch *watch)
+{
+ if (!dev || !watch)
+ return -EINVAL;
+
+ if (dev_find_wd (dev, watch->wd))
+ return -EINVAL;
+
+ if (dev->nr_watches == MAX_INOTIFY_DEV_WATCHES)
+ return -ENOSPC;
+
+ list_add(&watch->d_list, &dev->watches);
+ return 0;
+}
+
+/*
+ * inotify_dev_rm_watch - remove the given watch from the given device
+ *
+ * Caller must hold dev->lock because we call inotify_dev_queue_event().
+ */
+static int inotify_dev_rm_watch(struct inotify_device *dev,
+ struct inotify_watch *watch)
+{
+ if (!watch)
+ return -EINVAL;
+
+ inotify_dev_queue_event(dev, watch, IN_IGNORED, NULL);
+ list_del(&watch->d_list);
+
+ return 0;
+}
+
+void inode_update_watch_mask(struct inode *inode)
+{
+ struct inotify_watch *watch;
+ __u32 new_mask;
+
+ if (!inode->inotify_data)
+ return;
+
+ new_mask = 0;
+ list_for_each_entry(watch, &inode->inotify_data->watches, i_list)
+ new_mask |= watch->mask;
+
+ inode->inotify_data->watch_mask = new_mask;
+}
+
+/*
+ * inode_add_watch - add a watch to the given inode
+ *
+ * Callers must hold dev->lock, because we call inode_find_dev().
+ */
+static int inode_add_watch(struct inode *inode,
+ struct inotify_watch *watch)
+{
+ if (!inode || !watch || inode_find_dev(inode, watch->dev))
+ return -EINVAL;
+
+ /*
+ * This inode doesn't have an inotify_data structure attached to it
+ */
+ if (!inode->inotify_data) {
+ inode->inotify_data = kmalloc(sizeof(struct inotify_inode_data),
+ GFP_ATOMIC);
+ INIT_LIST_HEAD(&inode->inotify_data->watches);
+ inode->inotify_data->watch_mask = 0;
+ inode->inotify_data->watch_count = 0;
+ }
+ list_add(&watch->i_list, &inode->inotify_data->watches);
+ inode->inotify_data->watch_count++;
+ inode_update_watch_mask(inode);
+
+ return 0;
+}
+
+static int inode_rm_watch(struct inode *inode,
+ struct inotify_watch *watch)
+{
+ if (!inode || !watch || !inode->inotify_data)
+ return -EINVAL;
+
+ list_del(&watch->i_list);
+ inode->inotify_data->watch_count--;
+
+ if (!inode->inotify_data->watch_count) {
+ kfree(inode->inotify_data);
+ inode->inotify_data = NULL;
+ }
+
+ inode_update_watch_mask(inode);
+
+ return 0;
+}
+
+/* Kernel API */
+
+void inotify_inode_queue_event(struct inode *inode, __u32 mask,
+ const char *filename)
+{
+ struct inotify_watch *watch;
+
+ if (!inode->inotify_data)
+ return;
+
+ spin_lock(&inode->i_lock);
+
+ list_for_each_entry(watch, &inode->inotify_data->watches, i_list) {
+ spin_lock(&watch->dev->lock);
+ inotify_dev_queue_event(watch->dev, watch, mask, filename);
+ spin_unlock(&watch->dev->lock);
+ }
+
+ spin_unlock(&inode->i_lock);
+}
+EXPORT_SYMBOL_GPL(inotify_inode_queue_event);
+
+void inotify_dentry_parent_queue_event(struct dentry *dentry, __u32 mask,
+ const char *filename)
+{
+ struct dentry *parent;
+
+ parent = dget_parent(dentry);
+ inotify_inode_queue_event(parent->d_inode, mask, filename);
+ dput(parent);
+}
+EXPORT_SYMBOL_GPL(inotify_dentry_parent_queue_event);
+
+static void ignore_helper(struct inotify_watch *watch, int event)
+{
+ struct inotify_device *dev;
+ struct inode *inode;
+
+ inode = watch->inode;
+ dev = watch->dev;
+
+ spin_lock(&inode->i_lock);
+ spin_lock(&dev->lock);
+
+ if (event)
+ inotify_dev_queue_event(dev, watch, event, NULL);
+
+ inode_rm_watch(inode, watch);
+ inotify_dev_rm_watch(watch->dev, watch);
+ list_del(&watch->u_list);
+
+ delete_watch(dev, watch);
+ spin_unlock(&dev->lock);
+ spin_unlock(&inode->i_lock);
+
+ unref_inode(inode);
+}
+
+static void process_umount_list(struct list_head *umount)
+{
+ struct inotify_watch *watch, *next;
+
+ list_for_each_entry_safe(watch, next, umount, u_list)
+ ignore_helper(watch, IN_UNMOUNT);
+}
+
+/*
+ * build_umount_list - build a list of watches affected by an unmount.
+ *
+ * Caller must hold inode_lock.
+ */
+static void build_umount_list(struct list_head *head, struct super_block *sb,
+ struct list_head *umount)
+{
+ struct inode *inode;
+
+ list_for_each_entry(inode, head, i_list) {
+ struct inotify_watch *watch;
+
+ if (inode->i_sb != sb)
+ continue;
+
+ if (!inode->inotify_data)
+ continue;
+
+ spin_lock(&inode->i_lock);
+
+ list_for_each_entry(watch, &inode->inotify_data->watches,
+ i_list)
+ list_add(&watch->u_list, umount);
+
+ spin_unlock(&inode->i_lock);
+ }
+}
+
+void inotify_super_block_umount(struct super_block *sb)
+{
+ struct list_head umount;
+
+ INIT_LIST_HEAD(&umount);
+
+ spin_lock(&inode_lock);
+ build_umount_list(&inode_in_use, sb, &umount);
+ spin_unlock(&inode_lock);
+
+ process_umount_list(&umount);
+}
+EXPORT_SYMBOL_GPL(inotify_super_block_umount);
+
+/*
+ * inotify_inode_is_dead - an inode has been deleted, cleanup any watches
+ *
+ * FIXME: Callers need to always hold inode->i_lock.
+ */
+void inotify_inode_is_dead(struct inode *inode)
+{
+ struct inotify_watch *watch, *next;
+ struct inotify_inode_data *data;
+
+ data = inode->inode_data;
+ if (!data)
+ return;
+
+ list_for_each_entry_safe(watch, next, &data->watches, i_list)
+ ignore_helper(watch, 0);
+}
+EXPORT_SYMBOL_GPL(inotify_inode_is_dead);
+
+/* The driver interface is implemented below */
+
+static unsigned int inotify_poll(struct file *file, poll_table *wait)
+{
+ struct inotify_device *dev;
+
+ dev = file->private_data;
+
+ poll_wait(file, &dev->wait, wait);
+
+ if (inotify_dev_has_events(dev))
+ return POLLIN | POLLRDNORM;
+
+ return 0;
+}
+
+static ssize_t inotify_read(struct file *file, char __user *buf,
+ size_t count, loff_t *pos)
+{
+ size_t event_size;
+ struct inotify_device *dev;
+ char *start;
+ DECLARE_WAITQUEUE(wait, current);
+
+ start = buf;
+ dev = file->private_data;
+
+ /* We only hand out full inotify events */
+ event_size = sizeof(struct inotify_event);
+ if (count < event_size)
+ return -EINVAL;
+
+ while(1) {
+ int has_events;
+
+ spin_lock(&dev->lock);
+ has_events = inotify_dev_has_events(dev);
+ spin_unlock(&dev->lock);
+ if (has_events)
+ break;
+
+ if (file->f_flags & O_NONBLOCK)
+ return -EAGAIN;
+
+ if (signal_pending(current))
+ return -ERESTARTSYS;
+
+ add_wait_queue(&dev->wait, &wait);
+ set_current_state(TASK_INTERRUPTIBLE);
+
+ schedule();
+
+ set_current_state(TASK_RUNNING);
+ remove_wait_queue(&dev->wait, &wait);
+ }
+
+ while (count >= event_size) {
+ struct inotify_kernel_event *kevent;
+
+ spin_lock(&dev->lock);
+ if (!inotify_dev_has_events(dev)) {
+ spin_unlock(&dev->lock);
+ break;
+ }
+ kevent = inotify_dev_get_event(dev);
+ spin_unlock(&dev->lock);
+ if (copy_to_user(buf, &kevent->event, event_size))
+ return -EFAULT;
+
+ spin_lock(&dev->lock);
+ inotify_dev_event_dequeue(dev);
+ spin_unlock(&dev->lock);
+ count -= event_size;
+ buf += event_size;
+ }
+
+ return buf - start;
+}
+
+static int inotify_open(struct inode *inode, struct file *file)
+{
+ struct inotify_device *dev;
+
+ if (atomic_read(&watch_count) == MAX_INOTIFY_DEVS)
+ return -ENODEV;
+
+ atomic_inc(&watch_count);
+
+ dev = kmalloc(sizeof(struct inotify_device), GFP_KERNEL);
+ if (!dev)
+ return -ENOMEM;
+
+ bitmap_clear(dev->bitmask, MAX_INOTIFY_DEV_WATCHES);
+
+ INIT_LIST_HEAD(&dev->events);
+ INIT_LIST_HEAD(&dev->watches);
+ init_waitqueue_head(&dev->wait);
+
+ dev->event_count = 0;
+ dev->nr_watches = 0;
+ dev->lock = SPIN_LOCK_UNLOCKED;
+
+ file->private_data = dev;
+
+ printk(KERN_ALERT "inotify device opened\n");
+
+ return 0;
+}
+
+/*
+ * inotify_release_all_watches - destroy all watches on a given device
+ */
+static void inotify_release_all_watches(struct inotify_device *dev)
+{
+ struct inotify_watch *watch,*next;
+
+ list_for_each_entry_safe(watch, next, &dev->watches, d_list)
+ ignore_helper(watch, 0);
+}
+
+/*
+ * inotify_release_all_events - destroy all of the events on a given device
+ */
+static void inotify_release_all_events(struct inotify_device *dev)
+{
+ spin_lock(&dev->lock);
+ while (inotify_dev_has_events(dev))
+ inotify_dev_event_dequeue(dev);
+ spin_unlock(&dev->lock);
+}
+
+static int inotify_release(struct inode *inode, struct file *file)
+{
+ struct inotify_device *dev;
+
+ dev = file->private_data;
+ inotify_release_all_watches(dev);
+ inotify_release_all_events(dev);
+ kfree(dev);
+
+ printk(KERN_ALERT "inotify device released\n");
+
+ atomic_dec(&watch_count);
+ return 0;
+}
+
+static int inotify_watch(struct inotify_device *dev,
+ struct inotify_watch_request *request)
+{
+ struct inode *inode;
+ struct inotify_watch *watch;
+
+ inode = find_inode(request->dirname);
+ if (IS_ERR(inode))
+ return PTR_ERR(inode);
+
+ if (!S_ISDIR(inode->i_mode))
+ iprintk(INOTIFY_DEBUG_ERRORS, "watching file\n");
+
+ spin_lock(&inode->i_lock);
+ spin_lock(&dev->lock);
+
+ /*
+ * This handles the case of re-adding a directory we are already
+ * watching, we just update the mask and return 0
+ */
+ if (inotify_dev_is_watching_inode(dev, inode)) {
+ struct inotify_watch *owatch; /* the old watch */
+
+ iprintk(INOTIFY_DEBUG_ERRORS,
+ "adjusting event mask for inode %p\n", inode);
+
+ owatch = inode_find_dev(inode, dev);
+ owatch->mask = request->mask;
+ inode_update_watch_mask(inode);
+ spin_unlock(&dev->lock);
+ spin_unlock(&inode->i_lock);
+ unref_inode(inode);
+
+ return 0;
+ }
+
+ spin_unlock(&dev->lock);
+ spin_unlock(&inode->i_lock);
+
+ watch = create_watch(dev, request->mask, inode);
+ if (!watch) {
+ unref_inode(inode);
+ return -ENOSPC;
+ }
+
+ spin_lock(&inode->i_lock);
+ spin_lock(&dev->lock);
+
+ /* We can't add anymore watches to this device */
+ if (inotify_dev_add_watch(dev, watch) == -ENOSPC) {
+ iprintk(INOTIFY_DEBUG_ERRORS,
+ "can't add watch dev is full\n");
+ delete_watch(dev, watch);
+ spin_unlock(&dev->lock);
+ spin_unlock(&inode->i_lock);
+ unref_inode(inode);
+ return -ENOSPC;
+ }
+
+ inode_add_watch(inode, watch);
+
+ spin_unlock(&dev->lock);
+ spin_unlock(&inode->i_lock);
+
+ return watch->wd;
+}
+
+static int inotify_ignore(struct inotify_device *dev, int wd)
+{
+ struct inotify_watch *watch;
+
+ watch = dev_find_wd(dev, wd);
+ if (!watch)
+ return -EINVAL;
+ ignore_helper(watch, 0);
+
+ return 0;
+}
+
+static void inotify_print_stats(struct inotify_device *dev)
+{
+ int sizeof_inotify_watch;
+ int sizeof_inotify_device;
+ int sizeof_inotify_kernel_event;
+
+ sizeof_inotify_watch = sizeof (struct inotify_watch);
+ sizeof_inotify_device = sizeof (struct inotify_device);
+ sizeof_inotify_kernel_event = sizeof (struct inotify_kernel_event);
+
+ printk(KERN_ALERT "GLOBAL INOTIFY STATS\n");
+ printk(KERN_ALERT "watch_count = %d\n", atomic_read(&watch_count));
+
+ printk(KERN_ALERT "sizeof(struct inotify_watch) = %d\n",
+ sizeof_inotify_watch);
+ printk(KERN_ALERT "sizeof(struct inotify_device) = %d\n",
+ sizeof_inotify_device);
+ printk(KERN_ALERT "sizeof(struct inotify_kernel_event) = %d\n",
+ sizeof_inotify_kernel_event);
+
+ spin_lock(&dev->lock);
+
+ printk(KERN_ALERT "inotify device: %p\n", dev);
+ printk(KERN_ALERT "inotify event_count: %u\n", dev->event_count);
+ printk(KERN_ALERT "inotify watch_count: %d\n", dev->nr_watches);
+
+ spin_unlock(&dev->lock);
+}
+
+/*
+ * inotify_ioctl() - our device file's ioctl method
+ *
+ * The VFS serializes all of our calls via the BKL and we rely on that. We
+ * could, alternatively, grab dev->lock. Right now lower levels grab that
+ * where needed.
+ */
+static int inotify_ioctl(struct inode *ip, struct file *fp,
+ unsigned int cmd, unsigned long arg)
+{
+ struct inotify_device *dev;
+ struct inotify_watch_request request;
+ void __user *p;
+ int wd;
+
+ dev = fp->private_data;
+ p = (void __user *) arg;
+
+ switch (cmd) {
+ case INOTIFY_WATCH:
+ iprintk(INOTIFY_DEBUG_ERRORS, "INOTIFY_WATCH ioctl\n");
+ if (copy_from_user(&request, p, sizeof (request)))
+ return -EFAULT;
+ return inotify_watch(dev, &request);
+ case INOTIFY_IGNORE:
+ iprintk(INOTIFY_DEBUG_ERRORS, "INOTIFY_IGNORE ioctl\n");
+ if (copy_from_user(&wd, p, sizeof (wd)))
+ return -EFAULT;
+ return inotify_ignore(dev, wd);
+ case INOTIFY_STATS:
+ iprintk(INOTIFY_DEBUG_ERRORS, "INOTIFY_STATS ioctl\n");
+ inotify_print_stats(dev);
+ return 0;
+ case INOTIFY_SETDEBUG:
+ iprintk(INOTIFY_DEBUG_ERRORS, "INOTIFY_SETDEBUG ioctl\n");
+ if (copy_from_user(&inotify_debug_flags, p, sizeof (int)))
+ return -EFAULT;
+ return 0;
+ default:
+ return -ENOTTY;
+ }
+}
+
+static struct file_operations inotify_fops = {
+ .owner = THIS_MODULE,
+ .poll = inotify_poll,
+ .read = inotify_read,
+ .open = inotify_open,
+ .release = inotify_release,
+ .ioctl = inotify_ioctl,
+};
+
+struct miscdevice inotify_device = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = "inotify",
+ .fops = &inotify_fops,
+};
+
+static int __init inotify_init(void)
+{
+ int ret;
+
+ ret = misc_register(&inotify_device);
+ if (ret)
+ goto out;
+
+ inotify_debug_flags = INOTIFY_DEBUG_NONE;
+
+ watch_cachep = kmem_cache_create("inotify_watch_cache",
+ sizeof(struct inotify_watch), 0, 0,
+ NULL, NULL);
+
+ event_cachep = kmem_cache_create("inotify_event_cache",
+ sizeof(struct inotify_kernel_event), 0,
+ 0, NULL, NULL);
+
+ printk(KERN_INFO "inotify init: minor=%d\n", inotify_device.minor);
+out:
+ return ret;
+}
+
+module_init(inotify_init);
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/drivers/char/Kconfig linux-inotify/drivers/char/Kconfig
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/drivers/char/Kconfig 2004-09-27 03:41:14.000000000 -0400
+++ linux-inotify/drivers/char/Kconfig 2004-10-05 16:15:07.000000000 -0400
@@ -65,6 +65,19 @@
config ECC
tristate "ECC memory monitoring"
+config INOTIFY
+ bool "Inotify file change notification support"
+ default y
+ ---help---
+ Say Y here to enable inotify support and the /dev/inotify character
+ device. Inotify is a file change notification system and a
+ replacement for dnotify. Inotify fixes numerous shortcomings in
+ dnotify and introduces several new features. It allows monitoring
+ of both files and directories via a single open fd. Multiple file
+ events are supported.
+
+ If unsure, say Y.
+
config SERIAL_NONSTANDARD
bool "Non-standard serial port support"
---help---
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/drivers/char/Makefile linux-inotify/drivers/char/Makefile
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/drivers/char/Makefile 2004-09-27 03:41:14.000000000 -0400
+++ linux-inotify/drivers/char/Makefile 2004-10-05 16:16:46.000000000 -0400
@@ -11,6 +11,7 @@
obj-$(CONFIG_VT) += vt_ioctl.o vc_screen.o consolemap.o \
consolemap_deftbl.o selection.o keyboard.o
+obj-$(CONFIG_INOTIFY) += inotify.o
obj-$(CONFIG_ECC) += ecc.o
obj-$(CONFIG_HW_CONSOLE) += vt.o defkeymap.o
obj-$(CONFIG_MAGIC_SYSRQ) += sysrq.o
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/attr.c linux-inotify/fs/attr.c
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/attr.c 2004-09-27 03:41:57.000000000 -0400
+++ linux-inotify/fs/attr.c 2004-10-05 16:15:07.000000000 -0400
@@ -11,6 +11,7 @@
#include <linux/string.h>
#include <linux/smp_lock.h>
#include <linux/dnotify.h>
+#include <linux/inotify.h>
#include <linux/fcntl.h>
#include <linux/quotaops.h>
#include <linux/security.h>
@@ -128,6 +129,28 @@
return dn_mask;
}
+static int setattr_mask_inotify(unsigned int ia_valid)
+{
+ unsigned long dn_mask = 0;
+
+ if (ia_valid & ATTR_UID)
+ dn_mask |= IN_ATTRIB;
+ if (ia_valid & ATTR_GID)
+ dn_mask |= IN_ATTRIB;
+ if (ia_valid & ATTR_SIZE)
+ dn_mask |= IN_MODIFY;
+ /* both times implies a utime(s) call */
+ if ((ia_valid & (ATTR_ATIME|ATTR_MTIME)) == (ATTR_ATIME|ATTR_MTIME))
+ dn_mask |= IN_ATTRIB;
+ else if (ia_valid & ATTR_ATIME)
+ dn_mask |= IN_ACCESS;
+ else if (ia_valid & ATTR_MTIME)
+ dn_mask |= IN_MODIFY;
+ if (ia_valid & ATTR_MODE)
+ dn_mask |= IN_ATTRIB;
+ return dn_mask;
+}
+
int notify_change(struct dentry * dentry, struct iattr * attr)
{
struct inode *inode = dentry->d_inode;
@@ -185,8 +208,16 @@
}
if (!error) {
unsigned long dn_mask = setattr_mask(ia_valid);
+ unsigned long in_mask = setattr_mask_inotify(ia_valid);
+
if (dn_mask)
dnotify_parent(dentry, dn_mask);
+ if (in_mask) {
+ inotify_inode_queue_event(dentry->d_inode, in_mask,
+ NULL);
+ inotify_dentry_parent_queue_event(dentry, in_mask,
+ dentry->d_name.name);
+ }
}
return error;
}
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/dnotify.c linux-inotify/fs/dnotify.c
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/dnotify.c 2004-04-03 22:36:55.000000000 -0500
+++ linux-inotify/fs/dnotify.c 2004-10-05 16:16:19.000000000 -0400
@@ -13,6 +13,7 @@
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*/
+
#include <linux/fs.h>
#include <linux/module.h>
#include <linux/sched.h>
@@ -21,8 +22,6 @@
#include <linux/spinlock.h>
#include <linux/slab.h>
-int dir_notify_enable = 1;
-
static rwlock_t dn_lock = RW_LOCK_UNLOCKED;
static kmem_cache_t *dn_cache;
@@ -73,8 +72,6 @@
dnotify_flush(filp, id);
return 0;
}
- if (!dir_notify_enable)
- return -EINVAL;
inode = filp->f_dentry->d_inode;
if (!S_ISDIR(inode->i_mode))
return -ENOTDIR;
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/inode.c linux-inotify/fs/inode.c
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/inode.c 2004-09-27 03:41:52.000000000 -0400
+++ linux-inotify/fs/inode.c 2004-10-05 16:15:07.000000000 -0400
@@ -113,6 +113,9 @@
if (inode) {
struct address_space * const mapping = &inode->i_data;
+#ifdef CONFIG_INOTIFY
+ inode->inotify_data = NULL;
+#endif
inode->i_sb = sb;
inode->i_blkbits = sb->s_blocksize_bits;
inode->i_flags = 0;
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/Kconfig linux-inotify/fs/Kconfig
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/Kconfig 2004-09-27 03:41:53.000000000 -0400
+++ linux-inotify/fs/Kconfig 2004-10-05 16:15:07.000000000 -0400
@@ -562,6 +562,18 @@
depends on XFS_QUOTA || QUOTA
default y
+config DNOTIFY
+ bool "Dnotify support"
+ default y
+ help
+ Dnotify is a directory-based per-fd file change notification system
+ that uses signals to communicate events to user-space. It has
+ been replaced by inotify (see CONFIG_INOTIFY), which solves many of
+ the shortcomings of dnotify and adds new features, but some
+ applications may still rely on dnotify.
+
+ Because of this, if unsure, say Y.
+
config AUTOFS_FS
tristate "Kernel automounter support"
help
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/Makefile linux-inotify/fs/Makefile
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/Makefile 2004-09-27 03:41:51.000000000 -0400
+++ linux-inotify/fs/Makefile 2004-10-05 16:15:07.000000000 -0400
@@ -5,12 +5,11 @@
# Rewritten to use lists instead of if-statements.
#
-obj-y := open.o read_write.o file_table.o buffer.o \
- bio.o super.o block_dev.o char_dev.o stat.o exec.o pipe.o \
- namei.o fcntl.o ioctl.o readdir.o select.o fifo.o locks.o \
- dcache.o inode.o attr.o bad_inode.o file.o dnotify.o \
- filesystems.o namespace.o seq_file.o xattr.o libfs.o \
- fs-writeback.o mpage.o direct-io.o aio.o
+obj-y := open.o read_write.o file_table.o buffer.o bio.o super.o \
+ block_dev.o char_dev.o stat.o exec.o pipe.o namei.o fcntl.o \
+ ioctl.o readdir.o select.o fifo.o locks.o dcache.o inode.o \
+ attr.o bad_inode.o file.o filesystems.o namespace.o aio.o \
+ seq_file.o xattr.o libfs.o fs-writeback.o mpage.o direct-io.o \
obj-$(CONFIG_EPOLL) += eventpoll.o
obj-$(CONFIG_COMPAT) += compat.o
@@ -38,6 +37,8 @@
obj-$(CONFIG_QFMT_V2) += quota_v2.o
obj-$(CONFIG_QUOTACTL) += quota.o
+obj-$(CONFIG_DNOTIFY) += dnotify.o
+
obj-$(CONFIG_PROC_FS) += proc/
obj-y += partitions/
obj-y += sysfs/
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/namei.c linux-inotify/fs/namei.c
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/namei.c 2004-09-27 03:41:58.000000000 -0400
+++ linux-inotify/fs/namei.c 2004-10-05 16:15:07.000000000 -0400
@@ -23,6 +23,7 @@
#include <linux/quotaops.h>
#include <linux/pagemap.h>
#include <linux/dnotify.h>
+#include <linux/inotify.h>
#include <linux/smp_lock.h>
#include <linux/personality.h>
#include <linux/security.h>
@@ -1232,6 +1233,7 @@
error = dir->i_op->create(dir, dentry, mode, nd);
if (!error) {
inode_dir_notify(dir, DN_CREATE);
+ inotify_inode_queue_event(dir, IN_CREATE_FILE, dentry->d_name.name);
security_inode_post_create(dir, dentry, mode);
}
return error;
@@ -1543,6 +1545,7 @@
error = dir->i_op->mknod(dir, dentry, mode, dev);
if (!error) {
inode_dir_notify(dir, DN_CREATE);
+ inotify_inode_queue_event(dir, IN_CREATE_FILE, dentry->d_name.name);
security_inode_post_mknod(dir, dentry, mode, dev);
}
return error;
@@ -1631,6 +1634,7 @@
error = dir->i_op->mkdir(dir, dentry, mode);
if (!error) {
inode_dir_notify(dir, DN_CREATE);
+ inotify_inode_queue_event(dir, IN_CREATE_SUBDIR, dentry->d_name.name);
security_inode_post_mkdir(dir,dentry, mode);
}
return error;
@@ -1741,6 +1745,9 @@
up(&dentry->d_inode->i_sem);
if (!error) {
inode_dir_notify(dir, DN_DELETE);
+ inotify_inode_queue_event(dir, IN_DELETE_SUBDIR, dentry->d_name.name);
+ inotify_inode_queue_event(dentry->d_inode, IN_DELETE_SELF, NULL);
+ inotify_inode_is_dead (dentry->d_inode);
d_delete(dentry);
}
dput(dentry);
@@ -1827,8 +1834,11 @@
/* We don't d_delete() NFS sillyrenamed files--they still exist. */
if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
- d_delete(dentry);
inode_dir_notify(dir, DN_DELETE);
+ inotify_inode_queue_event(dir, IN_DELETE_FILE, dentry->d_name.name);
+ inotify_inode_queue_event(dentry->d_inode, IN_DELETE_SELF, NULL);
+ inotify_inode_is_dead (dentry->d_inode);
+ d_delete(dentry);
}
return error;
}
@@ -1918,6 +1928,7 @@
error = dir->i_op->symlink(dir, dentry, oldname);
if (!error) {
inode_dir_notify(dir, DN_CREATE);
+ inotify_inode_queue_event(dir, IN_CREATE_FILE, dentry->d_name.name);
security_inode_post_symlink(dir, dentry, oldname);
}
return error;
@@ -2006,6 +2017,7 @@
up(&old_dentry->d_inode->i_sem);
if (!error) {
inode_dir_notify(dir, DN_CREATE);
+ inotify_inode_queue_event(dir, IN_CREATE_FILE, new_dentry->d_name.name);
security_inode_post_link(old_dentry, dir, new_dentry);
}
return error;
@@ -2210,12 +2222,15 @@
else
error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
if (!error) {
- if (old_dir == new_dir)
+ if (old_dir == new_dir) {
inode_dir_notify(old_dir, DN_RENAME);
- else {
+ } else {
inode_dir_notify(old_dir, DN_DELETE);
inode_dir_notify(new_dir, DN_CREATE);
}
+
+ inotify_inode_queue_event (old_dir, IN_MOVED_FROM, old_dentry->d_name.name);
+ inotify_inode_queue_event (new_dir, IN_MOVED_TO, new_dentry->d_name.name);
}
return error;
}
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/open.c linux-inotify/fs/open.c
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/open.c 2004-09-27 03:41:57.000000000 -0400
+++ linux-inotify/fs/open.c 2004-10-05 16:19:06.000000000 -0400
@@ -11,6 +11,7 @@
#include <linux/smp_lock.h>
#include <linux/quotaops.h>
#include <linux/dnotify.h>
+#include <linux/inotify.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/tty.h>
@@ -1066,7 +1067,11 @@
if (!IS_ERR(f)) {
TRIG_EVENT(open_hook, fd,
f->f_dentry->d_name.len,
- f->f_dentry->d_name.name);
+ f->f_dentry->d_name.name);
+ inotify_inode_queue_event(f->f_dentry->d_inode,
+ IN_OPEN, NULL);
+ inotify_dentry_parent_queue_event(f->f_dentry,
+ IN_OPEN, f->f_dentry->d_name.name);
fd_install(fd, f);
} else {
put_unused_fd(fd);
@@ -1153,8 +1158,13 @@
}
}
spin_unlock(&files->file_lock);
- if (!error)
+ if (!error) {
+ inotify_dentry_parent_queue_event(filp->f_dentry, IN_CLOSE,
+ filp->f_dentry->d_name.name);
+ inotify_inode_queue_event(filp->f_dentry->d_inode, IN_CLOSE,
+ NULL);
error = filp_close(filp, files);
+ }
FSHOOK_END(close, error)
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/read_write.c linux-inotify/fs/read_write.c
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/read_write.c 2004-09-27 03:41:54.000000000 -0400
+++ linux-inotify/fs/read_write.c 2004-10-05 16:15:07.000000000 -0400
@@ -11,6 +11,7 @@
#include <linux/uio.h>
#include <linux/smp_lock.h>
#include <linux/dnotify.h>
+#include <linux/inotify.h>
#include <linux/security.h>
#include <linux/module.h>
#include <linux/fshooks.h>
@@ -237,8 +238,11 @@
ret = file->f_op->read(file, buf, count, pos);
else
ret = do_sync_read(file, buf, count, pos);
- if (ret > 0)
+ if (ret > 0) {
dnotify_parent(file->f_dentry, DN_ACCESS);
+ inotify_dentry_parent_queue_event(file->f_dentry, IN_ACCESS, file->f_dentry->d_name.name);
+ inotify_inode_queue_event (file->f_dentry->d_inode, IN_ACCESS, NULL);
+ }
}
}
@@ -281,8 +285,11 @@
ret = file->f_op->write(file, buf, count, pos);
else
ret = do_sync_write(file, buf, count, pos);
- if (ret > 0)
+ if (ret > 0) {
dnotify_parent(file->f_dentry, DN_MODIFY);
+ inotify_dentry_parent_queue_event(file->f_dentry, IN_MODIFY, file->f_dentry->d_name.name);
+ inotify_inode_queue_event (file->f_dentry->d_inode, IN_MODIFY, NULL);
+ }
}
}
@@ -526,9 +533,13 @@
out:
if (iov != iovstack)
kfree(iov);
- if ((ret + (type == READ)) > 0)
+ if ((ret + (type == READ)) > 0) {
dnotify_parent(file->f_dentry,
(type == READ) ? DN_ACCESS : DN_MODIFY);
+ inotify_dentry_parent_queue_event(file->f_dentry,
+ (type == READ) ? IN_ACCESS : IN_MODIFY, file->f_dentry->d_name.name);
+ inotify_inode_queue_event (file->f_dentry->d_inode, (type == READ) ? IN_ACCESS : IN_MODIFY, NULL);
+ }
return ret;
}
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/super.c linux-inotify/fs/super.c
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/fs/super.c 2004-09-27 03:41:54.000000000 -0400
+++ linux-inotify/fs/super.c 2004-10-05 16:15:07.000000000 -0400
@@ -36,6 +36,7 @@
#include <linux/writeback.h> /* for the emergency remount stuff */
#include <linux/idr.h>
#include <asm/uaccess.h>
+#include <linux/inotify.h>
void get_filesystem(struct file_system_type *fs);
@@ -204,6 +205,7 @@
if (root) {
sb->s_root = NULL;
+ inotify_super_block_umount (sb);
shrink_dcache_parent(root);
shrink_dcache_anon(&sb->s_anon);
dput(root);
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/include/linux/dnotify.h linux-inotify/include/linux/dnotify.h
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/include/linux/dnotify.h 2004-04-03 22:36:14.000000000 -0500
+++ linux-inotify/include/linux/dnotify.h 2004-10-05 16:15:07.000000000 -0400
@@ -1,3 +1,5 @@
+#ifndef _LINUX_DNOTIFY_H
+#define _LINUX_DNOTIFY_H
/*
* Directory notification for Linux
*
@@ -8,20 +10,54 @@
struct dnotify_struct {
struct dnotify_struct * dn_next;
- unsigned long dn_mask; /* Events to be notified
- see linux/fcntl.h */
+ unsigned long dn_mask;
int dn_fd;
struct file * dn_filp;
fl_owner_t dn_owner;
};
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+
+#ifdef CONFIG_DNOTIFY
+
extern void __inode_dir_notify(struct inode *, unsigned long);
-extern void dnotify_flush(struct file *filp, fl_owner_t id);
+extern void dnotify_flush(struct file *, fl_owner_t);
extern int fcntl_dirnotify(int, struct file *, unsigned long);
-void dnotify_parent(struct dentry *dentry, unsigned long event);
+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))
+ 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)
+{
+}
+
+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 __ */
+
+#endif /* _LINUX_DNOTIFY_H */
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/include/linux/fs.h linux-inotify/include/linux/fs.h
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/include/linux/fs.h 2004-09-27 03:41:58.000000000 -0400
+++ linux-inotify/include/linux/fs.h 2004-10-05 16:15:07.000000000 -0400
@@ -29,6 +29,7 @@
struct kstatfs;
struct vm_area_struct;
struct vfsmount;
+struct inotify_inode_data;
/*
* It's silly to have NR_OPEN bigger than NR_FILE, but you can change
@@ -63,7 +64,7 @@
};
extern struct inodes_stat_t inodes_stat;
-extern int leases_enable, dir_notify_enable, lease_break_time;
+extern int leases_enable, lease_break_time;
#define NR_FILE 8192 /* this can well be larger on a larger system */
#define NR_RESERVED_FILES 10 /* reserved for root */
@@ -428,8 +429,14 @@
int i_cindex;
void *i_filterdata;
+#ifdef CONFIG_DNOTIFY
unsigned long i_dnotify_mask; /* Directory notify events */
struct dnotify_struct *i_dnotify; /* for directory notifications */
+#endif
+
+#ifdef CONFIG_INOTIFY
+ struct inotify_inode_data *inotify_data;
+#endif
unsigned long i_state;
unsigned long dirtied_when; /* jiffies of first dirtying */
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/include/linux/inotify.h linux-inotify/include/linux/inotify.h
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/include/linux/inotify.h 1969-12-31 19:00:00.000000000 -0500
+++ linux-inotify/include/linux/inotify.h 2004-10-05 16:15:07.000000000 -0400
@@ -0,0 +1,124 @@
+/*
+ * Inode based directory notification for Linux
+ *
+ * Copyright (C) 2004 John McCutchan
+ */
+
+#ifndef _LINUX_INOTIFY_H
+#define _LINUX_INOTIFY_H
+
+#include <linux/types.h>
+#include <linux/limits.h>
+
+/* this size could limit things, since technically we could need PATH_MAX */
+#define INOTIFY_FILENAME_MAX 256
+
+/*
+ * struct inotify_event - structure read from the inotify device for each event
+ *
+ * When you are watching a directory, you will receive the filename for events
+ * such as IN_CREATE, IN_DELETE, IN_OPEN, IN_CLOSE, ...
+ *
+ * Note: When reading from the device you must provide a buffer that is a
+ * multiple of sizeof(struct inotify_event)
+ */
+struct inotify_event {
+ __s32 wd;
+ __u32 mask;
+ __u32 cookie;
+ char filename[INOTIFY_FILENAME_MAX];
+};
+
+/*
+ * struct inotify_watch_request - represents a watch request
+ *
+ * Pass to the inotify device via the INOTIFY_WATCH ioctl
+ */
+struct inotify_watch_request {
+ char *dirname; /* directory name */
+ __u32 mask; /* event mask */
+};
+
+/* the following are legal, implemented events */
+#define IN_ACCESS 0x00000001 /* File was accessed */
+#define IN_MODIFY 0x00000002 /* File was modified */
+#define IN_ATTRIB 0x00000004 /* File changed attributes */
+#define IN_CLOSE 0x00000008 /* File was closed */
+#define IN_OPEN 0x00000010 /* File was opened */
+#define IN_MOVED_FROM 0x00000020 /* File was moved from X */
+#define IN_MOVED_TO 0x00000040 /* File was moved to Y */
+#define IN_DELETE_SUBDIR 0x00000080 /* Subdir was deleted */
+#define IN_DELETE_FILE 0x00000100 /* Subfile was deleted */
+#define IN_CREATE_SUBDIR 0x00000200 /* Subdir was created */
+#define IN_CREATE_FILE 0x00000400 /* Subfile was created */
+#define IN_DELETE_SELF 0x00000800 /* Self was deleted */
+#define IN_UNMOUNT 0x00001000 /* Backing fs was unmounted */
+#define IN_Q_OVERFLOW 0x00002000 /* Event queued overflowed */
+#define IN_IGNORED 0x00004000 /* File was ignored */
+
+/* special flags */
+#define IN_ALL_EVENTS 0xffffffff /* All the events */
+
+#define INOTIFY_IOCTL_MAGIC 'Q'
+#define INOTIFY_IOCTL_MAXNR 4
+
+#define INOTIFY_WATCH _IOR(INOTIFY_IOCTL_MAGIC, 1, struct inotify_watch_request)
+#define INOTIFY_IGNORE _IOR(INOTIFY_IOCTL_MAGIC, 2, int)
+#define INOTIFY_STATS _IOR(INOTIFY_IOCTL_MAGIC, 3, int)
+#define INOTIFY_SETDEBUG _IOR(INOTIFY_IOCTL_MAGIC, 4, int)
+
+#define INOTIFY_DEBUG_NONE 0x00000000
+#define INOTIFY_DEBUG_ALLOC 0x00000001
+#define INOTIFY_DEBUG_EVENTS 0x00000002
+#define INOTIFY_DEBUG_INODE 0x00000004
+#define INOTIFY_DEBUG_ERRORS 0x00000008
+#define INOTIFY_DEBUG_FILEN 0x00000010
+#define INOTIFY_DEBUG_ALL 0xffffffff
+
+#ifdef __KERNEL__
+
+#include <linux/dcache.h>
+#include <linux/fs.h>
+#include <linux/config.h>
+
+struct inotify_inode_data {
+ struct list_head watches;
+ __u32 watch_mask;
+ int watch_count;
+};
+
+#ifdef CONFIG_INOTIFY
+
+extern void inotify_inode_queue_event(struct inode *, __u32, const char *);
+extern void inotify_dentry_parent_queue_event(struct dentry *, __u32,
+ const char *);
+extern void inotify_super_block_umount(struct super_block *);
+extern void inotify_inode_is_dead(struct inode *);
+
+#else
+
+static inline void inotify_inode_queue_event(struct inode *inode,
+ __u32 mask,
+ const char *filename)
+{
+}
+
+static inline void inotify_dentry_parent_queue_event(struct dentry *dentry,
+ __u32 mask,
+ const char *filename)
+{
+}
+
+static inline void inotify_super_block_umount(struct super_block *sb)
+{
+}
+
+static inline void inotify_inode_is_dead(struct inode *inode)
+{
+}
+
+#endif /* CONFIG_INOTIFY */
+
+#endif /* __KERNEL __ */
+
+#endif /* _LINUX_INOTIFY_H */
diff -urN linux-2.6.5-SLES9_GA_BRANCH_200409261010299/kernel/sysctl.c linux-inotify/kernel/sysctl.c
--- linux-2.6.5-SLES9_GA_BRANCH_200409261010299/kernel/sysctl.c 2004-09-27 03:41:57.000000000 -0400
+++ linux-inotify/kernel/sysctl.c 2004-10-05 16:15:07.000000000 -0400
@@ -961,14 +961,6 @@
.proc_handler = &proc_dointvec,
},
{
- .ctl_name = FS_DIR_NOTIFY,
- .procname = "dir-notify-enable",
- .data = &dir_notify_enable,
- .maxlen = sizeof(int),
- .mode = 0644,
- .proc_handler = &proc_dointvec,
- },
- {
.ctl_name = FS_LEASE_TIME,
.procname = "lease-break-time",
.data = &lease_break_time,