Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0 */
2 : /*
3 : * Filesystem access notification for Linux
4 : *
5 : * Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
6 : */
7 :
8 : #ifndef __LINUX_FSNOTIFY_BACKEND_H
9 : #define __LINUX_FSNOTIFY_BACKEND_H
10 :
11 : #ifdef __KERNEL__
12 :
13 : #include <linux/idr.h> /* inotify uses this */
14 : #include <linux/fs.h> /* struct inode */
15 : #include <linux/list.h>
16 : #include <linux/path.h> /* struct path */
17 : #include <linux/spinlock.h>
18 : #include <linux/types.h>
19 : #include <linux/atomic.h>
20 : #include <linux/user_namespace.h>
21 : #include <linux/refcount.h>
22 : #include <linux/mempool.h>
23 :
24 : /*
25 : * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily
26 : * convert between them. dnotify only needs conversion at watch creation
27 : * so no perf loss there. fanotify isn't defined yet, so it can use the
28 : * wholes if it needs more events.
29 : */
30 : #define FS_ACCESS 0x00000001 /* File was accessed */
31 : #define FS_MODIFY 0x00000002 /* File was modified */
32 : #define FS_ATTRIB 0x00000004 /* Metadata changed */
33 : #define FS_CLOSE_WRITE 0x00000008 /* Writtable file was closed */
34 : #define FS_CLOSE_NOWRITE 0x00000010 /* Unwrittable file closed */
35 : #define FS_OPEN 0x00000020 /* File was opened */
36 : #define FS_MOVED_FROM 0x00000040 /* File was moved from X */
37 : #define FS_MOVED_TO 0x00000080 /* File was moved to Y */
38 : #define FS_CREATE 0x00000100 /* Subfile was created */
39 : #define FS_DELETE 0x00000200 /* Subfile was deleted */
40 : #define FS_DELETE_SELF 0x00000400 /* Self was deleted */
41 : #define FS_MOVE_SELF 0x00000800 /* Self was moved */
42 : #define FS_OPEN_EXEC 0x00001000 /* File was opened for exec */
43 :
44 : #define FS_UNMOUNT 0x00002000 /* inode on umount fs */
45 : #define FS_Q_OVERFLOW 0x00004000 /* Event queued overflowed */
46 : #define FS_ERROR 0x00008000 /* Filesystem Error (fanotify) */
47 :
48 : /*
49 : * FS_IN_IGNORED overloads FS_ERROR. It is only used internally by inotify
50 : * which does not support FS_ERROR.
51 : */
52 : #define FS_IN_IGNORED 0x00008000 /* last inotify event here */
53 :
54 : #define FS_OPEN_PERM 0x00010000 /* open event in an permission hook */
55 : #define FS_ACCESS_PERM 0x00020000 /* access event in a permissions hook */
56 : #define FS_OPEN_EXEC_PERM 0x00040000 /* open/exec event in a permission hook */
57 :
58 : #define FS_EXCL_UNLINK 0x04000000 /* do not send events if object is unlinked */
59 : /*
60 : * Set on inode mark that cares about things that happen to its children.
61 : * Always set for dnotify and inotify.
62 : * Set on inode/sb/mount marks that care about parent/name info.
63 : */
64 : #define FS_EVENT_ON_CHILD 0x08000000
65 :
66 : #define FS_RENAME 0x10000000 /* File was renamed */
67 : #define FS_DN_MULTISHOT 0x20000000 /* dnotify multishot */
68 : #define FS_ISDIR 0x40000000 /* event occurred against dir */
69 : #define FS_IN_ONESHOT 0x80000000 /* only send event once */
70 :
71 : #define FS_MOVE (FS_MOVED_FROM | FS_MOVED_TO)
72 :
73 : /*
74 : * Directory entry modification events - reported only to directory
75 : * where entry is modified and not to a watching parent.
76 : * The watching parent may get an FS_ATTRIB|FS_EVENT_ON_CHILD event
77 : * when a directory entry inside a child subdir changes.
78 : */
79 : #define ALL_FSNOTIFY_DIRENT_EVENTS (FS_CREATE | FS_DELETE | FS_MOVE | FS_RENAME)
80 :
81 : #define ALL_FSNOTIFY_PERM_EVENTS (FS_OPEN_PERM | FS_ACCESS_PERM | \
82 : FS_OPEN_EXEC_PERM)
83 :
84 : /*
85 : * This is a list of all events that may get sent to a parent that is watching
86 : * with flag FS_EVENT_ON_CHILD based on fs event on a child of that directory.
87 : */
88 : #define FS_EVENTS_POSS_ON_CHILD (ALL_FSNOTIFY_PERM_EVENTS | \
89 : FS_ACCESS | FS_MODIFY | FS_ATTRIB | \
90 : FS_CLOSE_WRITE | FS_CLOSE_NOWRITE | \
91 : FS_OPEN | FS_OPEN_EXEC)
92 :
93 : /*
94 : * This is a list of all events that may get sent with the parent inode as the
95 : * @to_tell argument of fsnotify().
96 : * It may include events that can be sent to an inode/sb/mount mark, but cannot
97 : * be sent to a parent watching children.
98 : */
99 : #define FS_EVENTS_POSS_TO_PARENT (FS_EVENTS_POSS_ON_CHILD)
100 :
101 : /* Events that can be reported to backends */
102 : #define ALL_FSNOTIFY_EVENTS (ALL_FSNOTIFY_DIRENT_EVENTS | \
103 : FS_EVENTS_POSS_ON_CHILD | \
104 : FS_DELETE_SELF | FS_MOVE_SELF | \
105 : FS_UNMOUNT | FS_Q_OVERFLOW | FS_IN_IGNORED | \
106 : FS_ERROR)
107 :
108 : /* Extra flags that may be reported with event or control handling of events */
109 : #define ALL_FSNOTIFY_FLAGS (FS_EXCL_UNLINK | FS_ISDIR | FS_IN_ONESHOT | \
110 : FS_DN_MULTISHOT | FS_EVENT_ON_CHILD)
111 :
112 : #define ALL_FSNOTIFY_BITS (ALL_FSNOTIFY_EVENTS | ALL_FSNOTIFY_FLAGS)
113 :
114 : struct fsnotify_group;
115 : struct fsnotify_event;
116 : struct fsnotify_mark;
117 : struct fsnotify_event_private_data;
118 : struct fsnotify_fname;
119 : struct fsnotify_iter_info;
120 :
121 : struct mem_cgroup;
122 :
123 : /*
124 : * Each group much define these ops. The fsnotify infrastructure will call
125 : * these operations for each relevant group.
126 : *
127 : * handle_event - main call for a group to handle an fs event
128 : * @group: group to notify
129 : * @mask: event type and flags
130 : * @data: object that event happened on
131 : * @data_type: type of object for fanotify_data_XXX() accessors
132 : * @dir: optional directory associated with event -
133 : * if @file_name is not NULL, this is the directory that
134 : * @file_name is relative to
135 : * @file_name: optional file name associated with event
136 : * @cookie: inotify rename cookie
137 : * @iter_info: array of marks from this group that are interested in the event
138 : *
139 : * handle_inode_event - simple variant of handle_event() for groups that only
140 : * have inode marks and don't have ignore mask
141 : * @mark: mark to notify
142 : * @mask: event type and flags
143 : * @inode: inode that event happened on
144 : * @dir: optional directory associated with event -
145 : * if @file_name is not NULL, this is the directory that
146 : * @file_name is relative to.
147 : * Either @inode or @dir must be non-NULL.
148 : * @file_name: optional file name associated with event
149 : * @cookie: inotify rename cookie
150 : *
151 : * free_group_priv - called when a group refcnt hits 0 to clean up the private union
152 : * freeing_mark - called when a mark is being destroyed for some reason. The group
153 : * MUST be holding a reference on each mark and that reference must be
154 : * dropped in this function. inotify uses this function to send
155 : * userspace messages that marks have been removed.
156 : */
157 : struct fsnotify_ops {
158 : int (*handle_event)(struct fsnotify_group *group, u32 mask,
159 : const void *data, int data_type, struct inode *dir,
160 : const struct qstr *file_name, u32 cookie,
161 : struct fsnotify_iter_info *iter_info);
162 : int (*handle_inode_event)(struct fsnotify_mark *mark, u32 mask,
163 : struct inode *inode, struct inode *dir,
164 : const struct qstr *file_name, u32 cookie);
165 : void (*free_group_priv)(struct fsnotify_group *group);
166 : void (*freeing_mark)(struct fsnotify_mark *mark, struct fsnotify_group *group);
167 : void (*free_event)(struct fsnotify_group *group, struct fsnotify_event *event);
168 : /* called on final put+free to free memory */
169 : void (*free_mark)(struct fsnotify_mark *mark);
170 : };
171 :
172 : /*
173 : * all of the information about the original object we want to now send to
174 : * a group. If you want to carry more info from the accessing task to the
175 : * listener this structure is where you need to be adding fields.
176 : */
177 : struct fsnotify_event {
178 : struct list_head list;
179 : };
180 :
181 : /*
182 : * A group is a "thing" that wants to receive notification about filesystem
183 : * events. The mask holds the subset of event types this group cares about.
184 : * refcnt on a group is up to the implementor and at any moment if it goes 0
185 : * everything will be cleaned up.
186 : */
187 : struct fsnotify_group {
188 : const struct fsnotify_ops *ops; /* how this group handles things */
189 :
190 : /*
191 : * How the refcnt is used is up to each group. When the refcnt hits 0
192 : * fsnotify will clean up all of the resources associated with this group.
193 : * As an example, the dnotify group will always have a refcnt=1 and that
194 : * will never change. Inotify, on the other hand, has a group per
195 : * inotify_init() and the refcnt will hit 0 only when that fd has been
196 : * closed.
197 : */
198 : refcount_t refcnt; /* things with interest in this group */
199 :
200 : /* needed to send notification to userspace */
201 : spinlock_t notification_lock; /* protect the notification_list */
202 : struct list_head notification_list; /* list of event_holder this group needs to send to userspace */
203 : wait_queue_head_t notification_waitq; /* read() on the notification file blocks on this waitq */
204 : unsigned int q_len; /* events on the queue */
205 : unsigned int max_events; /* maximum events allowed on the list */
206 : /*
207 : * Valid fsnotify group priorities. Events are send in order from highest
208 : * priority to lowest priority. We default to the lowest priority.
209 : */
210 : #define FS_PRIO_0 0 /* normal notifiers, no permissions */
211 : #define FS_PRIO_1 1 /* fanotify content based access control */
212 : #define FS_PRIO_2 2 /* fanotify pre-content access */
213 : unsigned int priority;
214 : bool shutdown; /* group is being shut down, don't queue more events */
215 :
216 : /* stores all fastpath marks assoc with this group so they can be cleaned on unregister */
217 : struct mutex mark_mutex; /* protect marks_list */
218 : atomic_t user_waits; /* Number of tasks waiting for user
219 : * response */
220 : struct list_head marks_list; /* all inode marks for this group */
221 :
222 : struct fasync_struct *fsn_fa; /* async notification */
223 :
224 : struct fsnotify_event *overflow_event; /* Event we queue when the
225 : * notification list is too
226 : * full */
227 :
228 : struct mem_cgroup *memcg; /* memcg to charge allocations */
229 :
230 : /* groups can define private fields here or use the void *private */
231 : union {
232 : void *private;
233 : #ifdef CONFIG_INOTIFY_USER
234 : struct inotify_group_private_data {
235 : spinlock_t idr_lock;
236 : struct idr idr;
237 : struct ucounts *ucounts;
238 : } inotify_data;
239 : #endif
240 : #ifdef CONFIG_FANOTIFY
241 : struct fanotify_group_private_data {
242 : /* Hash table of events for merge */
243 : struct hlist_head *merge_hash;
244 : /* allows a group to block waiting for a userspace response */
245 : struct list_head access_list;
246 : wait_queue_head_t access_waitq;
247 : int flags; /* flags from fanotify_init() */
248 : int f_flags; /* event_f_flags from fanotify_init() */
249 : struct ucounts *ucounts;
250 : mempool_t error_events_pool;
251 : } fanotify_data;
252 : #endif /* CONFIG_FANOTIFY */
253 : };
254 : };
255 :
256 : /* When calling fsnotify tell it if the data is a path or inode */
257 : enum fsnotify_data_type {
258 : FSNOTIFY_EVENT_NONE,
259 : FSNOTIFY_EVENT_PATH,
260 : FSNOTIFY_EVENT_INODE,
261 : FSNOTIFY_EVENT_DENTRY,
262 : FSNOTIFY_EVENT_ERROR,
263 : };
264 :
265 : struct fs_error_report {
266 : int error;
267 : struct inode *inode;
268 : struct super_block *sb;
269 : };
270 :
271 : static inline struct inode *fsnotify_data_inode(const void *data, int data_type)
272 : {
273 0 : switch (data_type) {
274 : case FSNOTIFY_EVENT_INODE:
275 : return (struct inode *)data;
276 : case FSNOTIFY_EVENT_DENTRY:
277 0 : return d_inode(data);
278 : case FSNOTIFY_EVENT_PATH:
279 0 : return d_inode(((const struct path *)data)->dentry);
280 : case FSNOTIFY_EVENT_ERROR:
281 0 : return ((struct fs_error_report *)data)->inode;
282 : default:
283 : return NULL;
284 : }
285 : }
286 :
287 : static inline struct dentry *fsnotify_data_dentry(const void *data, int data_type)
288 : {
289 0 : switch (data_type) {
290 : case FSNOTIFY_EVENT_DENTRY:
291 : /* Non const is needed for dget() */
292 : return (struct dentry *)data;
293 : case FSNOTIFY_EVENT_PATH:
294 0 : return ((const struct path *)data)->dentry;
295 : default:
296 : return NULL;
297 : }
298 : }
299 :
300 : static inline const struct path *fsnotify_data_path(const void *data,
301 : int data_type)
302 : {
303 0 : switch (data_type) {
304 : case FSNOTIFY_EVENT_PATH:
305 : return data;
306 : default:
307 : return NULL;
308 : }
309 : }
310 :
311 : static inline struct super_block *fsnotify_data_sb(const void *data,
312 : int data_type)
313 : {
314 0 : switch (data_type) {
315 : case FSNOTIFY_EVENT_INODE:
316 0 : return ((struct inode *)data)->i_sb;
317 : case FSNOTIFY_EVENT_DENTRY:
318 0 : return ((struct dentry *)data)->d_sb;
319 : case FSNOTIFY_EVENT_PATH:
320 0 : return ((const struct path *)data)->dentry->d_sb;
321 : case FSNOTIFY_EVENT_ERROR:
322 0 : return ((struct fs_error_report *) data)->sb;
323 : default:
324 : return NULL;
325 : }
326 : }
327 :
328 : static inline struct fs_error_report *fsnotify_data_error_report(
329 : const void *data,
330 : int data_type)
331 : {
332 : switch (data_type) {
333 : case FSNOTIFY_EVENT_ERROR:
334 : return (struct fs_error_report *) data;
335 : default:
336 : return NULL;
337 : }
338 : }
339 :
340 : /*
341 : * Index to merged marks iterator array that correlates to a type of watch.
342 : * The type of watched object can be deduced from the iterator type, but not
343 : * the other way around, because an event can match different watched objects
344 : * of the same object type.
345 : * For example, both parent and child are watching an object of type inode.
346 : */
347 : enum fsnotify_iter_type {
348 : FSNOTIFY_ITER_TYPE_INODE,
349 : FSNOTIFY_ITER_TYPE_VFSMOUNT,
350 : FSNOTIFY_ITER_TYPE_SB,
351 : FSNOTIFY_ITER_TYPE_PARENT,
352 : FSNOTIFY_ITER_TYPE_INODE2,
353 : FSNOTIFY_ITER_TYPE_COUNT
354 : };
355 :
356 : /* The type of object that a mark is attached to */
357 : enum fsnotify_obj_type {
358 : FSNOTIFY_OBJ_TYPE_ANY = -1,
359 : FSNOTIFY_OBJ_TYPE_INODE,
360 : FSNOTIFY_OBJ_TYPE_VFSMOUNT,
361 : FSNOTIFY_OBJ_TYPE_SB,
362 : FSNOTIFY_OBJ_TYPE_COUNT,
363 : FSNOTIFY_OBJ_TYPE_DETACHED = FSNOTIFY_OBJ_TYPE_COUNT
364 : };
365 :
366 : static inline bool fsnotify_valid_obj_type(unsigned int obj_type)
367 : {
368 : return (obj_type < FSNOTIFY_OBJ_TYPE_COUNT);
369 : }
370 :
371 : struct fsnotify_iter_info {
372 : struct fsnotify_mark *marks[FSNOTIFY_ITER_TYPE_COUNT];
373 : unsigned int report_mask;
374 : int srcu_idx;
375 : };
376 :
377 : static inline bool fsnotify_iter_should_report_type(
378 : struct fsnotify_iter_info *iter_info, int iter_type)
379 : {
380 0 : return (iter_info->report_mask & (1U << iter_type));
381 : }
382 :
383 : static inline void fsnotify_iter_set_report_type(
384 : struct fsnotify_iter_info *iter_info, int iter_type)
385 : {
386 0 : iter_info->report_mask |= (1U << iter_type);
387 : }
388 :
389 : static inline void fsnotify_iter_set_report_type_mark(
390 : struct fsnotify_iter_info *iter_info, int iter_type,
391 : struct fsnotify_mark *mark)
392 : {
393 : iter_info->marks[iter_type] = mark;
394 : iter_info->report_mask |= (1U << iter_type);
395 : }
396 :
397 : #define FSNOTIFY_ITER_FUNCS(name, NAME) \
398 : static inline struct fsnotify_mark *fsnotify_iter_##name##_mark( \
399 : struct fsnotify_iter_info *iter_info) \
400 : { \
401 : return (iter_info->report_mask & (1U << FSNOTIFY_ITER_TYPE_##NAME)) ? \
402 : iter_info->marks[FSNOTIFY_ITER_TYPE_##NAME] : NULL; \
403 : }
404 :
405 0 : FSNOTIFY_ITER_FUNCS(inode, INODE)
406 0 : FSNOTIFY_ITER_FUNCS(parent, PARENT)
407 0 : FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT)
408 0 : FSNOTIFY_ITER_FUNCS(sb, SB)
409 :
410 : #define fsnotify_foreach_iter_type(type) \
411 : for (type = 0; type < FSNOTIFY_ITER_TYPE_COUNT; type++)
412 :
413 : /*
414 : * fsnotify_connp_t is what we embed in objects which connector can be attached
415 : * to. fsnotify_connp_t * is how we refer from connector back to object.
416 : */
417 : struct fsnotify_mark_connector;
418 : typedef struct fsnotify_mark_connector __rcu *fsnotify_connp_t;
419 :
420 : /*
421 : * Inode/vfsmount/sb point to this structure which tracks all marks attached to
422 : * the inode/vfsmount/sb. The reference to inode/vfsmount/sb is held by this
423 : * structure. We destroy this structure when there are no more marks attached
424 : * to it. The structure is protected by fsnotify_mark_srcu.
425 : */
426 : struct fsnotify_mark_connector {
427 : spinlock_t lock;
428 : unsigned short type; /* Type of object [lock] */
429 : #define FSNOTIFY_CONN_FLAG_HAS_FSID 0x01
430 : unsigned short flags; /* flags [lock] */
431 : __kernel_fsid_t fsid; /* fsid of filesystem containing object */
432 : union {
433 : /* Object pointer [lock] */
434 : fsnotify_connp_t *obj;
435 : /* Used listing heads to free after srcu period expires */
436 : struct fsnotify_mark_connector *destroy_next;
437 : };
438 : struct hlist_head list;
439 : };
440 :
441 : /*
442 : * A mark is simply an object attached to an in core inode which allows an
443 : * fsnotify listener to indicate they are either no longer interested in events
444 : * of a type matching mask or only interested in those events.
445 : *
446 : * These are flushed when an inode is evicted from core and may be flushed
447 : * when the inode is modified (as seen by fsnotify_access). Some fsnotify
448 : * users (such as dnotify) will flush these when the open fd is closed and not
449 : * at inode eviction or modification.
450 : *
451 : * Text in brackets is showing the lock(s) protecting modifications of a
452 : * particular entry. obj_lock means either inode->i_lock or
453 : * mnt->mnt_root->d_lock depending on the mark type.
454 : */
455 : struct fsnotify_mark {
456 : /* Mask this mark is for [mark->lock, group->mark_mutex] */
457 : __u32 mask;
458 : /* We hold one for presence in g_list. Also one ref for each 'thing'
459 : * in kernel that found and may be using this mark. */
460 : refcount_t refcnt;
461 : /* Group this mark is for. Set on mark creation, stable until last ref
462 : * is dropped */
463 : struct fsnotify_group *group;
464 : /* List of marks by group->marks_list. Also reused for queueing
465 : * mark into destroy_list when it's waiting for the end of SRCU period
466 : * before it can be freed. [group->mark_mutex] */
467 : struct list_head g_list;
468 : /* Protects inode / mnt pointers, flags, masks */
469 : spinlock_t lock;
470 : /* List of marks for inode / vfsmount [connector->lock, mark ref] */
471 : struct hlist_node obj_list;
472 : /* Head of list of marks for an object [mark ref] */
473 : struct fsnotify_mark_connector *connector;
474 : /* Events types to ignore [mark->lock, group->mark_mutex] */
475 : __u32 ignored_mask;
476 : #define FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY 0x01
477 : #define FSNOTIFY_MARK_FLAG_ALIVE 0x02
478 : #define FSNOTIFY_MARK_FLAG_ATTACHED 0x04
479 : unsigned int flags; /* flags [mark->lock] */
480 : };
481 :
482 : #ifdef CONFIG_FSNOTIFY
483 :
484 : /* called from the vfs helpers */
485 :
486 : /* main fsnotify call to send events */
487 : extern int fsnotify(__u32 mask, const void *data, int data_type,
488 : struct inode *dir, const struct qstr *name,
489 : struct inode *inode, u32 cookie);
490 : extern int __fsnotify_parent(struct dentry *dentry, __u32 mask, const void *data,
491 : int data_type);
492 : extern void __fsnotify_inode_delete(struct inode *inode);
493 : extern void __fsnotify_vfsmount_delete(struct vfsmount *mnt);
494 : extern void fsnotify_sb_delete(struct super_block *sb);
495 : extern u32 fsnotify_get_cookie(void);
496 :
497 : static inline __u32 fsnotify_parent_needed_mask(__u32 mask)
498 : {
499 : /* FS_EVENT_ON_CHILD is set on marks that want parent/name info */
500 0 : if (!(mask & FS_EVENT_ON_CHILD))
501 : return 0;
502 : /*
503 : * This object might be watched by a mark that cares about parent/name
504 : * info, does it care about the specific set of events that can be
505 : * reported with parent/name info?
506 : */
507 0 : return mask & FS_EVENTS_POSS_TO_PARENT;
508 : }
509 :
510 : static inline int fsnotify_inode_watches_children(struct inode *inode)
511 : {
512 : /* FS_EVENT_ON_CHILD is set if the inode may care */
513 15 : if (!(inode->i_fsnotify_mask & FS_EVENT_ON_CHILD))
514 : return 0;
515 : /* this inode might care about child events, does it care about the
516 : * specific set of events that can happen on a child? */
517 0 : return inode->i_fsnotify_mask & FS_EVENTS_POSS_ON_CHILD;
518 : }
519 :
520 : /*
521 : * Update the dentry with a flag indicating the interest of its parent to receive
522 : * filesystem events when those events happens to this dentry->d_inode.
523 : */
524 : static inline void fsnotify_update_flags(struct dentry *dentry)
525 : {
526 : assert_spin_locked(&dentry->d_lock);
527 :
528 : /*
529 : * Serialisation of setting PARENT_WATCHED on the dentries is provided
530 : * by d_lock. If inotify_inode_watched changes after we have taken
531 : * d_lock, the following __fsnotify_update_child_dentry_flags call will
532 : * find our entry, so it will spin until we complete here, and update
533 : * us with the new state.
534 : */
535 30 : if (fsnotify_inode_watches_children(dentry->d_parent->d_inode))
536 0 : dentry->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
537 : else
538 15 : dentry->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;
539 : }
540 :
541 : /* called from fsnotify listeners, such as fanotify or dnotify */
542 :
543 : /* create a new group */
544 : extern struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops);
545 : extern struct fsnotify_group *fsnotify_alloc_user_group(const struct fsnotify_ops *ops);
546 : /* get reference to a group */
547 : extern void fsnotify_get_group(struct fsnotify_group *group);
548 : /* drop reference on a group from fsnotify_alloc_group */
549 : extern void fsnotify_put_group(struct fsnotify_group *group);
550 : /* group destruction begins, stop queuing new events */
551 : extern void fsnotify_group_stop_queueing(struct fsnotify_group *group);
552 : /* destroy group */
553 : extern void fsnotify_destroy_group(struct fsnotify_group *group);
554 : /* fasync handler function */
555 : extern int fsnotify_fasync(int fd, struct file *file, int on);
556 : /* Free event from memory */
557 : extern void fsnotify_destroy_event(struct fsnotify_group *group,
558 : struct fsnotify_event *event);
559 : /* attach the event to the group notification queue */
560 : extern int fsnotify_insert_event(struct fsnotify_group *group,
561 : struct fsnotify_event *event,
562 : int (*merge)(struct fsnotify_group *,
563 : struct fsnotify_event *),
564 : void (*insert)(struct fsnotify_group *,
565 : struct fsnotify_event *));
566 :
567 : static inline int fsnotify_add_event(struct fsnotify_group *group,
568 : struct fsnotify_event *event,
569 : int (*merge)(struct fsnotify_group *,
570 : struct fsnotify_event *))
571 : {
572 0 : return fsnotify_insert_event(group, event, merge, NULL);
573 : }
574 :
575 : /* Queue overflow event to a notification group */
576 : static inline void fsnotify_queue_overflow(struct fsnotify_group *group)
577 : {
578 0 : fsnotify_add_event(group, group->overflow_event, NULL);
579 : }
580 :
581 : static inline bool fsnotify_is_overflow_event(u32 mask)
582 : {
583 : return mask & FS_Q_OVERFLOW;
584 : }
585 :
586 : static inline bool fsnotify_notify_queue_is_empty(struct fsnotify_group *group)
587 : {
588 : assert_spin_locked(&group->notification_lock);
589 :
590 0 : return list_empty(&group->notification_list);
591 : }
592 :
593 : extern bool fsnotify_notify_queue_is_empty(struct fsnotify_group *group);
594 : /* return, but do not dequeue the first event on the notification queue */
595 : extern struct fsnotify_event *fsnotify_peek_first_event(struct fsnotify_group *group);
596 : /* return AND dequeue the first event on the notification queue */
597 : extern struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group *group);
598 : /* Remove event queued in the notification list */
599 : extern void fsnotify_remove_queued_event(struct fsnotify_group *group,
600 : struct fsnotify_event *event);
601 :
602 : /* functions used to manipulate the marks attached to inodes */
603 :
604 : /* Get mask for calculating object interest taking ignored mask into account */
605 : static inline __u32 fsnotify_calc_mask(struct fsnotify_mark *mark)
606 : {
607 0 : __u32 mask = mark->mask;
608 :
609 0 : if (!mark->ignored_mask)
610 : return mask;
611 :
612 : /* Interest in FS_MODIFY may be needed for clearing ignored mask */
613 0 : if (!(mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY))
614 0 : mask |= FS_MODIFY;
615 :
616 : /*
617 : * If mark is interested in ignoring events on children, the object must
618 : * show interest in those events for fsnotify_parent() to notice it.
619 : */
620 0 : return mask | (mark->ignored_mask & ALL_FSNOTIFY_EVENTS);
621 : }
622 :
623 : /* Get mask of events for a list of marks */
624 : extern __u32 fsnotify_conn_mask(struct fsnotify_mark_connector *conn);
625 : /* Calculate mask of events for a list of marks */
626 : extern void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn);
627 : extern void fsnotify_init_mark(struct fsnotify_mark *mark,
628 : struct fsnotify_group *group);
629 : /* Find mark belonging to given group in the list of marks */
630 : extern struct fsnotify_mark *fsnotify_find_mark(fsnotify_connp_t *connp,
631 : struct fsnotify_group *group);
632 : /* Get cached fsid of filesystem containing object */
633 : extern int fsnotify_get_conn_fsid(const struct fsnotify_mark_connector *conn,
634 : __kernel_fsid_t *fsid);
635 : /* attach the mark to the object */
636 : extern int fsnotify_add_mark(struct fsnotify_mark *mark,
637 : fsnotify_connp_t *connp, unsigned int obj_type,
638 : int allow_dups, __kernel_fsid_t *fsid);
639 : extern int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
640 : fsnotify_connp_t *connp,
641 : unsigned int obj_type, int allow_dups,
642 : __kernel_fsid_t *fsid);
643 :
644 : /* attach the mark to the inode */
645 : static inline int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
646 : struct inode *inode,
647 : int allow_dups)
648 : {
649 : return fsnotify_add_mark(mark, &inode->i_fsnotify_marks,
650 : FSNOTIFY_OBJ_TYPE_INODE, allow_dups, NULL);
651 : }
652 : static inline int fsnotify_add_inode_mark_locked(struct fsnotify_mark *mark,
653 : struct inode *inode,
654 : int allow_dups)
655 : {
656 0 : return fsnotify_add_mark_locked(mark, &inode->i_fsnotify_marks,
657 : FSNOTIFY_OBJ_TYPE_INODE, allow_dups,
658 : NULL);
659 : }
660 :
661 : /* given a group and a mark, flag mark to be freed when all references are dropped */
662 : extern void fsnotify_destroy_mark(struct fsnotify_mark *mark,
663 : struct fsnotify_group *group);
664 : /* detach mark from inode / mount list, group list, drop inode reference */
665 : extern void fsnotify_detach_mark(struct fsnotify_mark *mark);
666 : /* free mark */
667 : extern void fsnotify_free_mark(struct fsnotify_mark *mark);
668 : /* Wait until all marks queued for destruction are destroyed */
669 : extern void fsnotify_wait_marks_destroyed(void);
670 : /* Clear all of the marks of a group attached to a given object type */
671 : extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group,
672 : unsigned int obj_type);
673 : /* run all the marks in a group, and clear all of the vfsmount marks */
674 : static inline void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group)
675 : {
676 : fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_VFSMOUNT);
677 : }
678 : /* run all the marks in a group, and clear all of the inode marks */
679 : static inline void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
680 : {
681 : fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_INODE);
682 : }
683 : /* run all the marks in a group, and clear all of the sn marks */
684 : static inline void fsnotify_clear_sb_marks_by_group(struct fsnotify_group *group)
685 : {
686 : fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_SB);
687 : }
688 : extern void fsnotify_get_mark(struct fsnotify_mark *mark);
689 : extern void fsnotify_put_mark(struct fsnotify_mark *mark);
690 : extern void fsnotify_finish_user_wait(struct fsnotify_iter_info *iter_info);
691 : extern bool fsnotify_prepare_user_wait(struct fsnotify_iter_info *iter_info);
692 :
693 : static inline void fsnotify_init_event(struct fsnotify_event *event)
694 : {
695 0 : INIT_LIST_HEAD(&event->list);
696 : }
697 :
698 : #else
699 :
700 : static inline int fsnotify(__u32 mask, const void *data, int data_type,
701 : struct inode *dir, const struct qstr *name,
702 : struct inode *inode, u32 cookie)
703 : {
704 : return 0;
705 : }
706 :
707 : static inline int __fsnotify_parent(struct dentry *dentry, __u32 mask,
708 : const void *data, int data_type)
709 : {
710 : return 0;
711 : }
712 :
713 : static inline void __fsnotify_inode_delete(struct inode *inode)
714 : {}
715 :
716 : static inline void __fsnotify_vfsmount_delete(struct vfsmount *mnt)
717 : {}
718 :
719 : static inline void fsnotify_sb_delete(struct super_block *sb)
720 : {}
721 :
722 : static inline void fsnotify_update_flags(struct dentry *dentry)
723 : {}
724 :
725 : static inline u32 fsnotify_get_cookie(void)
726 : {
727 : return 0;
728 : }
729 :
730 : static inline void fsnotify_unmount_inodes(struct super_block *sb)
731 : {}
732 :
733 : #endif /* CONFIG_FSNOTIFY */
734 :
735 : #endif /* __KERNEL __ */
736 :
737 : #endif /* __LINUX_FSNOTIFY_BACKEND_H */
|
