Loading...
1/* SPDX-License-Identifier: GPL-2.0 */
2#include <linux/fsnotify_backend.h>
3#include <linux/path.h>
4#include <linux/slab.h>
5#include <linux/exportfs.h>
6#include <linux/hashtable.h>
7
8extern struct kmem_cache *fanotify_mark_cache;
9extern struct kmem_cache *fanotify_fid_event_cachep;
10extern struct kmem_cache *fanotify_path_event_cachep;
11extern struct kmem_cache *fanotify_perm_event_cachep;
12
13/* Possible states of the permission event */
14enum {
15 FAN_EVENT_INIT,
16 FAN_EVENT_REPORTED,
17 FAN_EVENT_ANSWERED,
18 FAN_EVENT_CANCELED,
19};
20
21/*
22 * 3 dwords are sufficient for most local fs (64bit ino, 32bit generation).
23 * fh buf should be dword aligned. On 64bit arch, the ext_buf pointer is
24 * stored in either the first or last 2 dwords.
25 */
26#define FANOTIFY_INLINE_FH_LEN (3 << 2)
27#define FANOTIFY_FH_HDR_LEN offsetof(struct fanotify_fh, buf)
28
29/* Fixed size struct for file handle */
30struct fanotify_fh {
31 u8 type;
32 u8 len;
33#define FANOTIFY_FH_FLAG_EXT_BUF 1
34 u8 flags;
35 u8 pad;
36 unsigned char buf[];
37} __aligned(4);
38
39/* Variable size struct for dir file handle + child file handle + name */
40struct fanotify_info {
41 /* size of dir_fh/file_fh including fanotify_fh hdr size */
42 u8 dir_fh_totlen;
43 u8 dir2_fh_totlen;
44 u8 file_fh_totlen;
45 u8 name_len;
46 u8 name2_len;
47 u8 pad[3];
48 unsigned char buf[];
49 /*
50 * (struct fanotify_fh) dir_fh starts at buf[0]
51 * (optional) dir2_fh starts at buf[dir_fh_totlen]
52 * (optional) file_fh starts at buf[dir_fh_totlen + dir2_fh_totlen]
53 * name starts at buf[dir_fh_totlen + dir2_fh_totlen + file_fh_totlen]
54 * ...
55 */
56#define FANOTIFY_DIR_FH_SIZE(info) ((info)->dir_fh_totlen)
57#define FANOTIFY_DIR2_FH_SIZE(info) ((info)->dir2_fh_totlen)
58#define FANOTIFY_FILE_FH_SIZE(info) ((info)->file_fh_totlen)
59#define FANOTIFY_NAME_SIZE(info) ((info)->name_len + 1)
60#define FANOTIFY_NAME2_SIZE(info) ((info)->name2_len + 1)
61
62#define FANOTIFY_DIR_FH_OFFSET(info) 0
63#define FANOTIFY_DIR2_FH_OFFSET(info) \
64 (FANOTIFY_DIR_FH_OFFSET(info) + FANOTIFY_DIR_FH_SIZE(info))
65#define FANOTIFY_FILE_FH_OFFSET(info) \
66 (FANOTIFY_DIR2_FH_OFFSET(info) + FANOTIFY_DIR2_FH_SIZE(info))
67#define FANOTIFY_NAME_OFFSET(info) \
68 (FANOTIFY_FILE_FH_OFFSET(info) + FANOTIFY_FILE_FH_SIZE(info))
69#define FANOTIFY_NAME2_OFFSET(info) \
70 (FANOTIFY_NAME_OFFSET(info) + FANOTIFY_NAME_SIZE(info))
71
72#define FANOTIFY_DIR_FH_BUF(info) \
73 ((info)->buf + FANOTIFY_DIR_FH_OFFSET(info))
74#define FANOTIFY_DIR2_FH_BUF(info) \
75 ((info)->buf + FANOTIFY_DIR2_FH_OFFSET(info))
76#define FANOTIFY_FILE_FH_BUF(info) \
77 ((info)->buf + FANOTIFY_FILE_FH_OFFSET(info))
78#define FANOTIFY_NAME_BUF(info) \
79 ((info)->buf + FANOTIFY_NAME_OFFSET(info))
80#define FANOTIFY_NAME2_BUF(info) \
81 ((info)->buf + FANOTIFY_NAME2_OFFSET(info))
82} __aligned(4);
83
84static inline bool fanotify_fh_has_ext_buf(struct fanotify_fh *fh)
85{
86 return (fh->flags & FANOTIFY_FH_FLAG_EXT_BUF);
87}
88
89static inline char **fanotify_fh_ext_buf_ptr(struct fanotify_fh *fh)
90{
91 BUILD_BUG_ON(FANOTIFY_FH_HDR_LEN % 4);
92 BUILD_BUG_ON(__alignof__(char *) - 4 + sizeof(char *) >
93 FANOTIFY_INLINE_FH_LEN);
94 return (char **)ALIGN((unsigned long)(fh->buf), __alignof__(char *));
95}
96
97static inline void *fanotify_fh_ext_buf(struct fanotify_fh *fh)
98{
99 return *fanotify_fh_ext_buf_ptr(fh);
100}
101
102static inline void *fanotify_fh_buf(struct fanotify_fh *fh)
103{
104 return fanotify_fh_has_ext_buf(fh) ? fanotify_fh_ext_buf(fh) : fh->buf;
105}
106
107static inline int fanotify_info_dir_fh_len(struct fanotify_info *info)
108{
109 if (!info->dir_fh_totlen ||
110 WARN_ON_ONCE(info->dir_fh_totlen < FANOTIFY_FH_HDR_LEN))
111 return 0;
112
113 return info->dir_fh_totlen - FANOTIFY_FH_HDR_LEN;
114}
115
116static inline struct fanotify_fh *fanotify_info_dir_fh(struct fanotify_info *info)
117{
118 BUILD_BUG_ON(offsetof(struct fanotify_info, buf) % 4);
119
120 return (struct fanotify_fh *)FANOTIFY_DIR_FH_BUF(info);
121}
122
123static inline int fanotify_info_dir2_fh_len(struct fanotify_info *info)
124{
125 if (!info->dir2_fh_totlen ||
126 WARN_ON_ONCE(info->dir2_fh_totlen < FANOTIFY_FH_HDR_LEN))
127 return 0;
128
129 return info->dir2_fh_totlen - FANOTIFY_FH_HDR_LEN;
130}
131
132static inline struct fanotify_fh *fanotify_info_dir2_fh(struct fanotify_info *info)
133{
134 return (struct fanotify_fh *)FANOTIFY_DIR2_FH_BUF(info);
135}
136
137static inline int fanotify_info_file_fh_len(struct fanotify_info *info)
138{
139 if (!info->file_fh_totlen ||
140 WARN_ON_ONCE(info->file_fh_totlen < FANOTIFY_FH_HDR_LEN))
141 return 0;
142
143 return info->file_fh_totlen - FANOTIFY_FH_HDR_LEN;
144}
145
146static inline struct fanotify_fh *fanotify_info_file_fh(struct fanotify_info *info)
147{
148 return (struct fanotify_fh *)FANOTIFY_FILE_FH_BUF(info);
149}
150
151static inline char *fanotify_info_name(struct fanotify_info *info)
152{
153 if (!info->name_len)
154 return NULL;
155
156 return FANOTIFY_NAME_BUF(info);
157}
158
159static inline char *fanotify_info_name2(struct fanotify_info *info)
160{
161 if (!info->name2_len)
162 return NULL;
163
164 return FANOTIFY_NAME2_BUF(info);
165}
166
167static inline void fanotify_info_init(struct fanotify_info *info)
168{
169 BUILD_BUG_ON(FANOTIFY_FH_HDR_LEN + MAX_HANDLE_SZ > U8_MAX);
170 BUILD_BUG_ON(NAME_MAX > U8_MAX);
171
172 info->dir_fh_totlen = 0;
173 info->dir2_fh_totlen = 0;
174 info->file_fh_totlen = 0;
175 info->name_len = 0;
176 info->name2_len = 0;
177}
178
179/* These set/copy helpers MUST be called by order */
180static inline void fanotify_info_set_dir_fh(struct fanotify_info *info,
181 unsigned int totlen)
182{
183 if (WARN_ON_ONCE(info->dir2_fh_totlen > 0) ||
184 WARN_ON_ONCE(info->file_fh_totlen > 0) ||
185 WARN_ON_ONCE(info->name_len > 0) ||
186 WARN_ON_ONCE(info->name2_len > 0))
187 return;
188
189 info->dir_fh_totlen = totlen;
190}
191
192static inline void fanotify_info_set_dir2_fh(struct fanotify_info *info,
193 unsigned int totlen)
194{
195 if (WARN_ON_ONCE(info->file_fh_totlen > 0) ||
196 WARN_ON_ONCE(info->name_len > 0) ||
197 WARN_ON_ONCE(info->name2_len > 0))
198 return;
199
200 info->dir2_fh_totlen = totlen;
201}
202
203static inline void fanotify_info_set_file_fh(struct fanotify_info *info,
204 unsigned int totlen)
205{
206 if (WARN_ON_ONCE(info->name_len > 0) ||
207 WARN_ON_ONCE(info->name2_len > 0))
208 return;
209
210 info->file_fh_totlen = totlen;
211}
212
213static inline void fanotify_info_copy_name(struct fanotify_info *info,
214 const struct qstr *name)
215{
216 if (WARN_ON_ONCE(name->len > NAME_MAX) ||
217 WARN_ON_ONCE(info->name2_len > 0))
218 return;
219
220 info->name_len = name->len;
221 strcpy(fanotify_info_name(info), name->name);
222}
223
224static inline void fanotify_info_copy_name2(struct fanotify_info *info,
225 const struct qstr *name)
226{
227 if (WARN_ON_ONCE(name->len > NAME_MAX))
228 return;
229
230 info->name2_len = name->len;
231 strcpy(fanotify_info_name2(info), name->name);
232}
233
234/*
235 * Common structure for fanotify events. Concrete structs are allocated in
236 * fanotify_handle_event() and freed when the information is retrieved by
237 * userspace. The type of event determines how it was allocated, how it will
238 * be freed and which concrete struct it may be cast to.
239 */
240enum fanotify_event_type {
241 FANOTIFY_EVENT_TYPE_FID, /* fixed length */
242 FANOTIFY_EVENT_TYPE_FID_NAME, /* variable length */
243 FANOTIFY_EVENT_TYPE_PATH,
244 FANOTIFY_EVENT_TYPE_PATH_PERM,
245 FANOTIFY_EVENT_TYPE_OVERFLOW, /* struct fanotify_event */
246 FANOTIFY_EVENT_TYPE_FS_ERROR, /* struct fanotify_error_event */
247 __FANOTIFY_EVENT_TYPE_NUM
248};
249
250#define FANOTIFY_EVENT_TYPE_BITS \
251 (ilog2(__FANOTIFY_EVENT_TYPE_NUM - 1) + 1)
252#define FANOTIFY_EVENT_HASH_BITS \
253 (32 - FANOTIFY_EVENT_TYPE_BITS)
254
255struct fanotify_event {
256 struct fsnotify_event fse;
257 struct hlist_node merge_list; /* List for hashed merge */
258 u32 mask;
259 struct {
260 unsigned int type : FANOTIFY_EVENT_TYPE_BITS;
261 unsigned int hash : FANOTIFY_EVENT_HASH_BITS;
262 };
263 struct pid *pid;
264};
265
266static inline void fanotify_init_event(struct fanotify_event *event,
267 unsigned int hash, u32 mask)
268{
269 fsnotify_init_event(&event->fse);
270 INIT_HLIST_NODE(&event->merge_list);
271 event->hash = hash;
272 event->mask = mask;
273 event->pid = NULL;
274}
275
276#define FANOTIFY_INLINE_FH(name, size) \
277struct { \
278 struct fanotify_fh name; \
279 /* Space for object_fh.buf[] - access with fanotify_fh_buf() */ \
280 unsigned char _inline_fh_buf[size]; \
281}
282
283struct fanotify_fid_event {
284 struct fanotify_event fae;
285 __kernel_fsid_t fsid;
286
287 FANOTIFY_INLINE_FH(object_fh, FANOTIFY_INLINE_FH_LEN);
288};
289
290static inline struct fanotify_fid_event *
291FANOTIFY_FE(struct fanotify_event *event)
292{
293 return container_of(event, struct fanotify_fid_event, fae);
294}
295
296struct fanotify_name_event {
297 struct fanotify_event fae;
298 __kernel_fsid_t fsid;
299 struct fanotify_info info;
300};
301
302static inline struct fanotify_name_event *
303FANOTIFY_NE(struct fanotify_event *event)
304{
305 return container_of(event, struct fanotify_name_event, fae);
306}
307
308struct fanotify_error_event {
309 struct fanotify_event fae;
310 s32 error; /* Error reported by the Filesystem. */
311 u32 err_count; /* Suppressed errors count */
312
313 __kernel_fsid_t fsid; /* FSID this error refers to. */
314
315 FANOTIFY_INLINE_FH(object_fh, MAX_HANDLE_SZ);
316};
317
318static inline struct fanotify_error_event *
319FANOTIFY_EE(struct fanotify_event *event)
320{
321 return container_of(event, struct fanotify_error_event, fae);
322}
323
324static inline __kernel_fsid_t *fanotify_event_fsid(struct fanotify_event *event)
325{
326 if (event->type == FANOTIFY_EVENT_TYPE_FID)
327 return &FANOTIFY_FE(event)->fsid;
328 else if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME)
329 return &FANOTIFY_NE(event)->fsid;
330 else if (event->type == FANOTIFY_EVENT_TYPE_FS_ERROR)
331 return &FANOTIFY_EE(event)->fsid;
332 else
333 return NULL;
334}
335
336static inline struct fanotify_fh *fanotify_event_object_fh(
337 struct fanotify_event *event)
338{
339 if (event->type == FANOTIFY_EVENT_TYPE_FID)
340 return &FANOTIFY_FE(event)->object_fh;
341 else if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME)
342 return fanotify_info_file_fh(&FANOTIFY_NE(event)->info);
343 else if (event->type == FANOTIFY_EVENT_TYPE_FS_ERROR)
344 return &FANOTIFY_EE(event)->object_fh;
345 else
346 return NULL;
347}
348
349static inline struct fanotify_info *fanotify_event_info(
350 struct fanotify_event *event)
351{
352 if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME)
353 return &FANOTIFY_NE(event)->info;
354 else
355 return NULL;
356}
357
358static inline int fanotify_event_object_fh_len(struct fanotify_event *event)
359{
360 struct fanotify_info *info = fanotify_event_info(event);
361 struct fanotify_fh *fh = fanotify_event_object_fh(event);
362
363 if (info)
364 return info->file_fh_totlen ? fh->len : 0;
365 else
366 return fh ? fh->len : 0;
367}
368
369static inline int fanotify_event_dir_fh_len(struct fanotify_event *event)
370{
371 struct fanotify_info *info = fanotify_event_info(event);
372
373 return info ? fanotify_info_dir_fh_len(info) : 0;
374}
375
376static inline int fanotify_event_dir2_fh_len(struct fanotify_event *event)
377{
378 struct fanotify_info *info = fanotify_event_info(event);
379
380 return info ? fanotify_info_dir2_fh_len(info) : 0;
381}
382
383static inline bool fanotify_event_has_object_fh(struct fanotify_event *event)
384{
385 /* For error events, even zeroed fh are reported. */
386 if (event->type == FANOTIFY_EVENT_TYPE_FS_ERROR)
387 return true;
388 return fanotify_event_object_fh_len(event) > 0;
389}
390
391static inline bool fanotify_event_has_dir_fh(struct fanotify_event *event)
392{
393 return fanotify_event_dir_fh_len(event) > 0;
394}
395
396static inline bool fanotify_event_has_dir2_fh(struct fanotify_event *event)
397{
398 return fanotify_event_dir2_fh_len(event) > 0;
399}
400
401static inline bool fanotify_event_has_any_dir_fh(struct fanotify_event *event)
402{
403 return fanotify_event_has_dir_fh(event) ||
404 fanotify_event_has_dir2_fh(event);
405}
406
407struct fanotify_path_event {
408 struct fanotify_event fae;
409 struct path path;
410};
411
412static inline struct fanotify_path_event *
413FANOTIFY_PE(struct fanotify_event *event)
414{
415 return container_of(event, struct fanotify_path_event, fae);
416}
417
418/*
419 * Structure for permission fanotify events. It gets allocated and freed in
420 * fanotify_handle_event() since we wait there for user response. When the
421 * information is retrieved by userspace the structure is moved from
422 * group->notification_list to group->fanotify_data.access_list to wait for
423 * user response.
424 */
425struct fanotify_perm_event {
426 struct fanotify_event fae;
427 struct path path;
428 u32 response; /* userspace answer to the event */
429 unsigned short state; /* state of the event */
430 int fd; /* fd we passed to userspace for this event */
431 union {
432 struct fanotify_response_info_header hdr;
433 struct fanotify_response_info_audit_rule audit_rule;
434 };
435};
436
437static inline struct fanotify_perm_event *
438FANOTIFY_PERM(struct fanotify_event *event)
439{
440 return container_of(event, struct fanotify_perm_event, fae);
441}
442
443static inline bool fanotify_is_perm_event(u32 mask)
444{
445 return IS_ENABLED(CONFIG_FANOTIFY_ACCESS_PERMISSIONS) &&
446 mask & FANOTIFY_PERM_EVENTS;
447}
448
449static inline struct fanotify_event *FANOTIFY_E(struct fsnotify_event *fse)
450{
451 return container_of(fse, struct fanotify_event, fse);
452}
453
454static inline bool fanotify_is_error_event(u32 mask)
455{
456 return mask & FAN_FS_ERROR;
457}
458
459static inline const struct path *fanotify_event_path(struct fanotify_event *event)
460{
461 if (event->type == FANOTIFY_EVENT_TYPE_PATH)
462 return &FANOTIFY_PE(event)->path;
463 else if (event->type == FANOTIFY_EVENT_TYPE_PATH_PERM)
464 return &FANOTIFY_PERM(event)->path;
465 else
466 return NULL;
467}
468
469/*
470 * Use 128 size hash table to speed up events merge.
471 */
472#define FANOTIFY_HTABLE_BITS (7)
473#define FANOTIFY_HTABLE_SIZE (1 << FANOTIFY_HTABLE_BITS)
474#define FANOTIFY_HTABLE_MASK (FANOTIFY_HTABLE_SIZE - 1)
475
476/*
477 * Permission events and overflow event do not get merged - don't hash them.
478 */
479static inline bool fanotify_is_hashed_event(u32 mask)
480{
481 return !(fanotify_is_perm_event(mask) ||
482 fsnotify_is_overflow_event(mask));
483}
484
485static inline unsigned int fanotify_event_hash_bucket(
486 struct fsnotify_group *group,
487 struct fanotify_event *event)
488{
489 return event->hash & FANOTIFY_HTABLE_MASK;
490}
491
492struct fanotify_mark {
493 struct fsnotify_mark fsn_mark;
494 __kernel_fsid_t fsid;
495};
496
497static inline struct fanotify_mark *FANOTIFY_MARK(struct fsnotify_mark *mark)
498{
499 return container_of(mark, struct fanotify_mark, fsn_mark);
500}
501
502static inline bool fanotify_fsid_equal(__kernel_fsid_t *fsid1,
503 __kernel_fsid_t *fsid2)
504{
505 return fsid1->val[0] == fsid2->val[0] && fsid1->val[1] == fsid2->val[1];
506}
507
508static inline unsigned int fanotify_mark_user_flags(struct fsnotify_mark *mark)
509{
510 unsigned int mflags = 0;
511
512 if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
513 mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
514 if (mark->flags & FSNOTIFY_MARK_FLAG_NO_IREF)
515 mflags |= FAN_MARK_EVICTABLE;
516 if (mark->flags & FSNOTIFY_MARK_FLAG_HAS_IGNORE_FLAGS)
517 mflags |= FAN_MARK_IGNORE;
518
519 return mflags;
520}
1/* SPDX-License-Identifier: GPL-2.0 */
2#include <linux/fsnotify_backend.h>
3#include <linux/path.h>
4#include <linux/slab.h>
5#include <linux/exportfs.h>
6#include <linux/hashtable.h>
7
8extern struct kmem_cache *fanotify_mark_cache;
9extern struct kmem_cache *fanotify_fid_event_cachep;
10extern struct kmem_cache *fanotify_path_event_cachep;
11extern struct kmem_cache *fanotify_perm_event_cachep;
12
13/* Possible states of the permission event */
14enum {
15 FAN_EVENT_INIT,
16 FAN_EVENT_REPORTED,
17 FAN_EVENT_ANSWERED,
18 FAN_EVENT_CANCELED,
19};
20
21/*
22 * 3 dwords are sufficient for most local fs (64bit ino, 32bit generation).
23 * fh buf should be dword aligned. On 64bit arch, the ext_buf pointer is
24 * stored in either the first or last 2 dwords.
25 */
26#define FANOTIFY_INLINE_FH_LEN (3 << 2)
27#define FANOTIFY_FH_HDR_LEN offsetof(struct fanotify_fh, buf)
28
29/* Fixed size struct for file handle */
30struct fanotify_fh {
31 u8 type;
32 u8 len;
33#define FANOTIFY_FH_FLAG_EXT_BUF 1
34 u8 flags;
35 u8 pad;
36 unsigned char buf[];
37} __aligned(4);
38
39/* Variable size struct for dir file handle + child file handle + name */
40struct fanotify_info {
41 /* size of dir_fh/file_fh including fanotify_fh hdr size */
42 u8 dir_fh_totlen;
43 u8 file_fh_totlen;
44 u8 name_len;
45 u8 pad;
46 unsigned char buf[];
47 /*
48 * (struct fanotify_fh) dir_fh starts at buf[0]
49 * (optional) file_fh starts at buf[dir_fh_totlen]
50 * name starts at buf[dir_fh_totlen + file_fh_totlen]
51 */
52} __aligned(4);
53
54static inline bool fanotify_fh_has_ext_buf(struct fanotify_fh *fh)
55{
56 return (fh->flags & FANOTIFY_FH_FLAG_EXT_BUF);
57}
58
59static inline char **fanotify_fh_ext_buf_ptr(struct fanotify_fh *fh)
60{
61 BUILD_BUG_ON(FANOTIFY_FH_HDR_LEN % 4);
62 BUILD_BUG_ON(__alignof__(char *) - 4 + sizeof(char *) >
63 FANOTIFY_INLINE_FH_LEN);
64 return (char **)ALIGN((unsigned long)(fh->buf), __alignof__(char *));
65}
66
67static inline void *fanotify_fh_ext_buf(struct fanotify_fh *fh)
68{
69 return *fanotify_fh_ext_buf_ptr(fh);
70}
71
72static inline void *fanotify_fh_buf(struct fanotify_fh *fh)
73{
74 return fanotify_fh_has_ext_buf(fh) ? fanotify_fh_ext_buf(fh) : fh->buf;
75}
76
77static inline int fanotify_info_dir_fh_len(struct fanotify_info *info)
78{
79 if (!info->dir_fh_totlen ||
80 WARN_ON_ONCE(info->dir_fh_totlen < FANOTIFY_FH_HDR_LEN))
81 return 0;
82
83 return info->dir_fh_totlen - FANOTIFY_FH_HDR_LEN;
84}
85
86static inline struct fanotify_fh *fanotify_info_dir_fh(struct fanotify_info *info)
87{
88 BUILD_BUG_ON(offsetof(struct fanotify_info, buf) % 4);
89
90 return (struct fanotify_fh *)info->buf;
91}
92
93static inline int fanotify_info_file_fh_len(struct fanotify_info *info)
94{
95 if (!info->file_fh_totlen ||
96 WARN_ON_ONCE(info->file_fh_totlen < FANOTIFY_FH_HDR_LEN))
97 return 0;
98
99 return info->file_fh_totlen - FANOTIFY_FH_HDR_LEN;
100}
101
102static inline struct fanotify_fh *fanotify_info_file_fh(struct fanotify_info *info)
103{
104 return (struct fanotify_fh *)(info->buf + info->dir_fh_totlen);
105}
106
107static inline const char *fanotify_info_name(struct fanotify_info *info)
108{
109 return info->buf + info->dir_fh_totlen + info->file_fh_totlen;
110}
111
112static inline void fanotify_info_init(struct fanotify_info *info)
113{
114 info->dir_fh_totlen = 0;
115 info->file_fh_totlen = 0;
116 info->name_len = 0;
117}
118
119static inline unsigned int fanotify_info_len(struct fanotify_info *info)
120{
121 return info->dir_fh_totlen + info->file_fh_totlen + info->name_len;
122}
123
124static inline void fanotify_info_copy_name(struct fanotify_info *info,
125 const struct qstr *name)
126{
127 info->name_len = name->len;
128 strcpy(info->buf + info->dir_fh_totlen + info->file_fh_totlen,
129 name->name);
130}
131
132/*
133 * Common structure for fanotify events. Concrete structs are allocated in
134 * fanotify_handle_event() and freed when the information is retrieved by
135 * userspace. The type of event determines how it was allocated, how it will
136 * be freed and which concrete struct it may be cast to.
137 */
138enum fanotify_event_type {
139 FANOTIFY_EVENT_TYPE_FID, /* fixed length */
140 FANOTIFY_EVENT_TYPE_FID_NAME, /* variable length */
141 FANOTIFY_EVENT_TYPE_PATH,
142 FANOTIFY_EVENT_TYPE_PATH_PERM,
143 FANOTIFY_EVENT_TYPE_OVERFLOW, /* struct fanotify_event */
144 __FANOTIFY_EVENT_TYPE_NUM
145};
146
147#define FANOTIFY_EVENT_TYPE_BITS \
148 (ilog2(__FANOTIFY_EVENT_TYPE_NUM - 1) + 1)
149#define FANOTIFY_EVENT_HASH_BITS \
150 (32 - FANOTIFY_EVENT_TYPE_BITS)
151
152struct fanotify_event {
153 struct fsnotify_event fse;
154 struct hlist_node merge_list; /* List for hashed merge */
155 u32 mask;
156 struct {
157 unsigned int type : FANOTIFY_EVENT_TYPE_BITS;
158 unsigned int hash : FANOTIFY_EVENT_HASH_BITS;
159 };
160 struct pid *pid;
161};
162
163static inline void fanotify_init_event(struct fanotify_event *event,
164 unsigned int hash, u32 mask)
165{
166 fsnotify_init_event(&event->fse);
167 INIT_HLIST_NODE(&event->merge_list);
168 event->hash = hash;
169 event->mask = mask;
170 event->pid = NULL;
171}
172
173struct fanotify_fid_event {
174 struct fanotify_event fae;
175 __kernel_fsid_t fsid;
176 struct fanotify_fh object_fh;
177 /* Reserve space in object_fh.buf[] - access with fanotify_fh_buf() */
178 unsigned char _inline_fh_buf[FANOTIFY_INLINE_FH_LEN];
179};
180
181static inline struct fanotify_fid_event *
182FANOTIFY_FE(struct fanotify_event *event)
183{
184 return container_of(event, struct fanotify_fid_event, fae);
185}
186
187struct fanotify_name_event {
188 struct fanotify_event fae;
189 __kernel_fsid_t fsid;
190 struct fanotify_info info;
191};
192
193static inline struct fanotify_name_event *
194FANOTIFY_NE(struct fanotify_event *event)
195{
196 return container_of(event, struct fanotify_name_event, fae);
197}
198
199static inline __kernel_fsid_t *fanotify_event_fsid(struct fanotify_event *event)
200{
201 if (event->type == FANOTIFY_EVENT_TYPE_FID)
202 return &FANOTIFY_FE(event)->fsid;
203 else if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME)
204 return &FANOTIFY_NE(event)->fsid;
205 else
206 return NULL;
207}
208
209static inline struct fanotify_fh *fanotify_event_object_fh(
210 struct fanotify_event *event)
211{
212 if (event->type == FANOTIFY_EVENT_TYPE_FID)
213 return &FANOTIFY_FE(event)->object_fh;
214 else if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME)
215 return fanotify_info_file_fh(&FANOTIFY_NE(event)->info);
216 else
217 return NULL;
218}
219
220static inline struct fanotify_info *fanotify_event_info(
221 struct fanotify_event *event)
222{
223 if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME)
224 return &FANOTIFY_NE(event)->info;
225 else
226 return NULL;
227}
228
229static inline int fanotify_event_object_fh_len(struct fanotify_event *event)
230{
231 struct fanotify_info *info = fanotify_event_info(event);
232 struct fanotify_fh *fh = fanotify_event_object_fh(event);
233
234 if (info)
235 return info->file_fh_totlen ? fh->len : 0;
236 else
237 return fh ? fh->len : 0;
238}
239
240static inline int fanotify_event_dir_fh_len(struct fanotify_event *event)
241{
242 struct fanotify_info *info = fanotify_event_info(event);
243
244 return info ? fanotify_info_dir_fh_len(info) : 0;
245}
246
247struct fanotify_path_event {
248 struct fanotify_event fae;
249 struct path path;
250};
251
252static inline struct fanotify_path_event *
253FANOTIFY_PE(struct fanotify_event *event)
254{
255 return container_of(event, struct fanotify_path_event, fae);
256}
257
258/*
259 * Structure for permission fanotify events. It gets allocated and freed in
260 * fanotify_handle_event() since we wait there for user response. When the
261 * information is retrieved by userspace the structure is moved from
262 * group->notification_list to group->fanotify_data.access_list to wait for
263 * user response.
264 */
265struct fanotify_perm_event {
266 struct fanotify_event fae;
267 struct path path;
268 unsigned short response; /* userspace answer to the event */
269 unsigned short state; /* state of the event */
270 int fd; /* fd we passed to userspace for this event */
271};
272
273static inline struct fanotify_perm_event *
274FANOTIFY_PERM(struct fanotify_event *event)
275{
276 return container_of(event, struct fanotify_perm_event, fae);
277}
278
279static inline bool fanotify_is_perm_event(u32 mask)
280{
281 return IS_ENABLED(CONFIG_FANOTIFY_ACCESS_PERMISSIONS) &&
282 mask & FANOTIFY_PERM_EVENTS;
283}
284
285static inline struct fanotify_event *FANOTIFY_E(struct fsnotify_event *fse)
286{
287 return container_of(fse, struct fanotify_event, fse);
288}
289
290static inline bool fanotify_event_has_path(struct fanotify_event *event)
291{
292 return event->type == FANOTIFY_EVENT_TYPE_PATH ||
293 event->type == FANOTIFY_EVENT_TYPE_PATH_PERM;
294}
295
296static inline struct path *fanotify_event_path(struct fanotify_event *event)
297{
298 if (event->type == FANOTIFY_EVENT_TYPE_PATH)
299 return &FANOTIFY_PE(event)->path;
300 else if (event->type == FANOTIFY_EVENT_TYPE_PATH_PERM)
301 return &FANOTIFY_PERM(event)->path;
302 else
303 return NULL;
304}
305
306/*
307 * Use 128 size hash table to speed up events merge.
308 */
309#define FANOTIFY_HTABLE_BITS (7)
310#define FANOTIFY_HTABLE_SIZE (1 << FANOTIFY_HTABLE_BITS)
311#define FANOTIFY_HTABLE_MASK (FANOTIFY_HTABLE_SIZE - 1)
312
313/*
314 * Permission events and overflow event do not get merged - don't hash them.
315 */
316static inline bool fanotify_is_hashed_event(u32 mask)
317{
318 return !fanotify_is_perm_event(mask) && !(mask & FS_Q_OVERFLOW);
319}
320
321static inline unsigned int fanotify_event_hash_bucket(
322 struct fsnotify_group *group,
323 struct fanotify_event *event)
324{
325 return event->hash & FANOTIFY_HTABLE_MASK;
326}