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