Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Filesystem access notification for Linux |
| 3 | * |
| 4 | * Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com> |
| 5 | */ |
| 6 | |
| 7 | #ifndef __LINUX_FSNOTIFY_BACKEND_H |
| 8 | #define __LINUX_FSNOTIFY_BACKEND_H |
| 9 | |
| 10 | #ifdef __KERNEL__ |
| 11 | |
Eric Paris | 63c882a | 2009-05-21 17:02:01 -0400 | [diff] [blame] | 12 | #include <linux/idr.h> /* inotify uses this */ |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 13 | #include <linux/fs.h> /* struct inode */ |
| 14 | #include <linux/list.h> |
| 15 | #include <linux/path.h> /* struct path */ |
| 16 | #include <linux/spinlock.h> |
| 17 | #include <linux/types.h> |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 18 | #include <linux/atomic.h> |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 19 | |
| 20 | /* |
| 21 | * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily |
| 22 | * convert between them. dnotify only needs conversion at watch creation |
| 23 | * so no perf loss there. fanotify isn't defined yet, so it can use the |
| 24 | * wholes if it needs more events. |
| 25 | */ |
| 26 | #define FS_ACCESS 0x00000001 /* File was accessed */ |
| 27 | #define FS_MODIFY 0x00000002 /* File was modified */ |
| 28 | #define FS_ATTRIB 0x00000004 /* Metadata changed */ |
| 29 | #define FS_CLOSE_WRITE 0x00000008 /* Writtable file was closed */ |
| 30 | #define FS_CLOSE_NOWRITE 0x00000010 /* Unwrittable file closed */ |
| 31 | #define FS_OPEN 0x00000020 /* File was opened */ |
| 32 | #define FS_MOVED_FROM 0x00000040 /* File was moved from X */ |
| 33 | #define FS_MOVED_TO 0x00000080 /* File was moved to Y */ |
| 34 | #define FS_CREATE 0x00000100 /* Subfile was created */ |
| 35 | #define FS_DELETE 0x00000200 /* Subfile was deleted */ |
| 36 | #define FS_DELETE_SELF 0x00000400 /* Self was deleted */ |
| 37 | #define FS_MOVE_SELF 0x00000800 /* Self was moved */ |
| 38 | |
| 39 | #define FS_UNMOUNT 0x00002000 /* inode on umount fs */ |
| 40 | #define FS_Q_OVERFLOW 0x00004000 /* Event queued overflowed */ |
| 41 | #define FS_IN_IGNORED 0x00008000 /* last inotify event here */ |
| 42 | |
Eric Paris | c4ec54b | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 43 | #define FS_OPEN_PERM 0x00010000 /* open event in an permission hook */ |
| 44 | #define FS_ACCESS_PERM 0x00020000 /* access event in a permissions hook */ |
| 45 | |
Eric Paris | 8c1934c | 2010-07-28 10:18:37 -0400 | [diff] [blame] | 46 | #define FS_EXCL_UNLINK 0x04000000 /* do not send events if object is unlinked */ |
Eric Paris | b29866a | 2010-10-28 17:21:58 -0400 | [diff] [blame] | 47 | #define FS_ISDIR 0x40000000 /* event occurred against dir */ |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 48 | #define FS_IN_ONESHOT 0x80000000 /* only send event once */ |
| 49 | |
| 50 | #define FS_DN_RENAME 0x10000000 /* file renamed */ |
| 51 | #define FS_DN_MULTISHOT 0x20000000 /* dnotify multishot */ |
| 52 | |
Eric Paris | c28f7e5 | 2009-05-21 17:01:29 -0400 | [diff] [blame] | 53 | /* This inode cares about things that happen to its children. Always set for |
| 54 | * dnotify and inotify. */ |
| 55 | #define FS_EVENT_ON_CHILD 0x08000000 |
| 56 | |
| 57 | /* This is a list of all events that may get sent to a parernt based on fs event |
| 58 | * happening to inodes inside that directory */ |
| 59 | #define FS_EVENTS_POSS_ON_CHILD (FS_ACCESS | FS_MODIFY | FS_ATTRIB |\ |
| 60 | FS_CLOSE_WRITE | FS_CLOSE_NOWRITE | FS_OPEN |\ |
| 61 | FS_MOVED_FROM | FS_MOVED_TO | FS_CREATE |\ |
Naohiro Aota | a4f9a9a | 2012-05-29 11:02:24 -0700 | [diff] [blame] | 62 | FS_DELETE | FS_OPEN_PERM | FS_ACCESS_PERM) |
Eric Paris | c28f7e5 | 2009-05-21 17:01:29 -0400 | [diff] [blame] | 63 | |
Eric Paris | e9fd702 | 2009-12-17 20:12:04 -0500 | [diff] [blame] | 64 | #define FS_MOVE (FS_MOVED_FROM | FS_MOVED_TO) |
| 65 | |
Eric Paris | ff8bcbd | 2010-10-28 17:21:56 -0400 | [diff] [blame] | 66 | #define ALL_FSNOTIFY_PERM_EVENTS (FS_OPEN_PERM | FS_ACCESS_PERM) |
| 67 | |
Eric Paris | 20dee62 | 2010-07-28 10:18:37 -0400 | [diff] [blame] | 68 | #define ALL_FSNOTIFY_EVENTS (FS_ACCESS | FS_MODIFY | FS_ATTRIB | \ |
| 69 | FS_CLOSE_WRITE | FS_CLOSE_NOWRITE | FS_OPEN | \ |
| 70 | FS_MOVED_FROM | FS_MOVED_TO | FS_CREATE | \ |
| 71 | FS_DELETE | FS_DELETE_SELF | FS_MOVE_SELF | \ |
| 72 | FS_UNMOUNT | FS_Q_OVERFLOW | FS_IN_IGNORED | \ |
| 73 | FS_OPEN_PERM | FS_ACCESS_PERM | FS_EXCL_UNLINK | \ |
Eric Paris | b29866a | 2010-10-28 17:21:58 -0400 | [diff] [blame] | 74 | FS_ISDIR | FS_IN_ONESHOT | FS_DN_RENAME | \ |
Eric Paris | 20dee62 | 2010-07-28 10:18:37 -0400 | [diff] [blame] | 75 | FS_DN_MULTISHOT | FS_EVENT_ON_CHILD) |
| 76 | |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 77 | struct fsnotify_group; |
| 78 | struct fsnotify_event; |
Eric Paris | e61ce86 | 2009-12-17 21:24:24 -0500 | [diff] [blame] | 79 | struct fsnotify_mark; |
Eric Paris | e4aff11 | 2009-05-21 17:01:50 -0400 | [diff] [blame] | 80 | struct fsnotify_event_private_data; |
Jan Kara | 7053aee | 2014-01-21 15:48:14 -0800 | [diff] [blame] | 81 | struct fsnotify_fname; |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 82 | |
| 83 | /* |
| 84 | * Each group much define these ops. The fsnotify infrastructure will call |
| 85 | * these operations for each relevant group. |
| 86 | * |
| 87 | * handle_event - main call for a group to handle an fs event |
| 88 | * free_group_priv - called when a group refcnt hits 0 to clean up the private union |
Lino Sanfilippo | 6960b0d | 2011-08-12 01:13:31 +0200 | [diff] [blame] | 89 | * freeing_mark - called when a mark is being destroyed for some reason. The group |
| 90 | * MUST be holding a reference on each mark and that reference must be |
| 91 | * dropped in this function. inotify uses this function to send |
| 92 | * userspace messages that marks have been removed. |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 93 | */ |
| 94 | struct fsnotify_ops { |
Eric Paris | ce8f76f | 2010-07-28 10:18:39 -0400 | [diff] [blame] | 95 | int (*handle_event)(struct fsnotify_group *group, |
Jan Kara | 7053aee | 2014-01-21 15:48:14 -0800 | [diff] [blame] | 96 | struct inode *inode, |
Eric Paris | ce8f76f | 2010-07-28 10:18:39 -0400 | [diff] [blame] | 97 | struct fsnotify_mark *inode_mark, |
| 98 | struct fsnotify_mark *vfsmount_mark, |
Jan Kara | 7053aee | 2014-01-21 15:48:14 -0800 | [diff] [blame] | 99 | u32 mask, void *data, int data_type, |
Jan Kara | 45a22f4 | 2014-02-17 13:09:50 +0100 | [diff] [blame] | 100 | const unsigned char *file_name, u32 cookie); |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 101 | void (*free_group_priv)(struct fsnotify_group *group); |
Eric Paris | 841bdc1 | 2009-12-17 21:24:24 -0500 | [diff] [blame] | 102 | void (*freeing_mark)(struct fsnotify_mark *mark, struct fsnotify_group *group); |
Jan Kara | 7053aee | 2014-01-21 15:48:14 -0800 | [diff] [blame] | 103 | void (*free_event)(struct fsnotify_event *event); |
| 104 | }; |
| 105 | |
| 106 | /* |
| 107 | * all of the information about the original object we want to now send to |
| 108 | * a group. If you want to carry more info from the accessing task to the |
| 109 | * listener this structure is where you need to be adding fields. |
| 110 | */ |
| 111 | struct fsnotify_event { |
| 112 | struct list_head list; |
| 113 | /* inode may ONLY be dereferenced during handle_event(). */ |
| 114 | struct inode *inode; /* either the inode the event happened to or its parent */ |
| 115 | u32 mask; /* the type of access, bitwise OR for FS_* event types */ |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 116 | }; |
| 117 | |
| 118 | /* |
| 119 | * A group is a "thing" that wants to receive notification about filesystem |
| 120 | * events. The mask holds the subset of event types this group cares about. |
| 121 | * refcnt on a group is up to the implementor and at any moment if it goes 0 |
| 122 | * everything will be cleaned up. |
| 123 | */ |
| 124 | struct fsnotify_group { |
| 125 | /* |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 126 | * How the refcnt is used is up to each group. When the refcnt hits 0 |
| 127 | * fsnotify will clean up all of the resources associated with this group. |
| 128 | * As an example, the dnotify group will always have a refcnt=1 and that |
| 129 | * will never change. Inotify, on the other hand, has a group per |
| 130 | * inotify_init() and the refcnt will hit 0 only when that fd has been |
| 131 | * closed. |
| 132 | */ |
| 133 | atomic_t refcnt; /* things with interest in this group */ |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 134 | |
| 135 | const struct fsnotify_ops *ops; /* how this group handles things */ |
| 136 | |
Eric Paris | a2d8bc6 | 2009-05-21 17:01:37 -0400 | [diff] [blame] | 137 | /* needed to send notification to userspace */ |
| 138 | struct mutex notification_mutex; /* protect the notification_list */ |
| 139 | struct list_head notification_list; /* list of event_holder this group needs to send to userspace */ |
| 140 | wait_queue_head_t notification_waitq; /* read() on the notification file blocks on this waitq */ |
| 141 | unsigned int q_len; /* events on the queue */ |
| 142 | unsigned int max_events; /* maximum events allowed on the list */ |
Eric Paris | 6ad2d4e | 2010-10-28 17:21:56 -0400 | [diff] [blame] | 143 | /* |
| 144 | * Valid fsnotify group priorities. Events are send in order from highest |
| 145 | * priority to lowest priority. We default to the lowest priority. |
| 146 | */ |
| 147 | #define FS_PRIO_0 0 /* normal notifiers, no permissions */ |
| 148 | #define FS_PRIO_1 1 /* fanotify content based access control */ |
| 149 | #define FS_PRIO_2 2 /* fanotify pre-content access */ |
| 150 | unsigned int priority; |
Eric Paris | a2d8bc6 | 2009-05-21 17:01:37 -0400 | [diff] [blame] | 151 | |
Eric Paris | e61ce86 | 2009-12-17 21:24:24 -0500 | [diff] [blame] | 152 | /* stores all fastpath marks assoc with this group so they can be cleaned on unregister */ |
Lino Sanfilippo | 986ab09 | 2011-06-14 17:29:50 +0200 | [diff] [blame] | 153 | struct mutex mark_mutex; /* protect marks_list */ |
Eric Paris | 841bdc1 | 2009-12-17 21:24:24 -0500 | [diff] [blame] | 154 | atomic_t num_marks; /* 1 for each mark and 1 for not being |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 155 | * past the point of no return when freeing |
| 156 | * a group */ |
Eric Paris | e61ce86 | 2009-12-17 21:24:24 -0500 | [diff] [blame] | 157 | struct list_head marks_list; /* all inode marks for this group */ |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 158 | |
Jan Kara | 7053aee | 2014-01-21 15:48:14 -0800 | [diff] [blame] | 159 | struct fasync_struct *fsn_fa; /* async notification */ |
| 160 | |
Jan Kara | ff57cd5 | 2014-02-21 19:14:11 +0100 | [diff] [blame] | 161 | struct fsnotify_event *overflow_event; /* Event we queue when the |
Jan Kara | 7053aee | 2014-01-21 15:48:14 -0800 | [diff] [blame] | 162 | * notification list is too |
| 163 | * full */ |
Eric Paris | 0a6b6bd | 2011-10-14 17:43:39 -0400 | [diff] [blame] | 164 | |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 165 | /* groups can define private fields here or use the void *private */ |
| 166 | union { |
| 167 | void *private; |
Eric Paris | 63c882a | 2009-05-21 17:02:01 -0400 | [diff] [blame] | 168 | #ifdef CONFIG_INOTIFY_USER |
| 169 | struct inotify_group_private_data { |
| 170 | spinlock_t idr_lock; |
| 171 | struct idr idr; |
Eric Paris | 63c882a | 2009-05-21 17:02:01 -0400 | [diff] [blame] | 172 | struct user_struct *user; |
| 173 | } inotify_data; |
| 174 | #endif |
Eric Paris | 80af258 | 2010-07-28 10:18:37 -0400 | [diff] [blame] | 175 | #ifdef CONFIG_FANOTIFY |
Eric Paris | 9e66e42 | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 176 | struct fanotify_group_private_data { |
Eric Paris | 80af258 | 2010-07-28 10:18:37 -0400 | [diff] [blame] | 177 | #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS |
Eric Paris | 9e66e42 | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 178 | /* allows a group to block waiting for a userspace response */ |
Jan Kara | 9573f79 | 2014-04-03 14:46:34 -0700 | [diff] [blame] | 179 | spinlock_t access_lock; |
Eric Paris | 9e66e42 | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 180 | struct list_head access_list; |
| 181 | wait_queue_head_t access_waitq; |
Lino Sanfilippo | 09e5f14 | 2010-11-19 10:58:07 +0100 | [diff] [blame] | 182 | atomic_t bypass_perm; |
Eric Paris | 80af258 | 2010-07-28 10:18:37 -0400 | [diff] [blame] | 183 | #endif /* CONFIG_FANOTIFY_ACCESS_PERMISSIONS */ |
| 184 | int f_flags; |
Eric Paris | e7099d8 | 2010-10-28 17:21:57 -0400 | [diff] [blame] | 185 | unsigned int max_marks; |
Eric Paris | 4afeff8 | 2010-10-28 17:21:58 -0400 | [diff] [blame] | 186 | struct user_struct *user; |
Eric Paris | 9e66e42 | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 187 | } fanotify_data; |
Eric Paris | 80af258 | 2010-07-28 10:18:37 -0400 | [diff] [blame] | 188 | #endif /* CONFIG_FANOTIFY */ |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 189 | }; |
| 190 | }; |
| 191 | |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 192 | /* when calling fsnotify tell it if the data is a path or inode */ |
| 193 | #define FSNOTIFY_EVENT_NONE 0 |
Linus Torvalds | 2069601 | 2010-08-12 14:23:04 -0700 | [diff] [blame] | 194 | #define FSNOTIFY_EVENT_PATH 1 |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 195 | #define FSNOTIFY_EVENT_INODE 2 |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 196 | |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 197 | /* |
Jan Kara | 1e39fc0 | 2015-09-04 15:43:06 -0700 | [diff] [blame] | 198 | * A mark is simply an object attached to an in core inode which allows an |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 199 | * fsnotify listener to indicate they are either no longer interested in events |
| 200 | * of a type matching mask or only interested in those events. |
| 201 | * |
Jan Kara | 1e39fc0 | 2015-09-04 15:43:06 -0700 | [diff] [blame] | 202 | * These are flushed when an inode is evicted from core and may be flushed |
| 203 | * when the inode is modified (as seen by fsnotify_access). Some fsnotify |
| 204 | * users (such as dnotify) will flush these when the open fd is closed and not |
| 205 | * at inode eviction or modification. |
| 206 | * |
| 207 | * Text in brackets is showing the lock(s) protecting modifications of a |
| 208 | * particular entry. obj_lock means either inode->i_lock or |
| 209 | * mnt->mnt_root->d_lock depending on the mark type. |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 210 | */ |
Eric Paris | e61ce86 | 2009-12-17 21:24:24 -0500 | [diff] [blame] | 211 | struct fsnotify_mark { |
Jan Kara | 1e39fc0 | 2015-09-04 15:43:06 -0700 | [diff] [blame] | 212 | /* Mask this mark is for [mark->lock, group->mark_mutex] */ |
| 213 | __u32 mask; |
| 214 | /* We hold one for presence in g_list. Also one ref for each 'thing' |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 215 | * in kernel that found and may be using this mark. */ |
Jan Kara | 1e39fc0 | 2015-09-04 15:43:06 -0700 | [diff] [blame] | 216 | atomic_t refcnt; |
| 217 | /* Group this mark is for. Set on mark creation, stable until last ref |
| 218 | * is dropped */ |
| 219 | struct fsnotify_group *group; |
| 220 | /* List of marks by group->i_fsnotify_marks. Also reused for queueing |
| 221 | * mark into destroy_list when it's waiting for the end of SRCU period |
| 222 | * before it can be freed. [group->mark_mutex] */ |
Jeff Layton | 13d34ac | 2016-02-17 13:11:18 -0800 | [diff] [blame] | 223 | struct list_head g_list; |
Jan Kara | 1e39fc0 | 2015-09-04 15:43:06 -0700 | [diff] [blame] | 224 | /* Protects inode / mnt pointers, flags, masks */ |
| 225 | spinlock_t lock; |
| 226 | /* List of marks for inode / vfsmount [obj_lock] */ |
| 227 | struct hlist_node obj_list; |
Jan Kara | 1e39fc0 | 2015-09-04 15:43:06 -0700 | [diff] [blame] | 228 | union { /* Object pointer [mark->lock, group->mark_mutex] */ |
Jan Kara | 0809ab6 | 2014-12-12 16:58:36 -0800 | [diff] [blame] | 229 | struct inode *inode; /* inode this mark is associated with */ |
| 230 | struct vfsmount *mnt; /* vfsmount this mark is associated with */ |
Eric Paris | 2823e04 | 2009-12-17 21:24:23 -0500 | [diff] [blame] | 231 | }; |
Jan Kara | 1e39fc0 | 2015-09-04 15:43:06 -0700 | [diff] [blame] | 232 | /* Events types to ignore [mark->lock, group->mark_mutex] */ |
| 233 | __u32 ignored_mask; |
Eric Paris | 90b1e7a | 2009-12-17 21:24:33 -0500 | [diff] [blame] | 234 | #define FSNOTIFY_MARK_FLAG_INODE 0x01 |
| 235 | #define FSNOTIFY_MARK_FLAG_VFSMOUNT 0x02 |
| 236 | #define FSNOTIFY_MARK_FLAG_OBJECT_PINNED 0x04 |
Eric Paris | c908370 | 2009-12-17 21:24:33 -0500 | [diff] [blame] | 237 | #define FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY 0x08 |
Eric Paris | 700307a | 2010-07-28 10:18:38 -0400 | [diff] [blame] | 238 | #define FSNOTIFY_MARK_FLAG_ALIVE 0x10 |
Jan Kara | 4712e722 | 2015-09-04 15:43:12 -0700 | [diff] [blame] | 239 | #define FSNOTIFY_MARK_FLAG_ATTACHED 0x20 |
Jan Kara | 1e39fc0 | 2015-09-04 15:43:06 -0700 | [diff] [blame] | 240 | unsigned int flags; /* flags [mark->lock] */ |
Eric Paris | 841bdc1 | 2009-12-17 21:24:24 -0500 | [diff] [blame] | 241 | void (*free_mark)(struct fsnotify_mark *mark); /* called on final put+free */ |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 242 | }; |
| 243 | |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 244 | #ifdef CONFIG_FSNOTIFY |
| 245 | |
| 246 | /* called from the vfs helpers */ |
| 247 | |
| 248 | /* main fsnotify call to send events */ |
Eric Paris | c4ec54b | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 249 | extern int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is, |
| 250 | const unsigned char *name, u32 cookie); |
Eric Paris | 5242039 | 2010-10-28 17:21:56 -0400 | [diff] [blame] | 251 | extern int __fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask); |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 252 | extern void __fsnotify_inode_delete(struct inode *inode); |
Andreas Gruenbacher | ca9c726 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 253 | extern void __fsnotify_vfsmount_delete(struct vfsmount *mnt); |
Eric Paris | 47882c6 | 2009-05-21 17:01:47 -0400 | [diff] [blame] | 254 | extern u32 fsnotify_get_cookie(void); |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 255 | |
Eric Paris | c28f7e5 | 2009-05-21 17:01:29 -0400 | [diff] [blame] | 256 | static inline int fsnotify_inode_watches_children(struct inode *inode) |
| 257 | { |
| 258 | /* FS_EVENT_ON_CHILD is set if the inode may care */ |
| 259 | if (!(inode->i_fsnotify_mask & FS_EVENT_ON_CHILD)) |
| 260 | return 0; |
| 261 | /* this inode might care about child events, does it care about the |
| 262 | * specific set of events that can happen on a child? */ |
| 263 | return inode->i_fsnotify_mask & FS_EVENTS_POSS_ON_CHILD; |
| 264 | } |
| 265 | |
| 266 | /* |
| 267 | * Update the dentry with a flag indicating the interest of its parent to receive |
| 268 | * filesystem events when those events happens to this dentry->d_inode. |
| 269 | */ |
Al Viro | affda48 | 2016-05-29 18:35:12 -0400 | [diff] [blame] | 270 | static inline void fsnotify_update_flags(struct dentry *dentry) |
Eric Paris | c28f7e5 | 2009-05-21 17:01:29 -0400 | [diff] [blame] | 271 | { |
Eric Paris | c28f7e5 | 2009-05-21 17:01:29 -0400 | [diff] [blame] | 272 | assert_spin_locked(&dentry->d_lock); |
| 273 | |
Nick Piggin | b5c84bf | 2011-01-07 17:49:38 +1100 | [diff] [blame] | 274 | /* |
| 275 | * Serialisation of setting PARENT_WATCHED on the dentries is provided |
| 276 | * by d_lock. If inotify_inode_watched changes after we have taken |
| 277 | * d_lock, the following __fsnotify_update_child_dentry_flags call will |
| 278 | * find our entry, so it will spin until we complete here, and update |
| 279 | * us with the new state. |
| 280 | */ |
Al Viro | affda48 | 2016-05-29 18:35:12 -0400 | [diff] [blame] | 281 | if (fsnotify_inode_watches_children(dentry->d_parent->d_inode)) |
Eric Paris | c28f7e5 | 2009-05-21 17:01:29 -0400 | [diff] [blame] | 282 | dentry->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED; |
| 283 | else |
| 284 | dentry->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED; |
| 285 | } |
| 286 | |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 287 | /* called from fsnotify listeners, such as fanotify or dnotify */ |
| 288 | |
Lino Sanfilippo | 9861295 | 2011-06-14 17:29:46 +0200 | [diff] [blame] | 289 | /* create a new group */ |
Eric Paris | 0d2e2a1 | 2009-12-17 21:24:22 -0500 | [diff] [blame] | 290 | extern struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops); |
Lino Sanfilippo | 9861295 | 2011-06-14 17:29:46 +0200 | [diff] [blame] | 291 | /* get reference to a group */ |
| 292 | extern void fsnotify_get_group(struct fsnotify_group *group); |
Eric Paris | ffab834 | 2009-12-17 21:24:22 -0500 | [diff] [blame] | 293 | /* drop reference on a group from fsnotify_alloc_group */ |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 294 | extern void fsnotify_put_group(struct fsnotify_group *group); |
Lino Sanfilippo | d8153d4 | 2011-06-14 17:29:45 +0200 | [diff] [blame] | 295 | /* destroy group */ |
| 296 | extern void fsnotify_destroy_group(struct fsnotify_group *group); |
Eric Paris | 0a6b6bd | 2011-10-14 17:43:39 -0400 | [diff] [blame] | 297 | /* fasync handler function */ |
| 298 | extern int fsnotify_fasync(int fd, struct file *file, int on); |
Jan Kara | 7053aee | 2014-01-21 15:48:14 -0800 | [diff] [blame] | 299 | /* Free event from memory */ |
| 300 | extern void fsnotify_destroy_event(struct fsnotify_group *group, |
| 301 | struct fsnotify_event *event); |
Eric Paris | a2d8bc6 | 2009-05-21 17:01:37 -0400 | [diff] [blame] | 302 | /* attach the event to the group notification queue */ |
Jan Kara | 8ba8fa91 | 2014-08-06 16:03:26 -0700 | [diff] [blame] | 303 | extern int fsnotify_add_event(struct fsnotify_group *group, |
| 304 | struct fsnotify_event *event, |
| 305 | int (*merge)(struct list_head *, |
| 306 | struct fsnotify_event *)); |
Jan Kara | 5838d44 | 2014-08-06 16:03:28 -0700 | [diff] [blame] | 307 | /* Remove passed event from groups notification queue */ |
| 308 | extern void fsnotify_remove_event(struct fsnotify_group *group, struct fsnotify_event *event); |
Eric Paris | a2d8bc6 | 2009-05-21 17:01:37 -0400 | [diff] [blame] | 309 | /* true if the group notification queue is empty */ |
| 310 | extern bool fsnotify_notify_queue_is_empty(struct fsnotify_group *group); |
| 311 | /* return, but do not dequeue the first event on the notification queue */ |
Jan Kara | 8ba8fa91 | 2014-08-06 16:03:26 -0700 | [diff] [blame] | 312 | extern struct fsnotify_event *fsnotify_peek_first_event(struct fsnotify_group *group); |
Eric Paris | e4aff11 | 2009-05-21 17:01:50 -0400 | [diff] [blame] | 313 | /* return AND dequeue the first event on the notification queue */ |
Jan Kara | 8ba8fa91 | 2014-08-06 16:03:26 -0700 | [diff] [blame] | 314 | extern struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group *group); |
Eric Paris | a2d8bc6 | 2009-05-21 17:01:37 -0400 | [diff] [blame] | 315 | |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 316 | /* functions used to manipulate the marks attached to inodes */ |
| 317 | |
Eric Paris | 0d48b7f | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 318 | /* run all marks associated with a vfsmount and update mnt->mnt_fsnotify_mask */ |
| 319 | extern void fsnotify_recalc_vfsmount_mask(struct vfsmount *mnt); |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 320 | /* run all marks associated with an inode and update inode->i_fsnotify_mask */ |
| 321 | extern void fsnotify_recalc_inode_mask(struct inode *inode); |
Eric Paris | 841bdc1 | 2009-12-17 21:24:24 -0500 | [diff] [blame] | 322 | extern void fsnotify_init_mark(struct fsnotify_mark *mark, void (*free_mark)(struct fsnotify_mark *mark)); |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 323 | /* find (and take a reference) to a mark associated with group and inode */ |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 324 | extern struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group, struct inode *inode); |
Eric Paris | 1c52906 | 2009-12-17 21:24:28 -0500 | [diff] [blame] | 325 | /* find (and take a reference) to a mark associated with group and vfsmount */ |
| 326 | extern struct fsnotify_mark *fsnotify_find_vfsmount_mark(struct fsnotify_group *group, struct vfsmount *mnt); |
Eric Paris | 9e1c743 | 2009-12-17 20:12:05 -0500 | [diff] [blame] | 327 | /* copy the values from old into new */ |
Eric Paris | e61ce86 | 2009-12-17 21:24:24 -0500 | [diff] [blame] | 328 | extern void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old); |
Eric Paris | 33af5e3 | 2009-12-17 21:24:33 -0500 | [diff] [blame] | 329 | /* set the ignored_mask of a mark */ |
| 330 | extern void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask); |
Eric Paris | 90b1e7a | 2009-12-17 21:24:33 -0500 | [diff] [blame] | 331 | /* set the mask of a mark (might pin the object into memory */ |
| 332 | extern void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask); |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 333 | /* attach the mark to both the group and the inode */ |
Eric Paris | 5444e29 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 334 | extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group, |
| 335 | struct inode *inode, struct vfsmount *mnt, int allow_dups); |
Lino Sanfilippo | d5a335b | 2011-06-14 17:29:52 +0200 | [diff] [blame] | 336 | extern int fsnotify_add_mark_locked(struct fsnotify_mark *mark, struct fsnotify_group *group, |
| 337 | struct inode *inode, struct vfsmount *mnt, int allow_dups); |
Lino Sanfilippo | e2a2994 | 2011-06-14 17:29:51 +0200 | [diff] [blame] | 338 | /* given a group and a mark, flag mark to be freed when all references are dropped */ |
| 339 | extern void fsnotify_destroy_mark(struct fsnotify_mark *mark, |
| 340 | struct fsnotify_group *group); |
Jan Kara | 4712e722 | 2015-09-04 15:43:12 -0700 | [diff] [blame] | 341 | /* detach mark from inode / mount list, group list, drop inode reference */ |
| 342 | extern void fsnotify_detach_mark(struct fsnotify_mark *mark); |
| 343 | /* free mark */ |
| 344 | extern void fsnotify_free_mark(struct fsnotify_mark *mark); |
Eric Paris | 4d92604 | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 345 | /* run all the marks in a group, and clear all of the vfsmount marks */ |
| 346 | extern void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group); |
| 347 | /* run all the marks in a group, and clear all of the inode marks */ |
| 348 | extern void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group); |
| 349 | /* run all the marks in a group, and clear all of the marks where mark->flags & flags is true*/ |
| 350 | extern void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, unsigned int flags); |
Eric Paris | 841bdc1 | 2009-12-17 21:24:24 -0500 | [diff] [blame] | 351 | extern void fsnotify_get_mark(struct fsnotify_mark *mark); |
| 352 | extern void fsnotify_put_mark(struct fsnotify_mark *mark); |
Dave Chinner | 74278da | 2015-03-04 12:37:22 -0500 | [diff] [blame] | 353 | extern void fsnotify_unmount_inodes(struct super_block *sb); |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 354 | |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 355 | /* put here because inotify does some weird stuff when destroying watches */ |
Jan Kara | 7053aee | 2014-01-21 15:48:14 -0800 | [diff] [blame] | 356 | extern void fsnotify_init_event(struct fsnotify_event *event, |
| 357 | struct inode *to_tell, u32 mask); |
Eric Paris | b4e4e14 | 2009-12-17 21:24:21 -0500 | [diff] [blame] | 358 | |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 359 | #else |
| 360 | |
Eric Paris | c4ec54b | 2009-12-17 21:24:34 -0500 | [diff] [blame] | 361 | static inline int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is, |
| 362 | const unsigned char *name, u32 cookie) |
| 363 | { |
| 364 | return 0; |
| 365 | } |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 366 | |
Eric Paris | 5242039 | 2010-10-28 17:21:56 -0400 | [diff] [blame] | 367 | static inline int __fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask) |
| 368 | { |
| 369 | return 0; |
| 370 | } |
Eric Paris | c28f7e5 | 2009-05-21 17:01:29 -0400 | [diff] [blame] | 371 | |
Eric Paris | 3be25f4 | 2009-05-21 17:01:26 -0400 | [diff] [blame] | 372 | static inline void __fsnotify_inode_delete(struct inode *inode) |
| 373 | {} |
| 374 | |
Andreas Gruenbacher | ca9c726 | 2009-12-17 21:24:27 -0500 | [diff] [blame] | 375 | static inline void __fsnotify_vfsmount_delete(struct vfsmount *mnt) |
| 376 | {} |
| 377 | |
Al Viro | affda48 | 2016-05-29 18:35:12 -0400 | [diff] [blame] | 378 | static inline void fsnotify_update_flags(struct dentry *dentry) |
Eric Paris | c28f7e5 | 2009-05-21 17:01:29 -0400 | [diff] [blame] | 379 | {} |
| 380 | |
Eric Paris | 47882c6 | 2009-05-21 17:01:47 -0400 | [diff] [blame] | 381 | static inline u32 fsnotify_get_cookie(void) |
| 382 | { |
| 383 | return 0; |
| 384 | } |
| 385 | |
Dave Chinner | 74278da | 2015-03-04 12:37:22 -0500 | [diff] [blame] | 386 | static inline void fsnotify_unmount_inodes(struct super_block *sb) |
Eric Paris | 164bc61 | 2009-05-21 17:01:58 -0400 | [diff] [blame] | 387 | {} |
| 388 | |
Eric Paris | 9058652 | 2009-05-21 17:01:20 -0400 | [diff] [blame] | 389 | #endif /* CONFIG_FSNOTIFY */ |
| 390 | |
| 391 | #endif /* __KERNEL __ */ |
| 392 | |
| 393 | #endif /* __LINUX_FSNOTIFY_BACKEND_H */ |