2009-05-21 21:01:20 +00:00
|
|
|
/*
|
|
|
|
* Filesystem access notification for Linux
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __LINUX_FSNOTIFY_BACKEND_H
|
|
|
|
#define __LINUX_FSNOTIFY_BACKEND_H
|
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
|
2009-05-21 21:02:01 +00:00
|
|
|
#include <linux/idr.h> /* inotify uses this */
|
2009-05-21 21:01:20 +00:00
|
|
|
#include <linux/fs.h> /* struct inode */
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/path.h> /* struct path */
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/types.h>
|
2011-07-26 23:09:06 +00:00
|
|
|
#include <linux/atomic.h>
|
2009-05-21 21:01:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily
|
|
|
|
* convert between them. dnotify only needs conversion at watch creation
|
|
|
|
* so no perf loss there. fanotify isn't defined yet, so it can use the
|
|
|
|
* wholes if it needs more events.
|
|
|
|
*/
|
|
|
|
#define FS_ACCESS 0x00000001 /* File was accessed */
|
|
|
|
#define FS_MODIFY 0x00000002 /* File was modified */
|
|
|
|
#define FS_ATTRIB 0x00000004 /* Metadata changed */
|
|
|
|
#define FS_CLOSE_WRITE 0x00000008 /* Writtable file was closed */
|
|
|
|
#define FS_CLOSE_NOWRITE 0x00000010 /* Unwrittable file closed */
|
|
|
|
#define FS_OPEN 0x00000020 /* File was opened */
|
|
|
|
#define FS_MOVED_FROM 0x00000040 /* File was moved from X */
|
|
|
|
#define FS_MOVED_TO 0x00000080 /* File was moved to Y */
|
|
|
|
#define FS_CREATE 0x00000100 /* Subfile was created */
|
|
|
|
#define FS_DELETE 0x00000200 /* Subfile was deleted */
|
|
|
|
#define FS_DELETE_SELF 0x00000400 /* Self was deleted */
|
|
|
|
#define FS_MOVE_SELF 0x00000800 /* Self was moved */
|
|
|
|
|
|
|
|
#define FS_UNMOUNT 0x00002000 /* inode on umount fs */
|
|
|
|
#define FS_Q_OVERFLOW 0x00004000 /* Event queued overflowed */
|
|
|
|
#define FS_IN_IGNORED 0x00008000 /* last inotify event here */
|
|
|
|
|
2009-12-18 02:24:34 +00:00
|
|
|
#define FS_OPEN_PERM 0x00010000 /* open event in an permission hook */
|
|
|
|
#define FS_ACCESS_PERM 0x00020000 /* access event in a permissions hook */
|
|
|
|
|
2010-07-28 14:18:37 +00:00
|
|
|
#define FS_EXCL_UNLINK 0x04000000 /* do not send events if object is unlinked */
|
2010-10-28 21:21:58 +00:00
|
|
|
#define FS_ISDIR 0x40000000 /* event occurred against dir */
|
2009-05-21 21:01:20 +00:00
|
|
|
#define FS_IN_ONESHOT 0x80000000 /* only send event once */
|
|
|
|
|
|
|
|
#define FS_DN_RENAME 0x10000000 /* file renamed */
|
|
|
|
#define FS_DN_MULTISHOT 0x20000000 /* dnotify multishot */
|
|
|
|
|
2009-05-21 21:01:29 +00:00
|
|
|
/* 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 |\
|
2012-05-29 18:02:24 +00:00
|
|
|
FS_DELETE | FS_OPEN_PERM | FS_ACCESS_PERM)
|
2009-05-21 21:01:29 +00:00
|
|
|
|
2009-12-18 01:12:04 +00:00
|
|
|
#define FS_MOVE (FS_MOVED_FROM | FS_MOVED_TO)
|
|
|
|
|
2010-10-28 21:21:56 +00:00
|
|
|
#define ALL_FSNOTIFY_PERM_EVENTS (FS_OPEN_PERM | FS_ACCESS_PERM)
|
|
|
|
|
2010-07-28 14:18:37 +00:00
|
|
|
#define ALL_FSNOTIFY_EVENTS (FS_ACCESS | FS_MODIFY | FS_ATTRIB | \
|
|
|
|
FS_CLOSE_WRITE | FS_CLOSE_NOWRITE | FS_OPEN | \
|
|
|
|
FS_MOVED_FROM | FS_MOVED_TO | FS_CREATE | \
|
|
|
|
FS_DELETE | FS_DELETE_SELF | FS_MOVE_SELF | \
|
|
|
|
FS_UNMOUNT | FS_Q_OVERFLOW | FS_IN_IGNORED | \
|
|
|
|
FS_OPEN_PERM | FS_ACCESS_PERM | FS_EXCL_UNLINK | \
|
2010-10-28 21:21:58 +00:00
|
|
|
FS_ISDIR | FS_IN_ONESHOT | FS_DN_RENAME | \
|
2010-07-28 14:18:37 +00:00
|
|
|
FS_DN_MULTISHOT | FS_EVENT_ON_CHILD)
|
|
|
|
|
2009-05-21 21:01:20 +00:00
|
|
|
struct fsnotify_group;
|
|
|
|
struct fsnotify_event;
|
2009-12-18 02:24:24 +00:00
|
|
|
struct fsnotify_mark;
|
2009-05-21 21:01:50 +00:00
|
|
|
struct fsnotify_event_private_data;
|
2014-01-21 23:48:14 +00:00
|
|
|
struct fsnotify_fname;
|
2009-05-21 21:01:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Each group much define these ops. The fsnotify infrastructure will call
|
|
|
|
* these operations for each relevant group.
|
|
|
|
*
|
2009-05-21 21:01:26 +00:00
|
|
|
* should_send_event - given a group, inode, and mask this function determines
|
|
|
|
* if the group is interested in this event.
|
2009-05-21 21:01:20 +00:00
|
|
|
* handle_event - main call for a group to handle an fs event
|
|
|
|
* free_group_priv - called when a group refcnt hits 0 to clean up the private union
|
fsnotify: change locking order
On Mon, Aug 01, 2011 at 04:38:22PM -0400, Eric Paris wrote:
>
> I finally built and tested a v3.0 kernel with these patches (I know I'm
> SOOOOOO far behind). Not what I hoped for:
>
> > [ 150.937798] VFS: Busy inodes after unmount of tmpfs. Self-destruct in 5 seconds. Have a nice day...
> > [ 150.945290] BUG: unable to handle kernel NULL pointer dereference at 0000000000000070
> > [ 150.946012] IP: [<ffffffff810ffd58>] shmem_free_inode+0x18/0x50
> > [ 150.946012] PGD 2bf9e067 PUD 2bf9f067 PMD 0
> > [ 150.946012] Oops: 0000 [#1] PREEMPT SMP DEBUG_PAGEALLOC
> > [ 150.946012] CPU 0
> > [ 150.946012] Modules linked in: nfs lockd fscache auth_rpcgss nfs_acl sunrpc ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 ip6table_filter ip6_tables ext4 jbd2 crc16 joydev ata_piix i2c_piix4 pcspkr uinput ipv6 autofs4 usbhid [last unloaded: scsi_wait_scan]
> > [ 150.946012]
> > [ 150.946012] Pid: 2764, comm: syscall_thrash Not tainted 3.0.0+ #1 Red Hat KVM
> > [ 150.946012] RIP: 0010:[<ffffffff810ffd58>] [<ffffffff810ffd58>] shmem_free_inode+0x18/0x50
> > [ 150.946012] RSP: 0018:ffff88002c2e5df8 EFLAGS: 00010282
> > [ 150.946012] RAX: 000000004e370d9f RBX: 0000000000000000 RCX: ffff88003a029438
> > [ 150.946012] RDX: 0000000033630a5f RSI: 0000000000000000 RDI: ffff88003491c240
> > [ 150.946012] RBP: ffff88002c2e5e08 R08: 0000000000000000 R09: 0000000000000000
> > [ 150.946012] R10: 0000000000000000 R11: 0000000000000000 R12: ffff88003a029428
> > [ 150.946012] R13: ffff88003a029428 R14: ffff88003a029428 R15: ffff88003499a610
> > [ 150.946012] FS: 00007f5a05420700(0000) GS:ffff88003f600000(0000) knlGS:0000000000000000
> > [ 150.946012] CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
> > [ 150.946012] CR2: 0000000000000070 CR3: 000000002a662000 CR4: 00000000000006f0
> > [ 150.946012] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
> > [ 150.946012] DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
> > [ 150.946012] Process syscall_thrash (pid: 2764, threadinfo ffff88002c2e4000, task ffff88002bfbc760)
> > [ 150.946012] Stack:
> > [ 150.946012] ffff88003a029438 ffff88003a029428 ffff88002c2e5e38 ffffffff81102f76
> > [ 150.946012] ffff88003a029438 ffff88003a029598 ffffffff8160f9c0 ffff88002c221250
> > [ 150.946012] ffff88002c2e5e68 ffffffff8115e9be ffff88002c2e5e68 ffff88003a029438
> > [ 150.946012] Call Trace:
> > [ 150.946012] [<ffffffff81102f76>] shmem_evict_inode+0x76/0x130
> > [ 150.946012] [<ffffffff8115e9be>] evict+0x7e/0x170
> > [ 150.946012] [<ffffffff8115ee40>] iput_final+0xd0/0x190
> > [ 150.946012] [<ffffffff8115ef33>] iput+0x33/0x40
> > [ 150.946012] [<ffffffff81180205>] fsnotify_destroy_mark_locked+0x145/0x160
> > [ 150.946012] [<ffffffff81180316>] fsnotify_destroy_mark+0x36/0x50
> > [ 150.946012] [<ffffffff81181937>] sys_inotify_rm_watch+0x77/0xd0
> > [ 150.946012] [<ffffffff815aca52>] system_call_fastpath+0x16/0x1b
> > [ 150.946012] Code: 67 4a 00 b8 e4 ff ff ff eb aa 66 0f 1f 84 00 00 00 00 00 55 48 89 e5 48 83 ec 10 48 89 1c 24 4c 89 64 24 08 48 8b 9f 40 05 00 00
> > [ 150.946012] 83 7b 70 00 74 1c 4c 8d a3 80 00 00 00 4c 89 e7 e8 d2 5d 4a
> > [ 150.946012] RIP [<ffffffff810ffd58>] shmem_free_inode+0x18/0x50
> > [ 150.946012] RSP <ffff88002c2e5df8>
> > [ 150.946012] CR2: 0000000000000070
>
> Looks at aweful lot like the problem from:
> http://www.spinics.net/lists/linux-fsdevel/msg46101.html
>
I tried to reproduce this bug with your test program, but without success.
However, if I understand correctly, this occurs since we dont hold any locks when
we call iput() in mark_destroy(), right?
With the patches you tested, iput() is also not called within any lock, since the
groups mark_mutex is released temporarily before iput() is called. This is, since
the original codes behaviour is similar.
However since we now have a mutex as the biggest lock, we can do what you
suggested (http://www.spinics.net/lists/linux-fsdevel/msg46107.html) and
call iput() with the mutex held to avoid the race.
The patch below implements this. It uses nested locking to avoid deadlock in case
we do the final iput() on an inode which still holds marks and thus would take
the mutex again when calling fsnotify_inode_delete() in destroy_inode().
Signed-off-by: Lino Sanfilippo <LinoSanfilippo@gmx.de>
Signed-off-by: Eric Paris <eparis@redhat.com>
2011-08-11 23:13:31 +00:00
|
|
|
* freeing_mark - called when a mark is being destroyed for some reason. The group
|
|
|
|
* MUST be holding a reference on each mark and that reference must be
|
|
|
|
* dropped in this function. inotify uses this function to send
|
|
|
|
* userspace messages that marks have been removed.
|
2009-05-21 21:01:20 +00:00
|
|
|
*/
|
|
|
|
struct fsnotify_ops {
|
2010-07-28 14:18:39 +00:00
|
|
|
int (*handle_event)(struct fsnotify_group *group,
|
2014-01-21 23:48:14 +00:00
|
|
|
struct inode *inode,
|
2010-07-28 14:18:39 +00:00
|
|
|
struct fsnotify_mark *inode_mark,
|
|
|
|
struct fsnotify_mark *vfsmount_mark,
|
2014-01-21 23:48:14 +00:00
|
|
|
u32 mask, void *data, int data_type,
|
2014-02-17 12:09:50 +00:00
|
|
|
const unsigned char *file_name, u32 cookie);
|
2009-05-21 21:01:20 +00:00
|
|
|
void (*free_group_priv)(struct fsnotify_group *group);
|
2009-12-18 02:24:24 +00:00
|
|
|
void (*freeing_mark)(struct fsnotify_mark *mark, struct fsnotify_group *group);
|
2014-01-21 23:48:14 +00:00
|
|
|
void (*free_event)(struct fsnotify_event *event);
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* all of the information about the original object we want to now send to
|
|
|
|
* a group. If you want to carry more info from the accessing task to the
|
|
|
|
* listener this structure is where you need to be adding fields.
|
|
|
|
*/
|
|
|
|
struct fsnotify_event {
|
|
|
|
struct list_head list;
|
|
|
|
/* inode may ONLY be dereferenced during handle_event(). */
|
|
|
|
struct inode *inode; /* either the inode the event happened to or its parent */
|
|
|
|
u32 mask; /* the type of access, bitwise OR for FS_* event types */
|
2009-05-21 21:01:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A group is a "thing" that wants to receive notification about filesystem
|
|
|
|
* events. The mask holds the subset of event types this group cares about.
|
|
|
|
* refcnt on a group is up to the implementor and at any moment if it goes 0
|
|
|
|
* everything will be cleaned up.
|
|
|
|
*/
|
|
|
|
struct fsnotify_group {
|
|
|
|
/*
|
|
|
|
* How the refcnt is used is up to each group. When the refcnt hits 0
|
|
|
|
* fsnotify will clean up all of the resources associated with this group.
|
|
|
|
* As an example, the dnotify group will always have a refcnt=1 and that
|
|
|
|
* will never change. Inotify, on the other hand, has a group per
|
|
|
|
* inotify_init() and the refcnt will hit 0 only when that fd has been
|
|
|
|
* closed.
|
|
|
|
*/
|
|
|
|
atomic_t refcnt; /* things with interest in this group */
|
|
|
|
|
|
|
|
const struct fsnotify_ops *ops; /* how this group handles things */
|
|
|
|
|
2009-05-21 21:01:37 +00:00
|
|
|
/* needed to send notification to userspace */
|
|
|
|
struct mutex notification_mutex; /* protect the notification_list */
|
|
|
|
struct list_head notification_list; /* list of event_holder this group needs to send to userspace */
|
|
|
|
wait_queue_head_t notification_waitq; /* read() on the notification file blocks on this waitq */
|
|
|
|
unsigned int q_len; /* events on the queue */
|
|
|
|
unsigned int max_events; /* maximum events allowed on the list */
|
2010-10-28 21:21:56 +00:00
|
|
|
/*
|
|
|
|
* Valid fsnotify group priorities. Events are send in order from highest
|
|
|
|
* priority to lowest priority. We default to the lowest priority.
|
|
|
|
*/
|
|
|
|
#define FS_PRIO_0 0 /* normal notifiers, no permissions */
|
|
|
|
#define FS_PRIO_1 1 /* fanotify content based access control */
|
|
|
|
#define FS_PRIO_2 2 /* fanotify pre-content access */
|
|
|
|
unsigned int priority;
|
2009-05-21 21:01:37 +00:00
|
|
|
|
2009-12-18 02:24:24 +00:00
|
|
|
/* stores all fastpath marks assoc with this group so they can be cleaned on unregister */
|
2011-06-14 15:29:50 +00:00
|
|
|
struct mutex mark_mutex; /* protect marks_list */
|
2009-12-18 02:24:24 +00:00
|
|
|
atomic_t num_marks; /* 1 for each mark and 1 for not being
|
2009-05-21 21:01:26 +00:00
|
|
|
* past the point of no return when freeing
|
|
|
|
* a group */
|
2009-12-18 02:24:24 +00:00
|
|
|
struct list_head marks_list; /* all inode marks for this group */
|
2009-05-21 21:01:26 +00:00
|
|
|
|
2014-01-21 23:48:14 +00:00
|
|
|
struct fasync_struct *fsn_fa; /* async notification */
|
|
|
|
|
2014-02-21 18:14:11 +00:00
|
|
|
struct fsnotify_event *overflow_event; /* Event we queue when the
|
2014-01-21 23:48:14 +00:00
|
|
|
* notification list is too
|
|
|
|
* full */
|
2011-10-14 21:43:39 +00:00
|
|
|
|
2009-05-21 21:01:20 +00:00
|
|
|
/* groups can define private fields here or use the void *private */
|
|
|
|
union {
|
|
|
|
void *private;
|
2009-05-21 21:02:01 +00:00
|
|
|
#ifdef CONFIG_INOTIFY_USER
|
|
|
|
struct inotify_group_private_data {
|
|
|
|
spinlock_t idr_lock;
|
|
|
|
struct idr idr;
|
|
|
|
struct user_struct *user;
|
|
|
|
} inotify_data;
|
2009-12-18 02:24:34 +00:00
|
|
|
#endif
|
2010-07-28 14:18:37 +00:00
|
|
|
#ifdef CONFIG_FANOTIFY
|
2009-12-18 02:24:34 +00:00
|
|
|
struct fanotify_group_private_data {
|
2010-07-28 14:18:37 +00:00
|
|
|
#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
|
2009-12-18 02:24:34 +00:00
|
|
|
/* allows a group to block waiting for a userspace response */
|
2014-04-03 21:46:34 +00:00
|
|
|
spinlock_t access_lock;
|
2009-12-18 02:24:34 +00:00
|
|
|
struct list_head access_list;
|
|
|
|
wait_queue_head_t access_waitq;
|
2010-11-19 09:58:07 +00:00
|
|
|
atomic_t bypass_perm;
|
2010-07-28 14:18:37 +00:00
|
|
|
#endif /* CONFIG_FANOTIFY_ACCESS_PERMISSIONS */
|
|
|
|
int f_flags;
|
2010-10-28 21:21:57 +00:00
|
|
|
unsigned int max_marks;
|
2010-10-28 21:21:58 +00:00
|
|
|
struct user_struct *user;
|
2009-12-18 02:24:34 +00:00
|
|
|
} fanotify_data;
|
2010-07-28 14:18:37 +00:00
|
|
|
#endif /* CONFIG_FANOTIFY */
|
2009-05-21 21:01:20 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
/* when calling fsnotify tell it if the data is a path or inode */
|
|
|
|
#define FSNOTIFY_EVENT_NONE 0
|
2010-08-12 21:23:04 +00:00
|
|
|
#define FSNOTIFY_EVENT_PATH 1
|
2009-05-21 21:01:20 +00:00
|
|
|
#define FSNOTIFY_EVENT_INODE 2
|
|
|
|
|
2009-12-18 02:24:23 +00:00
|
|
|
/*
|
2009-12-18 02:24:24 +00:00
|
|
|
* Inode specific fields in an fsnotify_mark
|
2009-12-18 02:24:23 +00:00
|
|
|
*/
|
|
|
|
struct fsnotify_inode_mark {
|
2009-12-18 02:24:24 +00:00
|
|
|
struct inode *inode; /* inode this mark is associated with */
|
2009-12-18 02:24:24 +00:00
|
|
|
struct hlist_node i_list; /* list of marks by inode->i_fsnotify_marks */
|
2009-12-18 02:24:23 +00:00
|
|
|
struct list_head free_i_list; /* tmp list used when freeing this mark */
|
|
|
|
};
|
|
|
|
|
2009-12-18 02:24:23 +00:00
|
|
|
/*
|
2009-12-18 02:24:24 +00:00
|
|
|
* Mount point specific fields in an fsnotify_mark
|
2009-12-18 02:24:23 +00:00
|
|
|
*/
|
|
|
|
struct fsnotify_vfsmount_mark {
|
2009-12-18 02:24:24 +00:00
|
|
|
struct vfsmount *mnt; /* vfsmount this mark is associated with */
|
2009-12-18 02:24:24 +00:00
|
|
|
struct hlist_node m_list; /* list of marks by inode->i_fsnotify_marks */
|
2009-12-18 02:24:23 +00:00
|
|
|
struct list_head free_m_list; /* tmp list used when freeing this mark */
|
|
|
|
};
|
|
|
|
|
2009-05-21 21:01:26 +00:00
|
|
|
/*
|
2009-12-18 02:24:24 +00:00
|
|
|
* a mark is simply an object attached to an in core inode which allows an
|
2009-05-21 21:01:26 +00:00
|
|
|
* fsnotify listener to indicate they are either no longer interested in events
|
|
|
|
* of a type matching mask or only interested in those events.
|
|
|
|
*
|
|
|
|
* these are flushed when an inode is evicted from core and may be flushed
|
|
|
|
* when the inode is modified (as seen by fsnotify_access). Some fsnotify users
|
|
|
|
* (such as dnotify) will flush these when the open fd is closed and not at
|
|
|
|
* inode eviction or modification.
|
|
|
|
*/
|
2009-12-18 02:24:24 +00:00
|
|
|
struct fsnotify_mark {
|
2009-12-18 02:24:24 +00:00
|
|
|
__u32 mask; /* mask this mark is for */
|
2009-05-21 21:01:26 +00:00
|
|
|
/* we hold ref for each i_list and g_list. also one ref for each 'thing'
|
|
|
|
* in kernel that found and may be using this mark. */
|
|
|
|
atomic_t refcnt; /* active things looking at this mark */
|
2009-12-18 02:24:24 +00:00
|
|
|
struct fsnotify_group *group; /* group this mark is for */
|
2009-12-18 02:24:24 +00:00
|
|
|
struct list_head g_list; /* list of marks by group->i_fsnotify_marks */
|
2009-12-18 02:24:23 +00:00
|
|
|
spinlock_t lock; /* protect group and inode */
|
|
|
|
union {
|
|
|
|
struct fsnotify_inode_mark i;
|
2009-12-18 02:24:23 +00:00
|
|
|
struct fsnotify_vfsmount_mark m;
|
2009-12-18 02:24:23 +00:00
|
|
|
};
|
2010-10-28 21:21:59 +00:00
|
|
|
__u32 ignored_mask; /* events types to ignore */
|
2009-12-18 02:24:33 +00:00
|
|
|
#define FSNOTIFY_MARK_FLAG_INODE 0x01
|
|
|
|
#define FSNOTIFY_MARK_FLAG_VFSMOUNT 0x02
|
|
|
|
#define FSNOTIFY_MARK_FLAG_OBJECT_PINNED 0x04
|
2009-12-18 02:24:33 +00:00
|
|
|
#define FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY 0x08
|
2010-07-28 14:18:38 +00:00
|
|
|
#define FSNOTIFY_MARK_FLAG_ALIVE 0x10
|
2009-12-18 02:24:24 +00:00
|
|
|
unsigned int flags; /* vfsmount or inode mark? */
|
2010-07-28 14:18:38 +00:00
|
|
|
struct list_head destroy_list;
|
2009-12-18 02:24:24 +00:00
|
|
|
void (*free_mark)(struct fsnotify_mark *mark); /* called on final put+free */
|
2009-05-21 21:01:26 +00:00
|
|
|
};
|
|
|
|
|
2009-05-21 21:01:20 +00:00
|
|
|
#ifdef CONFIG_FSNOTIFY
|
|
|
|
|
|
|
|
/* called from the vfs helpers */
|
|
|
|
|
|
|
|
/* main fsnotify call to send events */
|
2009-12-18 02:24:34 +00:00
|
|
|
extern int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
|
|
|
|
const unsigned char *name, u32 cookie);
|
2010-10-28 21:21:56 +00:00
|
|
|
extern int __fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask);
|
2009-05-21 21:01:26 +00:00
|
|
|
extern void __fsnotify_inode_delete(struct inode *inode);
|
2009-12-18 02:24:27 +00:00
|
|
|
extern void __fsnotify_vfsmount_delete(struct vfsmount *mnt);
|
2009-05-21 21:01:47 +00:00
|
|
|
extern u32 fsnotify_get_cookie(void);
|
2009-05-21 21:01:20 +00:00
|
|
|
|
2009-05-21 21:01:29 +00:00
|
|
|
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(&dentry->d_lock);
|
|
|
|
|
2011-01-07 06:49:38 +00:00
|
|
|
/*
|
|
|
|
* Serialisation of setting PARENT_WATCHED on the dentries is provided
|
|
|
|
* by d_lock. If inotify_inode_watched changes after we have taken
|
|
|
|
* d_lock, the following __fsnotify_update_child_dentry_flags call will
|
|
|
|
* find our entry, so it will spin until we complete here, and update
|
|
|
|
* us with the new state.
|
|
|
|
*/
|
2009-05-21 21:01:29 +00:00
|
|
|
parent = dentry->d_parent;
|
2009-06-29 06:31:58 +00:00
|
|
|
if (parent->d_inode && fsnotify_inode_watches_children(parent->d_inode))
|
2009-05-21 21:01:29 +00:00
|
|
|
dentry->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
|
|
|
|
else
|
|
|
|
dentry->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fsnotify_d_instantiate - instantiate a dentry for inode
|
|
|
|
*/
|
|
|
|
static inline void __fsnotify_d_instantiate(struct dentry *dentry, struct inode *inode)
|
|
|
|
{
|
|
|
|
if (!inode)
|
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock(&dentry->d_lock);
|
|
|
|
__fsnotify_update_dcache_flags(dentry);
|
|
|
|
spin_unlock(&dentry->d_lock);
|
|
|
|
}
|
2009-05-21 21:01:20 +00:00
|
|
|
|
|
|
|
/* called from fsnotify listeners, such as fanotify or dnotify */
|
|
|
|
|
2011-06-14 15:29:46 +00:00
|
|
|
/* create a new group */
|
2009-12-18 02:24:22 +00:00
|
|
|
extern struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops);
|
2011-06-14 15:29:46 +00:00
|
|
|
/* get reference to a group */
|
|
|
|
extern void fsnotify_get_group(struct fsnotify_group *group);
|
2009-12-18 02:24:22 +00:00
|
|
|
/* drop reference on a group from fsnotify_alloc_group */
|
2009-05-21 21:01:20 +00:00
|
|
|
extern void fsnotify_put_group(struct fsnotify_group *group);
|
2011-06-14 15:29:45 +00:00
|
|
|
/* destroy group */
|
|
|
|
extern void fsnotify_destroy_group(struct fsnotify_group *group);
|
2011-10-14 21:43:39 +00:00
|
|
|
/* fasync handler function */
|
|
|
|
extern int fsnotify_fasync(int fd, struct file *file, int on);
|
2014-01-21 23:48:14 +00:00
|
|
|
/* Free event from memory */
|
|
|
|
extern void fsnotify_destroy_event(struct fsnotify_group *group,
|
|
|
|
struct fsnotify_event *event);
|
2009-05-21 21:01:37 +00:00
|
|
|
/* attach the event to the group notification queue */
|
2014-01-28 17:53:22 +00:00
|
|
|
extern int fsnotify_add_notify_event(struct fsnotify_group *group,
|
|
|
|
struct fsnotify_event *event,
|
|
|
|
int (*merge)(struct list_head *,
|
|
|
|
struct fsnotify_event *));
|
2009-05-21 21:01:37 +00:00
|
|
|
/* true if the group notification queue is empty */
|
|
|
|
extern bool fsnotify_notify_queue_is_empty(struct fsnotify_group *group);
|
|
|
|
/* return, but do not dequeue the first event on the notification queue */
|
|
|
|
extern struct fsnotify_event *fsnotify_peek_notify_event(struct fsnotify_group *group);
|
2009-05-21 21:01:50 +00:00
|
|
|
/* return AND dequeue the first event on the notification queue */
|
2009-05-21 21:01:37 +00:00
|
|
|
extern struct fsnotify_event *fsnotify_remove_notify_event(struct fsnotify_group *group);
|
|
|
|
|
2009-05-21 21:01:26 +00:00
|
|
|
/* functions used to manipulate the marks attached to inodes */
|
|
|
|
|
2009-12-18 02:24:27 +00:00
|
|
|
/* run all marks associated with a vfsmount and update mnt->mnt_fsnotify_mask */
|
|
|
|
extern void fsnotify_recalc_vfsmount_mask(struct vfsmount *mnt);
|
2009-05-21 21:01:26 +00:00
|
|
|
/* run all marks associated with an inode and update inode->i_fsnotify_mask */
|
|
|
|
extern void fsnotify_recalc_inode_mask(struct inode *inode);
|
2009-12-18 02:24:24 +00:00
|
|
|
extern void fsnotify_init_mark(struct fsnotify_mark *mark, void (*free_mark)(struct fsnotify_mark *mark));
|
2009-05-21 21:01:26 +00:00
|
|
|
/* find (and take a reference) to a mark associated with group and inode */
|
2009-12-18 02:24:27 +00:00
|
|
|
extern struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group, struct inode *inode);
|
2009-12-18 02:24:28 +00:00
|
|
|
/* find (and take a reference) to a mark associated with group and vfsmount */
|
|
|
|
extern struct fsnotify_mark *fsnotify_find_vfsmount_mark(struct fsnotify_group *group, struct vfsmount *mnt);
|
2009-12-18 01:12:05 +00:00
|
|
|
/* copy the values from old into new */
|
2009-12-18 02:24:24 +00:00
|
|
|
extern void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old);
|
2009-12-18 02:24:33 +00:00
|
|
|
/* set the ignored_mask of a mark */
|
|
|
|
extern void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask);
|
2009-12-18 02:24:33 +00:00
|
|
|
/* set the mask of a mark (might pin the object into memory */
|
|
|
|
extern void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask);
|
2009-05-21 21:01:26 +00:00
|
|
|
/* attach the mark to both the group and the inode */
|
2009-12-18 02:24:27 +00:00
|
|
|
extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group,
|
|
|
|
struct inode *inode, struct vfsmount *mnt, int allow_dups);
|
2011-06-14 15:29:52 +00:00
|
|
|
extern int fsnotify_add_mark_locked(struct fsnotify_mark *mark, struct fsnotify_group *group,
|
|
|
|
struct inode *inode, struct vfsmount *mnt, int allow_dups);
|
2011-06-14 15:29:51 +00:00
|
|
|
/* given a group and a mark, flag mark to be freed when all references are dropped */
|
|
|
|
extern void fsnotify_destroy_mark(struct fsnotify_mark *mark,
|
|
|
|
struct fsnotify_group *group);
|
2011-06-14 15:29:52 +00:00
|
|
|
extern void fsnotify_destroy_mark_locked(struct fsnotify_mark *mark,
|
|
|
|
struct fsnotify_group *group);
|
2009-12-18 02:24:34 +00:00
|
|
|
/* run all the marks in a group, and clear all of the vfsmount marks */
|
|
|
|
extern void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group);
|
|
|
|
/* run all the marks in a group, and clear all of the inode marks */
|
|
|
|
extern void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group);
|
|
|
|
/* run all the marks in a group, and clear all of the marks where mark->flags & flags is true*/
|
|
|
|
extern void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, unsigned int flags);
|
2009-05-21 21:01:26 +00:00
|
|
|
/* run all the marks in a group, and flag them to be freed */
|
|
|
|
extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group);
|
2009-12-18 02:24:24 +00:00
|
|
|
extern void fsnotify_get_mark(struct fsnotify_mark *mark);
|
|
|
|
extern void fsnotify_put_mark(struct fsnotify_mark *mark);
|
2009-05-21 21:01:58 +00:00
|
|
|
extern void fsnotify_unmount_inodes(struct list_head *list);
|
2009-05-21 21:01:26 +00:00
|
|
|
|
2009-05-21 21:01:20 +00:00
|
|
|
/* put here because inotify does some weird stuff when destroying watches */
|
2014-01-21 23:48:14 +00:00
|
|
|
extern void fsnotify_init_event(struct fsnotify_event *event,
|
|
|
|
struct inode *to_tell, u32 mask);
|
2009-12-18 02:24:21 +00:00
|
|
|
|
2009-05-21 21:01:20 +00:00
|
|
|
#else
|
|
|
|
|
2009-12-18 02:24:34 +00:00
|
|
|
static inline int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
|
|
|
|
const unsigned char *name, u32 cookie)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2009-05-21 21:01:26 +00:00
|
|
|
|
2010-10-28 21:21:56 +00:00
|
|
|
static inline int __fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2009-05-21 21:01:29 +00:00
|
|
|
|
2009-05-21 21:01:26 +00:00
|
|
|
static inline void __fsnotify_inode_delete(struct inode *inode)
|
|
|
|
{}
|
|
|
|
|
2009-12-18 02:24:27 +00:00
|
|
|
static inline void __fsnotify_vfsmount_delete(struct vfsmount *mnt)
|
|
|
|
{}
|
|
|
|
|
2009-05-21 21:01:29 +00:00
|
|
|
static inline void __fsnotify_update_dcache_flags(struct dentry *dentry)
|
|
|
|
{}
|
|
|
|
|
|
|
|
static inline void __fsnotify_d_instantiate(struct dentry *dentry, struct inode *inode)
|
|
|
|
{}
|
|
|
|
|
2009-05-21 21:01:47 +00:00
|
|
|
static inline u32 fsnotify_get_cookie(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-21 21:01:58 +00:00
|
|
|
static inline void fsnotify_unmount_inodes(struct list_head *list)
|
|
|
|
{}
|
|
|
|
|
2009-05-21 21:01:20 +00:00
|
|
|
#endif /* CONFIG_FSNOTIFY */
|
|
|
|
|
|
|
|
#endif /* __KERNEL __ */
|
|
|
|
|
|
|
|
#endif /* __LINUX_FSNOTIFY_BACKEND_H */
|