1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/fanotify.h>
3 #include <linux/fcntl.h>
4 #include <linux/fdtable.h>
5 #include <linux/file.h>
6 #include <linux/fs.h>
7 #include <linux/anon_inodes.h>
8 #include <linux/fsnotify_backend.h>
9 #include <linux/init.h>
10 #include <linux/mount.h>
11 #include <linux/namei.h>
12 #include <linux/poll.h>
13 #include <linux/security.h>
14 #include <linux/syscalls.h>
15 #include <linux/slab.h>
16 #include <linux/types.h>
17 #include <linux/uaccess.h>
18 #include <linux/compat.h>
19 #include <linux/sched/signal.h>
20 #include <linux/memcontrol.h>
21 #include <linux/statfs.h>
22 #include <linux/exportfs.h>
23 
24 #include <asm/ioctls.h>
25 
26 #include "../../mount.h"
27 #include "../fdinfo.h"
28 #include "fanotify.h"
29 
30 #define FANOTIFY_DEFAULT_MAX_EVENTS	16384
31 #define FANOTIFY_OLD_DEFAULT_MAX_MARKS	8192
32 #define FANOTIFY_DEFAULT_MAX_GROUPS	128
33 #define FANOTIFY_DEFAULT_FEE_POOL_SIZE	32
34 
35 /*
36  * Legacy fanotify marks limits (8192) is per group and we introduced a tunable
37  * limit of marks per user, similar to inotify.  Effectively, the legacy limit
38  * of fanotify marks per user is <max marks per group> * <max groups per user>.
39  * This default limit (1M) also happens to match the increased limit of inotify
40  * max_user_watches since v5.10.
41  */
42 #define FANOTIFY_DEFAULT_MAX_USER_MARKS	\
43 	(FANOTIFY_OLD_DEFAULT_MAX_MARKS * FANOTIFY_DEFAULT_MAX_GROUPS)
44 
45 /*
46  * Most of the memory cost of adding an inode mark is pinning the marked inode.
47  * The size of the filesystem inode struct is not uniform across filesystems,
48  * so double the size of a VFS inode is used as a conservative approximation.
49  */
50 #define INODE_MARK_COST	(2 * sizeof(struct inode))
51 
52 /* configurable via /proc/sys/fs/fanotify/ */
53 static int fanotify_max_queued_events __read_mostly;
54 
55 #ifdef CONFIG_SYSCTL
56 
57 #include <linux/sysctl.h>
58 
59 static long ft_zero = 0;
60 static long ft_int_max = INT_MAX;
61 
62 static struct ctl_table fanotify_table[] = {
63 	{
64 		.procname	= "max_user_groups",
65 		.data	= &init_user_ns.ucount_max[UCOUNT_FANOTIFY_GROUPS],
66 		.maxlen		= sizeof(long),
67 		.mode		= 0644,
68 		.proc_handler	= proc_doulongvec_minmax,
69 		.extra1		= &ft_zero,
70 		.extra2		= &ft_int_max,
71 	},
72 	{
73 		.procname	= "max_user_marks",
74 		.data	= &init_user_ns.ucount_max[UCOUNT_FANOTIFY_MARKS],
75 		.maxlen		= sizeof(long),
76 		.mode		= 0644,
77 		.proc_handler	= proc_doulongvec_minmax,
78 		.extra1		= &ft_zero,
79 		.extra2		= &ft_int_max,
80 	},
81 	{
82 		.procname	= "max_queued_events",
83 		.data		= &fanotify_max_queued_events,
84 		.maxlen		= sizeof(int),
85 		.mode		= 0644,
86 		.proc_handler	= proc_dointvec_minmax,
87 		.extra1		= SYSCTL_ZERO
88 	},
89 	{ }
90 };
91 
92 static void __init fanotify_sysctls_init(void)
93 {
94 	register_sysctl("fs/fanotify", fanotify_table);
95 }
96 #else
97 #define fanotify_sysctls_init() do { } while (0)
98 #endif /* CONFIG_SYSCTL */
99 
100 /*
101  * All flags that may be specified in parameter event_f_flags of fanotify_init.
102  *
103  * Internal and external open flags are stored together in field f_flags of
104  * struct file. Only external open flags shall be allowed in event_f_flags.
105  * Internal flags like FMODE_NONOTIFY, FMODE_EXEC, FMODE_NOCMTIME shall be
106  * excluded.
107  */
108 #define	FANOTIFY_INIT_ALL_EVENT_F_BITS				( \
109 		O_ACCMODE	| O_APPEND	| O_NONBLOCK	| \
110 		__O_SYNC	| O_DSYNC	| O_CLOEXEC     | \
111 		O_LARGEFILE	| O_NOATIME	)
112 
113 extern const struct fsnotify_ops fanotify_fsnotify_ops;
114 
115 struct kmem_cache *fanotify_mark_cache __read_mostly;
116 struct kmem_cache *fanotify_fid_event_cachep __read_mostly;
117 struct kmem_cache *fanotify_path_event_cachep __read_mostly;
118 struct kmem_cache *fanotify_perm_event_cachep __read_mostly;
119 
120 #define FANOTIFY_EVENT_ALIGN 4
121 #define FANOTIFY_FID_INFO_HDR_LEN \
122 	(sizeof(struct fanotify_event_info_fid) + sizeof(struct file_handle))
123 #define FANOTIFY_PIDFD_INFO_HDR_LEN \
124 	sizeof(struct fanotify_event_info_pidfd)
125 #define FANOTIFY_ERROR_INFO_LEN \
126 	(sizeof(struct fanotify_event_info_error))
127 
128 static int fanotify_fid_info_len(int fh_len, int name_len)
129 {
130 	int info_len = fh_len;
131 
132 	if (name_len)
133 		info_len += name_len + 1;
134 
135 	return roundup(FANOTIFY_FID_INFO_HDR_LEN + info_len,
136 		       FANOTIFY_EVENT_ALIGN);
137 }
138 
139 /* FAN_RENAME may have one or two dir+name info records */
140 static int fanotify_dir_name_info_len(struct fanotify_event *event)
141 {
142 	struct fanotify_info *info = fanotify_event_info(event);
143 	int dir_fh_len = fanotify_event_dir_fh_len(event);
144 	int dir2_fh_len = fanotify_event_dir2_fh_len(event);
145 	int info_len = 0;
146 
147 	if (dir_fh_len)
148 		info_len += fanotify_fid_info_len(dir_fh_len,
149 						  info->name_len);
150 	if (dir2_fh_len)
151 		info_len += fanotify_fid_info_len(dir2_fh_len,
152 						  info->name2_len);
153 
154 	return info_len;
155 }
156 
157 static size_t fanotify_event_len(unsigned int info_mode,
158 				 struct fanotify_event *event)
159 {
160 	size_t event_len = FAN_EVENT_METADATA_LEN;
161 	int fh_len;
162 	int dot_len = 0;
163 
164 	if (!info_mode)
165 		return event_len;
166 
167 	if (fanotify_is_error_event(event->mask))
168 		event_len += FANOTIFY_ERROR_INFO_LEN;
169 
170 	if (fanotify_event_has_any_dir_fh(event)) {
171 		event_len += fanotify_dir_name_info_len(event);
172 	} else if ((info_mode & FAN_REPORT_NAME) &&
173 		   (event->mask & FAN_ONDIR)) {
174 		/*
175 		 * With group flag FAN_REPORT_NAME, if name was not recorded in
176 		 * event on a directory, we will report the name ".".
177 		 */
178 		dot_len = 1;
179 	}
180 
181 	if (info_mode & FAN_REPORT_PIDFD)
182 		event_len += FANOTIFY_PIDFD_INFO_HDR_LEN;
183 
184 	if (fanotify_event_has_object_fh(event)) {
185 		fh_len = fanotify_event_object_fh_len(event);
186 		event_len += fanotify_fid_info_len(fh_len, dot_len);
187 	}
188 
189 	return event_len;
190 }
191 
192 /*
193  * Remove an hashed event from merge hash table.
194  */
195 static void fanotify_unhash_event(struct fsnotify_group *group,
196 				  struct fanotify_event *event)
197 {
198 	assert_spin_locked(&group->notification_lock);
199 
200 	pr_debug("%s: group=%p event=%p bucket=%u\n", __func__,
201 		 group, event, fanotify_event_hash_bucket(group, event));
202 
203 	if (WARN_ON_ONCE(hlist_unhashed(&event->merge_list)))
204 		return;
205 
206 	hlist_del_init(&event->merge_list);
207 }
208 
209 /*
210  * Get an fanotify notification event if one exists and is small
211  * enough to fit in "count". Return an error pointer if the count
212  * is not large enough. When permission event is dequeued, its state is
213  * updated accordingly.
214  */
215 static struct fanotify_event *get_one_event(struct fsnotify_group *group,
216 					    size_t count)
217 {
218 	size_t event_size;
219 	struct fanotify_event *event = NULL;
220 	struct fsnotify_event *fsn_event;
221 	unsigned int info_mode = FAN_GROUP_FLAG(group, FANOTIFY_INFO_MODES);
222 
223 	pr_debug("%s: group=%p count=%zd\n", __func__, group, count);
224 
225 	spin_lock(&group->notification_lock);
226 	fsn_event = fsnotify_peek_first_event(group);
227 	if (!fsn_event)
228 		goto out;
229 
230 	event = FANOTIFY_E(fsn_event);
231 	event_size = fanotify_event_len(info_mode, event);
232 
233 	if (event_size > count) {
234 		event = ERR_PTR(-EINVAL);
235 		goto out;
236 	}
237 
238 	/*
239 	 * Held the notification_lock the whole time, so this is the
240 	 * same event we peeked above.
241 	 */
242 	fsnotify_remove_first_event(group);
243 	if (fanotify_is_perm_event(event->mask))
244 		FANOTIFY_PERM(event)->state = FAN_EVENT_REPORTED;
245 	if (fanotify_is_hashed_event(event->mask))
246 		fanotify_unhash_event(group, event);
247 out:
248 	spin_unlock(&group->notification_lock);
249 	return event;
250 }
251 
252 static int create_fd(struct fsnotify_group *group, struct path *path,
253 		     struct file **file)
254 {
255 	int client_fd;
256 	struct file *new_file;
257 
258 	client_fd = get_unused_fd_flags(group->fanotify_data.f_flags);
259 	if (client_fd < 0)
260 		return client_fd;
261 
262 	/*
263 	 * we need a new file handle for the userspace program so it can read even if it was
264 	 * originally opened O_WRONLY.
265 	 */
266 	new_file = dentry_open(path,
267 			       group->fanotify_data.f_flags | __FMODE_NONOTIFY,
268 			       current_cred());
269 	if (IS_ERR(new_file)) {
270 		/*
271 		 * we still send an event even if we can't open the file.  this
272 		 * can happen when say tasks are gone and we try to open their
273 		 * /proc files or we try to open a WRONLY file like in sysfs
274 		 * we just send the errno to userspace since there isn't much
275 		 * else we can do.
276 		 */
277 		put_unused_fd(client_fd);
278 		client_fd = PTR_ERR(new_file);
279 	} else {
280 		*file = new_file;
281 	}
282 
283 	return client_fd;
284 }
285 
286 /*
287  * Finish processing of permission event by setting it to ANSWERED state and
288  * drop group->notification_lock.
289  */
290 static void finish_permission_event(struct fsnotify_group *group,
291 				    struct fanotify_perm_event *event,
292 				    unsigned int response)
293 				    __releases(&group->notification_lock)
294 {
295 	bool destroy = false;
296 
297 	assert_spin_locked(&group->notification_lock);
298 	event->response = response;
299 	if (event->state == FAN_EVENT_CANCELED)
300 		destroy = true;
301 	else
302 		event->state = FAN_EVENT_ANSWERED;
303 	spin_unlock(&group->notification_lock);
304 	if (destroy)
305 		fsnotify_destroy_event(group, &event->fae.fse);
306 }
307 
308 static int process_access_response(struct fsnotify_group *group,
309 				   struct fanotify_response *response_struct)
310 {
311 	struct fanotify_perm_event *event;
312 	int fd = response_struct->fd;
313 	int response = response_struct->response;
314 
315 	pr_debug("%s: group=%p fd=%d response=%d\n", __func__, group,
316 		 fd, response);
317 	/*
318 	 * make sure the response is valid, if invalid we do nothing and either
319 	 * userspace can send a valid response or we will clean it up after the
320 	 * timeout
321 	 */
322 	switch (response & ~FAN_AUDIT) {
323 	case FAN_ALLOW:
324 	case FAN_DENY:
325 		break;
326 	default:
327 		return -EINVAL;
328 	}
329 
330 	if (fd < 0)
331 		return -EINVAL;
332 
333 	if ((response & FAN_AUDIT) && !FAN_GROUP_FLAG(group, FAN_ENABLE_AUDIT))
334 		return -EINVAL;
335 
336 	spin_lock(&group->notification_lock);
337 	list_for_each_entry(event, &group->fanotify_data.access_list,
338 			    fae.fse.list) {
339 		if (event->fd != fd)
340 			continue;
341 
342 		list_del_init(&event->fae.fse.list);
343 		finish_permission_event(group, event, response);
344 		wake_up(&group->fanotify_data.access_waitq);
345 		return 0;
346 	}
347 	spin_unlock(&group->notification_lock);
348 
349 	return -ENOENT;
350 }
351 
352 static size_t copy_error_info_to_user(struct fanotify_event *event,
353 				      char __user *buf, int count)
354 {
355 	struct fanotify_event_info_error info = { };
356 	struct fanotify_error_event *fee = FANOTIFY_EE(event);
357 
358 	info.hdr.info_type = FAN_EVENT_INFO_TYPE_ERROR;
359 	info.hdr.len = FANOTIFY_ERROR_INFO_LEN;
360 
361 	if (WARN_ON(count < info.hdr.len))
362 		return -EFAULT;
363 
364 	info.error = fee->error;
365 	info.error_count = fee->err_count;
366 
367 	if (copy_to_user(buf, &info, sizeof(info)))
368 		return -EFAULT;
369 
370 	return info.hdr.len;
371 }
372 
373 static int copy_fid_info_to_user(__kernel_fsid_t *fsid, struct fanotify_fh *fh,
374 				 int info_type, const char *name,
375 				 size_t name_len,
376 				 char __user *buf, size_t count)
377 {
378 	struct fanotify_event_info_fid info = { };
379 	struct file_handle handle = { };
380 	unsigned char bounce[FANOTIFY_INLINE_FH_LEN], *fh_buf;
381 	size_t fh_len = fh ? fh->len : 0;
382 	size_t info_len = fanotify_fid_info_len(fh_len, name_len);
383 	size_t len = info_len;
384 
385 	pr_debug("%s: fh_len=%zu name_len=%zu, info_len=%zu, count=%zu\n",
386 		 __func__, fh_len, name_len, info_len, count);
387 
388 	if (WARN_ON_ONCE(len < sizeof(info) || len > count))
389 		return -EFAULT;
390 
391 	/*
392 	 * Copy event info fid header followed by variable sized file handle
393 	 * and optionally followed by variable sized filename.
394 	 */
395 	switch (info_type) {
396 	case FAN_EVENT_INFO_TYPE_FID:
397 	case FAN_EVENT_INFO_TYPE_DFID:
398 		if (WARN_ON_ONCE(name_len))
399 			return -EFAULT;
400 		break;
401 	case FAN_EVENT_INFO_TYPE_DFID_NAME:
402 	case FAN_EVENT_INFO_TYPE_OLD_DFID_NAME:
403 	case FAN_EVENT_INFO_TYPE_NEW_DFID_NAME:
404 		if (WARN_ON_ONCE(!name || !name_len))
405 			return -EFAULT;
406 		break;
407 	default:
408 		return -EFAULT;
409 	}
410 
411 	info.hdr.info_type = info_type;
412 	info.hdr.len = len;
413 	info.fsid = *fsid;
414 	if (copy_to_user(buf, &info, sizeof(info)))
415 		return -EFAULT;
416 
417 	buf += sizeof(info);
418 	len -= sizeof(info);
419 	if (WARN_ON_ONCE(len < sizeof(handle)))
420 		return -EFAULT;
421 
422 	handle.handle_type = fh->type;
423 	handle.handle_bytes = fh_len;
424 
425 	/* Mangle handle_type for bad file_handle */
426 	if (!fh_len)
427 		handle.handle_type = FILEID_INVALID;
428 
429 	if (copy_to_user(buf, &handle, sizeof(handle)))
430 		return -EFAULT;
431 
432 	buf += sizeof(handle);
433 	len -= sizeof(handle);
434 	if (WARN_ON_ONCE(len < fh_len))
435 		return -EFAULT;
436 
437 	/*
438 	 * For an inline fh and inline file name, copy through stack to exclude
439 	 * the copy from usercopy hardening protections.
440 	 */
441 	fh_buf = fanotify_fh_buf(fh);
442 	if (fh_len <= FANOTIFY_INLINE_FH_LEN) {
443 		memcpy(bounce, fh_buf, fh_len);
444 		fh_buf = bounce;
445 	}
446 	if (copy_to_user(buf, fh_buf, fh_len))
447 		return -EFAULT;
448 
449 	buf += fh_len;
450 	len -= fh_len;
451 
452 	if (name_len) {
453 		/* Copy the filename with terminating null */
454 		name_len++;
455 		if (WARN_ON_ONCE(len < name_len))
456 			return -EFAULT;
457 
458 		if (copy_to_user(buf, name, name_len))
459 			return -EFAULT;
460 
461 		buf += name_len;
462 		len -= name_len;
463 	}
464 
465 	/* Pad with 0's */
466 	WARN_ON_ONCE(len < 0 || len >= FANOTIFY_EVENT_ALIGN);
467 	if (len > 0 && clear_user(buf, len))
468 		return -EFAULT;
469 
470 	return info_len;
471 }
472 
473 static int copy_pidfd_info_to_user(int pidfd,
474 				   char __user *buf,
475 				   size_t count)
476 {
477 	struct fanotify_event_info_pidfd info = { };
478 	size_t info_len = FANOTIFY_PIDFD_INFO_HDR_LEN;
479 
480 	if (WARN_ON_ONCE(info_len > count))
481 		return -EFAULT;
482 
483 	info.hdr.info_type = FAN_EVENT_INFO_TYPE_PIDFD;
484 	info.hdr.len = info_len;
485 	info.pidfd = pidfd;
486 
487 	if (copy_to_user(buf, &info, info_len))
488 		return -EFAULT;
489 
490 	return info_len;
491 }
492 
493 static int copy_info_records_to_user(struct fanotify_event *event,
494 				     struct fanotify_info *info,
495 				     unsigned int info_mode, int pidfd,
496 				     char __user *buf, size_t count)
497 {
498 	int ret, total_bytes = 0, info_type = 0;
499 	unsigned int fid_mode = info_mode & FANOTIFY_FID_BITS;
500 	unsigned int pidfd_mode = info_mode & FAN_REPORT_PIDFD;
501 
502 	/*
503 	 * Event info records order is as follows:
504 	 * 1. dir fid + name
505 	 * 2. (optional) new dir fid + new name
506 	 * 3. (optional) child fid
507 	 */
508 	if (fanotify_event_has_dir_fh(event)) {
509 		info_type = info->name_len ? FAN_EVENT_INFO_TYPE_DFID_NAME :
510 					     FAN_EVENT_INFO_TYPE_DFID;
511 
512 		/* FAN_RENAME uses special info types */
513 		if (event->mask & FAN_RENAME)
514 			info_type = FAN_EVENT_INFO_TYPE_OLD_DFID_NAME;
515 
516 		ret = copy_fid_info_to_user(fanotify_event_fsid(event),
517 					    fanotify_info_dir_fh(info),
518 					    info_type,
519 					    fanotify_info_name(info),
520 					    info->name_len, buf, count);
521 		if (ret < 0)
522 			return ret;
523 
524 		buf += ret;
525 		count -= ret;
526 		total_bytes += ret;
527 	}
528 
529 	/* New dir fid+name may be reported in addition to old dir fid+name */
530 	if (fanotify_event_has_dir2_fh(event)) {
531 		info_type = FAN_EVENT_INFO_TYPE_NEW_DFID_NAME;
532 		ret = copy_fid_info_to_user(fanotify_event_fsid(event),
533 					    fanotify_info_dir2_fh(info),
534 					    info_type,
535 					    fanotify_info_name2(info),
536 					    info->name2_len, buf, count);
537 		if (ret < 0)
538 			return ret;
539 
540 		buf += ret;
541 		count -= ret;
542 		total_bytes += ret;
543 	}
544 
545 	if (fanotify_event_has_object_fh(event)) {
546 		const char *dot = NULL;
547 		int dot_len = 0;
548 
549 		if (fid_mode == FAN_REPORT_FID || info_type) {
550 			/*
551 			 * With only group flag FAN_REPORT_FID only type FID is
552 			 * reported. Second info record type is always FID.
553 			 */
554 			info_type = FAN_EVENT_INFO_TYPE_FID;
555 		} else if ((fid_mode & FAN_REPORT_NAME) &&
556 			   (event->mask & FAN_ONDIR)) {
557 			/*
558 			 * With group flag FAN_REPORT_NAME, if name was not
559 			 * recorded in an event on a directory, report the name
560 			 * "." with info type DFID_NAME.
561 			 */
562 			info_type = FAN_EVENT_INFO_TYPE_DFID_NAME;
563 			dot = ".";
564 			dot_len = 1;
565 		} else if ((event->mask & ALL_FSNOTIFY_DIRENT_EVENTS) ||
566 			   (event->mask & FAN_ONDIR)) {
567 			/*
568 			 * With group flag FAN_REPORT_DIR_FID, a single info
569 			 * record has type DFID for directory entry modification
570 			 * event and for event on a directory.
571 			 */
572 			info_type = FAN_EVENT_INFO_TYPE_DFID;
573 		} else {
574 			/*
575 			 * With group flags FAN_REPORT_DIR_FID|FAN_REPORT_FID,
576 			 * a single info record has type FID for event on a
577 			 * non-directory, when there is no directory to report.
578 			 * For example, on FAN_DELETE_SELF event.
579 			 */
580 			info_type = FAN_EVENT_INFO_TYPE_FID;
581 		}
582 
583 		ret = copy_fid_info_to_user(fanotify_event_fsid(event),
584 					    fanotify_event_object_fh(event),
585 					    info_type, dot, dot_len,
586 					    buf, count);
587 		if (ret < 0)
588 			return ret;
589 
590 		buf += ret;
591 		count -= ret;
592 		total_bytes += ret;
593 	}
594 
595 	if (pidfd_mode) {
596 		ret = copy_pidfd_info_to_user(pidfd, buf, count);
597 		if (ret < 0)
598 			return ret;
599 
600 		buf += ret;
601 		count -= ret;
602 		total_bytes += ret;
603 	}
604 
605 	if (fanotify_is_error_event(event->mask)) {
606 		ret = copy_error_info_to_user(event, buf, count);
607 		if (ret < 0)
608 			return ret;
609 		buf += ret;
610 		count -= ret;
611 		total_bytes += ret;
612 	}
613 
614 	return total_bytes;
615 }
616 
617 static ssize_t copy_event_to_user(struct fsnotify_group *group,
618 				  struct fanotify_event *event,
619 				  char __user *buf, size_t count)
620 {
621 	struct fanotify_event_metadata metadata;
622 	struct path *path = fanotify_event_path(event);
623 	struct fanotify_info *info = fanotify_event_info(event);
624 	unsigned int info_mode = FAN_GROUP_FLAG(group, FANOTIFY_INFO_MODES);
625 	unsigned int pidfd_mode = info_mode & FAN_REPORT_PIDFD;
626 	struct file *f = NULL;
627 	int ret, pidfd = FAN_NOPIDFD, fd = FAN_NOFD;
628 
629 	pr_debug("%s: group=%p event=%p\n", __func__, group, event);
630 
631 	metadata.event_len = fanotify_event_len(info_mode, event);
632 	metadata.metadata_len = FAN_EVENT_METADATA_LEN;
633 	metadata.vers = FANOTIFY_METADATA_VERSION;
634 	metadata.reserved = 0;
635 	metadata.mask = event->mask & FANOTIFY_OUTGOING_EVENTS;
636 	metadata.pid = pid_vnr(event->pid);
637 	/*
638 	 * For an unprivileged listener, event->pid can be used to identify the
639 	 * events generated by the listener process itself, without disclosing
640 	 * the pids of other processes.
641 	 */
642 	if (FAN_GROUP_FLAG(group, FANOTIFY_UNPRIV) &&
643 	    task_tgid(current) != event->pid)
644 		metadata.pid = 0;
645 
646 	/*
647 	 * For now, fid mode is required for an unprivileged listener and
648 	 * fid mode does not report fd in events.  Keep this check anyway
649 	 * for safety in case fid mode requirement is relaxed in the future
650 	 * to allow unprivileged listener to get events with no fd and no fid.
651 	 */
652 	if (!FAN_GROUP_FLAG(group, FANOTIFY_UNPRIV) &&
653 	    path && path->mnt && path->dentry) {
654 		fd = create_fd(group, path, &f);
655 		if (fd < 0)
656 			return fd;
657 	}
658 	metadata.fd = fd;
659 
660 	if (pidfd_mode) {
661 		/*
662 		 * Complain if the FAN_REPORT_PIDFD and FAN_REPORT_TID mutual
663 		 * exclusion is ever lifted. At the time of incoporating pidfd
664 		 * support within fanotify, the pidfd API only supported the
665 		 * creation of pidfds for thread-group leaders.
666 		 */
667 		WARN_ON_ONCE(FAN_GROUP_FLAG(group, FAN_REPORT_TID));
668 
669 		/*
670 		 * The PIDTYPE_TGID check for an event->pid is performed
671 		 * preemptively in an attempt to catch out cases where the event
672 		 * listener reads events after the event generating process has
673 		 * already terminated. Report FAN_NOPIDFD to the event listener
674 		 * in those cases, with all other pidfd creation errors being
675 		 * reported as FAN_EPIDFD.
676 		 */
677 		if (metadata.pid == 0 ||
678 		    !pid_has_task(event->pid, PIDTYPE_TGID)) {
679 			pidfd = FAN_NOPIDFD;
680 		} else {
681 			pidfd = pidfd_create(event->pid, 0);
682 			if (pidfd < 0)
683 				pidfd = FAN_EPIDFD;
684 		}
685 	}
686 
687 	ret = -EFAULT;
688 	/*
689 	 * Sanity check copy size in case get_one_event() and
690 	 * event_len sizes ever get out of sync.
691 	 */
692 	if (WARN_ON_ONCE(metadata.event_len > count))
693 		goto out_close_fd;
694 
695 	if (copy_to_user(buf, &metadata, FAN_EVENT_METADATA_LEN))
696 		goto out_close_fd;
697 
698 	buf += FAN_EVENT_METADATA_LEN;
699 	count -= FAN_EVENT_METADATA_LEN;
700 
701 	if (fanotify_is_perm_event(event->mask))
702 		FANOTIFY_PERM(event)->fd = fd;
703 
704 	if (info_mode) {
705 		ret = copy_info_records_to_user(event, info, info_mode, pidfd,
706 						buf, count);
707 		if (ret < 0)
708 			goto out_close_fd;
709 	}
710 
711 	if (f)
712 		fd_install(fd, f);
713 
714 	return metadata.event_len;
715 
716 out_close_fd:
717 	if (fd != FAN_NOFD) {
718 		put_unused_fd(fd);
719 		fput(f);
720 	}
721 
722 	if (pidfd >= 0)
723 		close_fd(pidfd);
724 
725 	return ret;
726 }
727 
728 /* intofiy userspace file descriptor functions */
729 static __poll_t fanotify_poll(struct file *file, poll_table *wait)
730 {
731 	struct fsnotify_group *group = file->private_data;
732 	__poll_t ret = 0;
733 
734 	poll_wait(file, &group->notification_waitq, wait);
735 	spin_lock(&group->notification_lock);
736 	if (!fsnotify_notify_queue_is_empty(group))
737 		ret = EPOLLIN | EPOLLRDNORM;
738 	spin_unlock(&group->notification_lock);
739 
740 	return ret;
741 }
742 
743 static ssize_t fanotify_read(struct file *file, char __user *buf,
744 			     size_t count, loff_t *pos)
745 {
746 	struct fsnotify_group *group;
747 	struct fanotify_event *event;
748 	char __user *start;
749 	int ret;
750 	DEFINE_WAIT_FUNC(wait, woken_wake_function);
751 
752 	start = buf;
753 	group = file->private_data;
754 
755 	pr_debug("%s: group=%p\n", __func__, group);
756 
757 	add_wait_queue(&group->notification_waitq, &wait);
758 	while (1) {
759 		/*
760 		 * User can supply arbitrarily large buffer. Avoid softlockups
761 		 * in case there are lots of available events.
762 		 */
763 		cond_resched();
764 		event = get_one_event(group, count);
765 		if (IS_ERR(event)) {
766 			ret = PTR_ERR(event);
767 			break;
768 		}
769 
770 		if (!event) {
771 			ret = -EAGAIN;
772 			if (file->f_flags & O_NONBLOCK)
773 				break;
774 
775 			ret = -ERESTARTSYS;
776 			if (signal_pending(current))
777 				break;
778 
779 			if (start != buf)
780 				break;
781 
782 			wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
783 			continue;
784 		}
785 
786 		ret = copy_event_to_user(group, event, buf, count);
787 		if (unlikely(ret == -EOPENSTALE)) {
788 			/*
789 			 * We cannot report events with stale fd so drop it.
790 			 * Setting ret to 0 will continue the event loop and
791 			 * do the right thing if there are no more events to
792 			 * read (i.e. return bytes read, -EAGAIN or wait).
793 			 */
794 			ret = 0;
795 		}
796 
797 		/*
798 		 * Permission events get queued to wait for response.  Other
799 		 * events can be destroyed now.
800 		 */
801 		if (!fanotify_is_perm_event(event->mask)) {
802 			fsnotify_destroy_event(group, &event->fse);
803 		} else {
804 			if (ret <= 0) {
805 				spin_lock(&group->notification_lock);
806 				finish_permission_event(group,
807 					FANOTIFY_PERM(event), FAN_DENY);
808 				wake_up(&group->fanotify_data.access_waitq);
809 			} else {
810 				spin_lock(&group->notification_lock);
811 				list_add_tail(&event->fse.list,
812 					&group->fanotify_data.access_list);
813 				spin_unlock(&group->notification_lock);
814 			}
815 		}
816 		if (ret < 0)
817 			break;
818 		buf += ret;
819 		count -= ret;
820 	}
821 	remove_wait_queue(&group->notification_waitq, &wait);
822 
823 	if (start != buf && ret != -EFAULT)
824 		ret = buf - start;
825 	return ret;
826 }
827 
828 static ssize_t fanotify_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
829 {
830 	struct fanotify_response response = { .fd = -1, .response = -1 };
831 	struct fsnotify_group *group;
832 	int ret;
833 
834 	if (!IS_ENABLED(CONFIG_FANOTIFY_ACCESS_PERMISSIONS))
835 		return -EINVAL;
836 
837 	group = file->private_data;
838 
839 	if (count < sizeof(response))
840 		return -EINVAL;
841 
842 	count = sizeof(response);
843 
844 	pr_debug("%s: group=%p count=%zu\n", __func__, group, count);
845 
846 	if (copy_from_user(&response, buf, count))
847 		return -EFAULT;
848 
849 	ret = process_access_response(group, &response);
850 	if (ret < 0)
851 		count = ret;
852 
853 	return count;
854 }
855 
856 static int fanotify_release(struct inode *ignored, struct file *file)
857 {
858 	struct fsnotify_group *group = file->private_data;
859 	struct fsnotify_event *fsn_event;
860 
861 	/*
862 	 * Stop new events from arriving in the notification queue. since
863 	 * userspace cannot use fanotify fd anymore, no event can enter or
864 	 * leave access_list by now either.
865 	 */
866 	fsnotify_group_stop_queueing(group);
867 
868 	/*
869 	 * Process all permission events on access_list and notification queue
870 	 * and simulate reply from userspace.
871 	 */
872 	spin_lock(&group->notification_lock);
873 	while (!list_empty(&group->fanotify_data.access_list)) {
874 		struct fanotify_perm_event *event;
875 
876 		event = list_first_entry(&group->fanotify_data.access_list,
877 				struct fanotify_perm_event, fae.fse.list);
878 		list_del_init(&event->fae.fse.list);
879 		finish_permission_event(group, event, FAN_ALLOW);
880 		spin_lock(&group->notification_lock);
881 	}
882 
883 	/*
884 	 * Destroy all non-permission events. For permission events just
885 	 * dequeue them and set the response. They will be freed once the
886 	 * response is consumed and fanotify_get_response() returns.
887 	 */
888 	while ((fsn_event = fsnotify_remove_first_event(group))) {
889 		struct fanotify_event *event = FANOTIFY_E(fsn_event);
890 
891 		if (!(event->mask & FANOTIFY_PERM_EVENTS)) {
892 			spin_unlock(&group->notification_lock);
893 			fsnotify_destroy_event(group, fsn_event);
894 		} else {
895 			finish_permission_event(group, FANOTIFY_PERM(event),
896 						FAN_ALLOW);
897 		}
898 		spin_lock(&group->notification_lock);
899 	}
900 	spin_unlock(&group->notification_lock);
901 
902 	/* Response for all permission events it set, wakeup waiters */
903 	wake_up(&group->fanotify_data.access_waitq);
904 
905 	/* matches the fanotify_init->fsnotify_alloc_group */
906 	fsnotify_destroy_group(group);
907 
908 	return 0;
909 }
910 
911 static long fanotify_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
912 {
913 	struct fsnotify_group *group;
914 	struct fsnotify_event *fsn_event;
915 	void __user *p;
916 	int ret = -ENOTTY;
917 	size_t send_len = 0;
918 
919 	group = file->private_data;
920 
921 	p = (void __user *) arg;
922 
923 	switch (cmd) {
924 	case FIONREAD:
925 		spin_lock(&group->notification_lock);
926 		list_for_each_entry(fsn_event, &group->notification_list, list)
927 			send_len += FAN_EVENT_METADATA_LEN;
928 		spin_unlock(&group->notification_lock);
929 		ret = put_user(send_len, (int __user *) p);
930 		break;
931 	}
932 
933 	return ret;
934 }
935 
936 static const struct file_operations fanotify_fops = {
937 	.show_fdinfo	= fanotify_show_fdinfo,
938 	.poll		= fanotify_poll,
939 	.read		= fanotify_read,
940 	.write		= fanotify_write,
941 	.fasync		= NULL,
942 	.release	= fanotify_release,
943 	.unlocked_ioctl	= fanotify_ioctl,
944 	.compat_ioctl	= compat_ptr_ioctl,
945 	.llseek		= noop_llseek,
946 };
947 
948 static int fanotify_find_path(int dfd, const char __user *filename,
949 			      struct path *path, unsigned int flags, __u64 mask,
950 			      unsigned int obj_type)
951 {
952 	int ret;
953 
954 	pr_debug("%s: dfd=%d filename=%p flags=%x\n", __func__,
955 		 dfd, filename, flags);
956 
957 	if (filename == NULL) {
958 		struct fd f = fdget(dfd);
959 
960 		ret = -EBADF;
961 		if (!f.file)
962 			goto out;
963 
964 		ret = -ENOTDIR;
965 		if ((flags & FAN_MARK_ONLYDIR) &&
966 		    !(S_ISDIR(file_inode(f.file)->i_mode))) {
967 			fdput(f);
968 			goto out;
969 		}
970 
971 		*path = f.file->f_path;
972 		path_get(path);
973 		fdput(f);
974 	} else {
975 		unsigned int lookup_flags = 0;
976 
977 		if (!(flags & FAN_MARK_DONT_FOLLOW))
978 			lookup_flags |= LOOKUP_FOLLOW;
979 		if (flags & FAN_MARK_ONLYDIR)
980 			lookup_flags |= LOOKUP_DIRECTORY;
981 
982 		ret = user_path_at(dfd, filename, lookup_flags, path);
983 		if (ret)
984 			goto out;
985 	}
986 
987 	/* you can only watch an inode if you have read permissions on it */
988 	ret = path_permission(path, MAY_READ);
989 	if (ret) {
990 		path_put(path);
991 		goto out;
992 	}
993 
994 	ret = security_path_notify(path, mask, obj_type);
995 	if (ret)
996 		path_put(path);
997 
998 out:
999 	return ret;
1000 }
1001 
1002 static __u32 fanotify_mark_remove_from_mask(struct fsnotify_mark *fsn_mark,
1003 					    __u32 mask, unsigned int flags,
1004 					    __u32 umask, int *destroy)
1005 {
1006 	__u32 oldmask, newmask;
1007 
1008 	/* umask bits cannot be removed by user */
1009 	mask &= ~umask;
1010 	spin_lock(&fsn_mark->lock);
1011 	oldmask = fsnotify_calc_mask(fsn_mark);
1012 	if (!(flags & FANOTIFY_MARK_IGNORE_BITS)) {
1013 		fsn_mark->mask &= ~mask;
1014 	} else {
1015 		fsn_mark->ignore_mask &= ~mask;
1016 	}
1017 	newmask = fsnotify_calc_mask(fsn_mark);
1018 	/*
1019 	 * We need to keep the mark around even if remaining mask cannot
1020 	 * result in any events (e.g. mask == FAN_ONDIR) to support incremenal
1021 	 * changes to the mask.
1022 	 * Destroy mark when only umask bits remain.
1023 	 */
1024 	*destroy = !((fsn_mark->mask | fsn_mark->ignore_mask) & ~umask);
1025 	spin_unlock(&fsn_mark->lock);
1026 
1027 	return oldmask & ~newmask;
1028 }
1029 
1030 static int fanotify_remove_mark(struct fsnotify_group *group,
1031 				fsnotify_connp_t *connp, __u32 mask,
1032 				unsigned int flags, __u32 umask)
1033 {
1034 	struct fsnotify_mark *fsn_mark = NULL;
1035 	__u32 removed;
1036 	int destroy_mark;
1037 
1038 	fsnotify_group_lock(group);
1039 	fsn_mark = fsnotify_find_mark(connp, group);
1040 	if (!fsn_mark) {
1041 		fsnotify_group_unlock(group);
1042 		return -ENOENT;
1043 	}
1044 
1045 	removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags,
1046 						 umask, &destroy_mark);
1047 	if (removed & fsnotify_conn_mask(fsn_mark->connector))
1048 		fsnotify_recalc_mask(fsn_mark->connector);
1049 	if (destroy_mark)
1050 		fsnotify_detach_mark(fsn_mark);
1051 	fsnotify_group_unlock(group);
1052 	if (destroy_mark)
1053 		fsnotify_free_mark(fsn_mark);
1054 
1055 	/* matches the fsnotify_find_mark() */
1056 	fsnotify_put_mark(fsn_mark);
1057 	return 0;
1058 }
1059 
1060 static int fanotify_remove_vfsmount_mark(struct fsnotify_group *group,
1061 					 struct vfsmount *mnt, __u32 mask,
1062 					 unsigned int flags, __u32 umask)
1063 {
1064 	return fanotify_remove_mark(group, &real_mount(mnt)->mnt_fsnotify_marks,
1065 				    mask, flags, umask);
1066 }
1067 
1068 static int fanotify_remove_sb_mark(struct fsnotify_group *group,
1069 				   struct super_block *sb, __u32 mask,
1070 				   unsigned int flags, __u32 umask)
1071 {
1072 	return fanotify_remove_mark(group, &sb->s_fsnotify_marks, mask,
1073 				    flags, umask);
1074 }
1075 
1076 static int fanotify_remove_inode_mark(struct fsnotify_group *group,
1077 				      struct inode *inode, __u32 mask,
1078 				      unsigned int flags, __u32 umask)
1079 {
1080 	return fanotify_remove_mark(group, &inode->i_fsnotify_marks, mask,
1081 				    flags, umask);
1082 }
1083 
1084 static bool fanotify_mark_update_flags(struct fsnotify_mark *fsn_mark,
1085 				       unsigned int fan_flags)
1086 {
1087 	bool want_iref = !(fan_flags & FAN_MARK_EVICTABLE);
1088 	unsigned int ignore = fan_flags & FANOTIFY_MARK_IGNORE_BITS;
1089 	bool recalc = false;
1090 
1091 	/*
1092 	 * When using FAN_MARK_IGNORE for the first time, mark starts using
1093 	 * independent event flags in ignore mask.  After that, trying to
1094 	 * update the ignore mask with the old FAN_MARK_IGNORED_MASK API
1095 	 * will result in EEXIST error.
1096 	 */
1097 	if (ignore == FAN_MARK_IGNORE)
1098 		fsn_mark->flags |= FSNOTIFY_MARK_FLAG_HAS_IGNORE_FLAGS;
1099 
1100 	/*
1101 	 * Setting FAN_MARK_IGNORED_SURV_MODIFY for the first time may lead to
1102 	 * the removal of the FS_MODIFY bit in calculated mask if it was set
1103 	 * because of an ignore mask that is now going to survive FS_MODIFY.
1104 	 */
1105 	if (ignore && (fan_flags & FAN_MARK_IGNORED_SURV_MODIFY) &&
1106 	    !(fsn_mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)) {
1107 		fsn_mark->flags |= FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY;
1108 		if (!(fsn_mark->mask & FS_MODIFY))
1109 			recalc = true;
1110 	}
1111 
1112 	if (fsn_mark->connector->type != FSNOTIFY_OBJ_TYPE_INODE ||
1113 	    want_iref == !(fsn_mark->flags & FSNOTIFY_MARK_FLAG_NO_IREF))
1114 		return recalc;
1115 
1116 	/*
1117 	 * NO_IREF may be removed from a mark, but not added.
1118 	 * When removed, fsnotify_recalc_mask() will take the inode ref.
1119 	 */
1120 	WARN_ON_ONCE(!want_iref);
1121 	fsn_mark->flags &= ~FSNOTIFY_MARK_FLAG_NO_IREF;
1122 
1123 	return true;
1124 }
1125 
1126 static bool fanotify_mark_add_to_mask(struct fsnotify_mark *fsn_mark,
1127 				      __u32 mask, unsigned int fan_flags)
1128 {
1129 	bool recalc;
1130 
1131 	spin_lock(&fsn_mark->lock);
1132 	if (!(fan_flags & FANOTIFY_MARK_IGNORE_BITS))
1133 		fsn_mark->mask |= mask;
1134 	else
1135 		fsn_mark->ignore_mask |= mask;
1136 
1137 	recalc = fsnotify_calc_mask(fsn_mark) &
1138 		~fsnotify_conn_mask(fsn_mark->connector);
1139 
1140 	recalc |= fanotify_mark_update_flags(fsn_mark, fan_flags);
1141 	spin_unlock(&fsn_mark->lock);
1142 
1143 	return recalc;
1144 }
1145 
1146 static struct fsnotify_mark *fanotify_add_new_mark(struct fsnotify_group *group,
1147 						   fsnotify_connp_t *connp,
1148 						   unsigned int obj_type,
1149 						   unsigned int fan_flags,
1150 						   __kernel_fsid_t *fsid)
1151 {
1152 	struct ucounts *ucounts = group->fanotify_data.ucounts;
1153 	struct fsnotify_mark *mark;
1154 	int ret;
1155 
1156 	/*
1157 	 * Enforce per user marks limits per user in all containing user ns.
1158 	 * A group with FAN_UNLIMITED_MARKS does not contribute to mark count
1159 	 * in the limited groups account.
1160 	 */
1161 	if (!FAN_GROUP_FLAG(group, FAN_UNLIMITED_MARKS) &&
1162 	    !inc_ucount(ucounts->ns, ucounts->uid, UCOUNT_FANOTIFY_MARKS))
1163 		return ERR_PTR(-ENOSPC);
1164 
1165 	mark = kmem_cache_alloc(fanotify_mark_cache, GFP_KERNEL);
1166 	if (!mark) {
1167 		ret = -ENOMEM;
1168 		goto out_dec_ucounts;
1169 	}
1170 
1171 	fsnotify_init_mark(mark, group);
1172 	if (fan_flags & FAN_MARK_EVICTABLE)
1173 		mark->flags |= FSNOTIFY_MARK_FLAG_NO_IREF;
1174 
1175 	ret = fsnotify_add_mark_locked(mark, connp, obj_type, 0, fsid);
1176 	if (ret) {
1177 		fsnotify_put_mark(mark);
1178 		goto out_dec_ucounts;
1179 	}
1180 
1181 	return mark;
1182 
1183 out_dec_ucounts:
1184 	if (!FAN_GROUP_FLAG(group, FAN_UNLIMITED_MARKS))
1185 		dec_ucount(ucounts, UCOUNT_FANOTIFY_MARKS);
1186 	return ERR_PTR(ret);
1187 }
1188 
1189 static int fanotify_group_init_error_pool(struct fsnotify_group *group)
1190 {
1191 	if (mempool_initialized(&group->fanotify_data.error_events_pool))
1192 		return 0;
1193 
1194 	return mempool_init_kmalloc_pool(&group->fanotify_data.error_events_pool,
1195 					 FANOTIFY_DEFAULT_FEE_POOL_SIZE,
1196 					 sizeof(struct fanotify_error_event));
1197 }
1198 
1199 static int fanotify_may_update_existing_mark(struct fsnotify_mark *fsn_mark,
1200 					      unsigned int fan_flags)
1201 {
1202 	/*
1203 	 * Non evictable mark cannot be downgraded to evictable mark.
1204 	 */
1205 	if (fan_flags & FAN_MARK_EVICTABLE &&
1206 	    !(fsn_mark->flags & FSNOTIFY_MARK_FLAG_NO_IREF))
1207 		return -EEXIST;
1208 
1209 	/*
1210 	 * New ignore mask semantics cannot be downgraded to old semantics.
1211 	 */
1212 	if (fan_flags & FAN_MARK_IGNORED_MASK &&
1213 	    fsn_mark->flags & FSNOTIFY_MARK_FLAG_HAS_IGNORE_FLAGS)
1214 		return -EEXIST;
1215 
1216 	/*
1217 	 * An ignore mask that survives modify could never be downgraded to not
1218 	 * survive modify.  With new FAN_MARK_IGNORE semantics we make that rule
1219 	 * explicit and return an error when trying to update the ignore mask
1220 	 * without the original FAN_MARK_IGNORED_SURV_MODIFY value.
1221 	 */
1222 	if (fan_flags & FAN_MARK_IGNORE &&
1223 	    !(fan_flags & FAN_MARK_IGNORED_SURV_MODIFY) &&
1224 	    fsn_mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
1225 		return -EEXIST;
1226 
1227 	return 0;
1228 }
1229 
1230 static int fanotify_add_mark(struct fsnotify_group *group,
1231 			     fsnotify_connp_t *connp, unsigned int obj_type,
1232 			     __u32 mask, unsigned int fan_flags,
1233 			     __kernel_fsid_t *fsid)
1234 {
1235 	struct fsnotify_mark *fsn_mark;
1236 	bool recalc;
1237 	int ret = 0;
1238 
1239 	fsnotify_group_lock(group);
1240 	fsn_mark = fsnotify_find_mark(connp, group);
1241 	if (!fsn_mark) {
1242 		fsn_mark = fanotify_add_new_mark(group, connp, obj_type,
1243 						 fan_flags, fsid);
1244 		if (IS_ERR(fsn_mark)) {
1245 			fsnotify_group_unlock(group);
1246 			return PTR_ERR(fsn_mark);
1247 		}
1248 	}
1249 
1250 	/*
1251 	 * Check if requested mark flags conflict with an existing mark flags.
1252 	 */
1253 	ret = fanotify_may_update_existing_mark(fsn_mark, fan_flags);
1254 	if (ret)
1255 		goto out;
1256 
1257 	/*
1258 	 * Error events are pre-allocated per group, only if strictly
1259 	 * needed (i.e. FAN_FS_ERROR was requested).
1260 	 */
1261 	if (!(fan_flags & FANOTIFY_MARK_IGNORE_BITS) &&
1262 	    (mask & FAN_FS_ERROR)) {
1263 		ret = fanotify_group_init_error_pool(group);
1264 		if (ret)
1265 			goto out;
1266 	}
1267 
1268 	recalc = fanotify_mark_add_to_mask(fsn_mark, mask, fan_flags);
1269 	if (recalc)
1270 		fsnotify_recalc_mask(fsn_mark->connector);
1271 
1272 out:
1273 	fsnotify_group_unlock(group);
1274 
1275 	fsnotify_put_mark(fsn_mark);
1276 	return ret;
1277 }
1278 
1279 static int fanotify_add_vfsmount_mark(struct fsnotify_group *group,
1280 				      struct vfsmount *mnt, __u32 mask,
1281 				      unsigned int flags, __kernel_fsid_t *fsid)
1282 {
1283 	return fanotify_add_mark(group, &real_mount(mnt)->mnt_fsnotify_marks,
1284 				 FSNOTIFY_OBJ_TYPE_VFSMOUNT, mask, flags, fsid);
1285 }
1286 
1287 static int fanotify_add_sb_mark(struct fsnotify_group *group,
1288 				struct super_block *sb, __u32 mask,
1289 				unsigned int flags, __kernel_fsid_t *fsid)
1290 {
1291 	return fanotify_add_mark(group, &sb->s_fsnotify_marks,
1292 				 FSNOTIFY_OBJ_TYPE_SB, mask, flags, fsid);
1293 }
1294 
1295 static int fanotify_add_inode_mark(struct fsnotify_group *group,
1296 				   struct inode *inode, __u32 mask,
1297 				   unsigned int flags, __kernel_fsid_t *fsid)
1298 {
1299 	pr_debug("%s: group=%p inode=%p\n", __func__, group, inode);
1300 
1301 	/*
1302 	 * If some other task has this inode open for write we should not add
1303 	 * an ignore mask, unless that ignore mask is supposed to survive
1304 	 * modification changes anyway.
1305 	 */
1306 	if ((flags & FANOTIFY_MARK_IGNORE_BITS) &&
1307 	    !(flags & FAN_MARK_IGNORED_SURV_MODIFY) &&
1308 	    inode_is_open_for_write(inode))
1309 		return 0;
1310 
1311 	return fanotify_add_mark(group, &inode->i_fsnotify_marks,
1312 				 FSNOTIFY_OBJ_TYPE_INODE, mask, flags, fsid);
1313 }
1314 
1315 static struct fsnotify_event *fanotify_alloc_overflow_event(void)
1316 {
1317 	struct fanotify_event *oevent;
1318 
1319 	oevent = kmalloc(sizeof(*oevent), GFP_KERNEL_ACCOUNT);
1320 	if (!oevent)
1321 		return NULL;
1322 
1323 	fanotify_init_event(oevent, 0, FS_Q_OVERFLOW);
1324 	oevent->type = FANOTIFY_EVENT_TYPE_OVERFLOW;
1325 
1326 	return &oevent->fse;
1327 }
1328 
1329 static struct hlist_head *fanotify_alloc_merge_hash(void)
1330 {
1331 	struct hlist_head *hash;
1332 
1333 	hash = kmalloc(sizeof(struct hlist_head) << FANOTIFY_HTABLE_BITS,
1334 		       GFP_KERNEL_ACCOUNT);
1335 	if (!hash)
1336 		return NULL;
1337 
1338 	__hash_init(hash, FANOTIFY_HTABLE_SIZE);
1339 
1340 	return hash;
1341 }
1342 
1343 /* fanotify syscalls */
1344 SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags)
1345 {
1346 	struct fsnotify_group *group;
1347 	int f_flags, fd;
1348 	unsigned int fid_mode = flags & FANOTIFY_FID_BITS;
1349 	unsigned int class = flags & FANOTIFY_CLASS_BITS;
1350 	unsigned int internal_flags = 0;
1351 
1352 	pr_debug("%s: flags=%x event_f_flags=%x\n",
1353 		 __func__, flags, event_f_flags);
1354 
1355 	if (!capable(CAP_SYS_ADMIN)) {
1356 		/*
1357 		 * An unprivileged user can setup an fanotify group with
1358 		 * limited functionality - an unprivileged group is limited to
1359 		 * notification events with file handles and it cannot use
1360 		 * unlimited queue/marks.
1361 		 */
1362 		if ((flags & FANOTIFY_ADMIN_INIT_FLAGS) || !fid_mode)
1363 			return -EPERM;
1364 
1365 		/*
1366 		 * Setting the internal flag FANOTIFY_UNPRIV on the group
1367 		 * prevents setting mount/filesystem marks on this group and
1368 		 * prevents reporting pid and open fd in events.
1369 		 */
1370 		internal_flags |= FANOTIFY_UNPRIV;
1371 	}
1372 
1373 #ifdef CONFIG_AUDITSYSCALL
1374 	if (flags & ~(FANOTIFY_INIT_FLAGS | FAN_ENABLE_AUDIT))
1375 #else
1376 	if (flags & ~FANOTIFY_INIT_FLAGS)
1377 #endif
1378 		return -EINVAL;
1379 
1380 	/*
1381 	 * A pidfd can only be returned for a thread-group leader; thus
1382 	 * FAN_REPORT_PIDFD and FAN_REPORT_TID need to remain mutually
1383 	 * exclusive.
1384 	 */
1385 	if ((flags & FAN_REPORT_PIDFD) && (flags & FAN_REPORT_TID))
1386 		return -EINVAL;
1387 
1388 	if (event_f_flags & ~FANOTIFY_INIT_ALL_EVENT_F_BITS)
1389 		return -EINVAL;
1390 
1391 	switch (event_f_flags & O_ACCMODE) {
1392 	case O_RDONLY:
1393 	case O_RDWR:
1394 	case O_WRONLY:
1395 		break;
1396 	default:
1397 		return -EINVAL;
1398 	}
1399 
1400 	if (fid_mode && class != FAN_CLASS_NOTIF)
1401 		return -EINVAL;
1402 
1403 	/*
1404 	 * Child name is reported with parent fid so requires dir fid.
1405 	 * We can report both child fid and dir fid with or without name.
1406 	 */
1407 	if ((fid_mode & FAN_REPORT_NAME) && !(fid_mode & FAN_REPORT_DIR_FID))
1408 		return -EINVAL;
1409 
1410 	/*
1411 	 * FAN_REPORT_TARGET_FID requires FAN_REPORT_NAME and FAN_REPORT_FID
1412 	 * and is used as an indication to report both dir and child fid on all
1413 	 * dirent events.
1414 	 */
1415 	if ((fid_mode & FAN_REPORT_TARGET_FID) &&
1416 	    (!(fid_mode & FAN_REPORT_NAME) || !(fid_mode & FAN_REPORT_FID)))
1417 		return -EINVAL;
1418 
1419 	f_flags = O_RDWR | __FMODE_NONOTIFY;
1420 	if (flags & FAN_CLOEXEC)
1421 		f_flags |= O_CLOEXEC;
1422 	if (flags & FAN_NONBLOCK)
1423 		f_flags |= O_NONBLOCK;
1424 
1425 	/* fsnotify_alloc_group takes a ref.  Dropped in fanotify_release */
1426 	group = fsnotify_alloc_group(&fanotify_fsnotify_ops,
1427 				     FSNOTIFY_GROUP_USER | FSNOTIFY_GROUP_NOFS);
1428 	if (IS_ERR(group)) {
1429 		return PTR_ERR(group);
1430 	}
1431 
1432 	/* Enforce groups limits per user in all containing user ns */
1433 	group->fanotify_data.ucounts = inc_ucount(current_user_ns(),
1434 						  current_euid(),
1435 						  UCOUNT_FANOTIFY_GROUPS);
1436 	if (!group->fanotify_data.ucounts) {
1437 		fd = -EMFILE;
1438 		goto out_destroy_group;
1439 	}
1440 
1441 	group->fanotify_data.flags = flags | internal_flags;
1442 	group->memcg = get_mem_cgroup_from_mm(current->mm);
1443 
1444 	group->fanotify_data.merge_hash = fanotify_alloc_merge_hash();
1445 	if (!group->fanotify_data.merge_hash) {
1446 		fd = -ENOMEM;
1447 		goto out_destroy_group;
1448 	}
1449 
1450 	group->overflow_event = fanotify_alloc_overflow_event();
1451 	if (unlikely(!group->overflow_event)) {
1452 		fd = -ENOMEM;
1453 		goto out_destroy_group;
1454 	}
1455 
1456 	if (force_o_largefile())
1457 		event_f_flags |= O_LARGEFILE;
1458 	group->fanotify_data.f_flags = event_f_flags;
1459 	init_waitqueue_head(&group->fanotify_data.access_waitq);
1460 	INIT_LIST_HEAD(&group->fanotify_data.access_list);
1461 	switch (class) {
1462 	case FAN_CLASS_NOTIF:
1463 		group->priority = FS_PRIO_0;
1464 		break;
1465 	case FAN_CLASS_CONTENT:
1466 		group->priority = FS_PRIO_1;
1467 		break;
1468 	case FAN_CLASS_PRE_CONTENT:
1469 		group->priority = FS_PRIO_2;
1470 		break;
1471 	default:
1472 		fd = -EINVAL;
1473 		goto out_destroy_group;
1474 	}
1475 
1476 	if (flags & FAN_UNLIMITED_QUEUE) {
1477 		fd = -EPERM;
1478 		if (!capable(CAP_SYS_ADMIN))
1479 			goto out_destroy_group;
1480 		group->max_events = UINT_MAX;
1481 	} else {
1482 		group->max_events = fanotify_max_queued_events;
1483 	}
1484 
1485 	if (flags & FAN_UNLIMITED_MARKS) {
1486 		fd = -EPERM;
1487 		if (!capable(CAP_SYS_ADMIN))
1488 			goto out_destroy_group;
1489 	}
1490 
1491 	if (flags & FAN_ENABLE_AUDIT) {
1492 		fd = -EPERM;
1493 		if (!capable(CAP_AUDIT_WRITE))
1494 			goto out_destroy_group;
1495 	}
1496 
1497 	fd = anon_inode_getfd("[fanotify]", &fanotify_fops, group, f_flags);
1498 	if (fd < 0)
1499 		goto out_destroy_group;
1500 
1501 	return fd;
1502 
1503 out_destroy_group:
1504 	fsnotify_destroy_group(group);
1505 	return fd;
1506 }
1507 
1508 static int fanotify_test_fsid(struct dentry *dentry, __kernel_fsid_t *fsid)
1509 {
1510 	__kernel_fsid_t root_fsid;
1511 	int err;
1512 
1513 	/*
1514 	 * Make sure dentry is not of a filesystem with zero fsid (e.g. fuse).
1515 	 */
1516 	err = vfs_get_fsid(dentry, fsid);
1517 	if (err)
1518 		return err;
1519 
1520 	if (!fsid->val[0] && !fsid->val[1])
1521 		return -ENODEV;
1522 
1523 	/*
1524 	 * Make sure dentry is not of a filesystem subvolume (e.g. btrfs)
1525 	 * which uses a different fsid than sb root.
1526 	 */
1527 	err = vfs_get_fsid(dentry->d_sb->s_root, &root_fsid);
1528 	if (err)
1529 		return err;
1530 
1531 	if (root_fsid.val[0] != fsid->val[0] ||
1532 	    root_fsid.val[1] != fsid->val[1])
1533 		return -EXDEV;
1534 
1535 	return 0;
1536 }
1537 
1538 /* Check if filesystem can encode a unique fid */
1539 static int fanotify_test_fid(struct dentry *dentry)
1540 {
1541 	/*
1542 	 * We need to make sure that the file system supports at least
1543 	 * encoding a file handle so user can use name_to_handle_at() to
1544 	 * compare fid returned with event to the file handle of watched
1545 	 * objects. However, name_to_handle_at() requires that the
1546 	 * filesystem also supports decoding file handles.
1547 	 */
1548 	if (!dentry->d_sb->s_export_op ||
1549 	    !dentry->d_sb->s_export_op->fh_to_dentry)
1550 		return -EOPNOTSUPP;
1551 
1552 	return 0;
1553 }
1554 
1555 static int fanotify_events_supported(struct fsnotify_group *group,
1556 				     struct path *path, __u64 mask,
1557 				     unsigned int flags)
1558 {
1559 	unsigned int mark_type = flags & FANOTIFY_MARK_TYPE_BITS;
1560 	/* Strict validation of events in non-dir inode mask with v5.17+ APIs */
1561 	bool strict_dir_events = FAN_GROUP_FLAG(group, FAN_REPORT_TARGET_FID) ||
1562 				 (mask & FAN_RENAME) ||
1563 				 (flags & FAN_MARK_IGNORE);
1564 
1565 	/*
1566 	 * Some filesystems such as 'proc' acquire unusual locks when opening
1567 	 * files. For them fanotify permission events have high chances of
1568 	 * deadlocking the system - open done when reporting fanotify event
1569 	 * blocks on this "unusual" lock while another process holding the lock
1570 	 * waits for fanotify permission event to be answered. Just disallow
1571 	 * permission events for such filesystems.
1572 	 */
1573 	if (mask & FANOTIFY_PERM_EVENTS &&
1574 	    path->mnt->mnt_sb->s_type->fs_flags & FS_DISALLOW_NOTIFY_PERM)
1575 		return -EINVAL;
1576 
1577 	/*
1578 	 * We shouldn't have allowed setting dirent events and the directory
1579 	 * flags FAN_ONDIR and FAN_EVENT_ON_CHILD in mask of non-dir inode,
1580 	 * but because we always allowed it, error only when using new APIs.
1581 	 */
1582 	if (strict_dir_events && mark_type == FAN_MARK_INODE &&
1583 	    !d_is_dir(path->dentry) && (mask & FANOTIFY_DIRONLY_EVENT_BITS))
1584 		return -ENOTDIR;
1585 
1586 	return 0;
1587 }
1588 
1589 static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,
1590 			    int dfd, const char  __user *pathname)
1591 {
1592 	struct inode *inode = NULL;
1593 	struct vfsmount *mnt = NULL;
1594 	struct fsnotify_group *group;
1595 	struct fd f;
1596 	struct path path;
1597 	__kernel_fsid_t __fsid, *fsid = NULL;
1598 	u32 valid_mask = FANOTIFY_EVENTS | FANOTIFY_EVENT_FLAGS;
1599 	unsigned int mark_type = flags & FANOTIFY_MARK_TYPE_BITS;
1600 	unsigned int mark_cmd = flags & FANOTIFY_MARK_CMD_BITS;
1601 	unsigned int ignore = flags & FANOTIFY_MARK_IGNORE_BITS;
1602 	unsigned int obj_type, fid_mode;
1603 	u32 umask = 0;
1604 	int ret;
1605 
1606 	pr_debug("%s: fanotify_fd=%d flags=%x dfd=%d pathname=%p mask=%llx\n",
1607 		 __func__, fanotify_fd, flags, dfd, pathname, mask);
1608 
1609 	/* we only use the lower 32 bits as of right now. */
1610 	if (upper_32_bits(mask))
1611 		return -EINVAL;
1612 
1613 	if (flags & ~FANOTIFY_MARK_FLAGS)
1614 		return -EINVAL;
1615 
1616 	switch (mark_type) {
1617 	case FAN_MARK_INODE:
1618 		obj_type = FSNOTIFY_OBJ_TYPE_INODE;
1619 		break;
1620 	case FAN_MARK_MOUNT:
1621 		obj_type = FSNOTIFY_OBJ_TYPE_VFSMOUNT;
1622 		break;
1623 	case FAN_MARK_FILESYSTEM:
1624 		obj_type = FSNOTIFY_OBJ_TYPE_SB;
1625 		break;
1626 	default:
1627 		return -EINVAL;
1628 	}
1629 
1630 	switch (mark_cmd) {
1631 	case FAN_MARK_ADD:
1632 	case FAN_MARK_REMOVE:
1633 		if (!mask)
1634 			return -EINVAL;
1635 		break;
1636 	case FAN_MARK_FLUSH:
1637 		if (flags & ~(FANOTIFY_MARK_TYPE_BITS | FAN_MARK_FLUSH))
1638 			return -EINVAL;
1639 		break;
1640 	default:
1641 		return -EINVAL;
1642 	}
1643 
1644 	if (IS_ENABLED(CONFIG_FANOTIFY_ACCESS_PERMISSIONS))
1645 		valid_mask |= FANOTIFY_PERM_EVENTS;
1646 
1647 	if (mask & ~valid_mask)
1648 		return -EINVAL;
1649 
1650 
1651 	/* We don't allow FAN_MARK_IGNORE & FAN_MARK_IGNORED_MASK together */
1652 	if (ignore == (FAN_MARK_IGNORE | FAN_MARK_IGNORED_MASK))
1653 		return -EINVAL;
1654 
1655 	/*
1656 	 * Event flags (FAN_ONDIR, FAN_EVENT_ON_CHILD) have no effect with
1657 	 * FAN_MARK_IGNORED_MASK.
1658 	 */
1659 	if (ignore == FAN_MARK_IGNORED_MASK) {
1660 		mask &= ~FANOTIFY_EVENT_FLAGS;
1661 		umask = FANOTIFY_EVENT_FLAGS;
1662 	}
1663 
1664 	f = fdget(fanotify_fd);
1665 	if (unlikely(!f.file))
1666 		return -EBADF;
1667 
1668 	/* verify that this is indeed an fanotify instance */
1669 	ret = -EINVAL;
1670 	if (unlikely(f.file->f_op != &fanotify_fops))
1671 		goto fput_and_out;
1672 	group = f.file->private_data;
1673 
1674 	/*
1675 	 * An unprivileged user is not allowed to setup mount nor filesystem
1676 	 * marks.  This also includes setting up such marks by a group that
1677 	 * was initialized by an unprivileged user.
1678 	 */
1679 	ret = -EPERM;
1680 	if ((!capable(CAP_SYS_ADMIN) ||
1681 	     FAN_GROUP_FLAG(group, FANOTIFY_UNPRIV)) &&
1682 	    mark_type != FAN_MARK_INODE)
1683 		goto fput_and_out;
1684 
1685 	/*
1686 	 * group->priority == FS_PRIO_0 == FAN_CLASS_NOTIF.  These are not
1687 	 * allowed to set permissions events.
1688 	 */
1689 	ret = -EINVAL;
1690 	if (mask & FANOTIFY_PERM_EVENTS &&
1691 	    group->priority == FS_PRIO_0)
1692 		goto fput_and_out;
1693 
1694 	if (mask & FAN_FS_ERROR &&
1695 	    mark_type != FAN_MARK_FILESYSTEM)
1696 		goto fput_and_out;
1697 
1698 	/*
1699 	 * Evictable is only relevant for inode marks, because only inode object
1700 	 * can be evicted on memory pressure.
1701 	 */
1702 	if (flags & FAN_MARK_EVICTABLE &&
1703 	     mark_type != FAN_MARK_INODE)
1704 		goto fput_and_out;
1705 
1706 	/*
1707 	 * Events that do not carry enough information to report
1708 	 * event->fd require a group that supports reporting fid.  Those
1709 	 * events are not supported on a mount mark, because they do not
1710 	 * carry enough information (i.e. path) to be filtered by mount
1711 	 * point.
1712 	 */
1713 	fid_mode = FAN_GROUP_FLAG(group, FANOTIFY_FID_BITS);
1714 	if (mask & ~(FANOTIFY_FD_EVENTS|FANOTIFY_EVENT_FLAGS) &&
1715 	    (!fid_mode || mark_type == FAN_MARK_MOUNT))
1716 		goto fput_and_out;
1717 
1718 	/*
1719 	 * FAN_RENAME uses special info type records to report the old and
1720 	 * new parent+name.  Reporting only old and new parent id is less
1721 	 * useful and was not implemented.
1722 	 */
1723 	if (mask & FAN_RENAME && !(fid_mode & FAN_REPORT_NAME))
1724 		goto fput_and_out;
1725 
1726 	if (mark_cmd == FAN_MARK_FLUSH) {
1727 		ret = 0;
1728 		if (mark_type == FAN_MARK_MOUNT)
1729 			fsnotify_clear_vfsmount_marks_by_group(group);
1730 		else if (mark_type == FAN_MARK_FILESYSTEM)
1731 			fsnotify_clear_sb_marks_by_group(group);
1732 		else
1733 			fsnotify_clear_inode_marks_by_group(group);
1734 		goto fput_and_out;
1735 	}
1736 
1737 	ret = fanotify_find_path(dfd, pathname, &path, flags,
1738 			(mask & ALL_FSNOTIFY_EVENTS), obj_type);
1739 	if (ret)
1740 		goto fput_and_out;
1741 
1742 	if (mark_cmd == FAN_MARK_ADD) {
1743 		ret = fanotify_events_supported(group, &path, mask, flags);
1744 		if (ret)
1745 			goto path_put_and_out;
1746 	}
1747 
1748 	if (fid_mode) {
1749 		ret = fanotify_test_fsid(path.dentry, &__fsid);
1750 		if (ret)
1751 			goto path_put_and_out;
1752 
1753 		ret = fanotify_test_fid(path.dentry);
1754 		if (ret)
1755 			goto path_put_and_out;
1756 
1757 		fsid = &__fsid;
1758 	}
1759 
1760 	/* inode held in place by reference to path; group by fget on fd */
1761 	if (mark_type == FAN_MARK_INODE)
1762 		inode = path.dentry->d_inode;
1763 	else
1764 		mnt = path.mnt;
1765 
1766 	ret = mnt ? -EINVAL : -EISDIR;
1767 	/* FAN_MARK_IGNORE requires SURV_MODIFY for sb/mount/dir marks */
1768 	if (mark_cmd == FAN_MARK_ADD && ignore == FAN_MARK_IGNORE &&
1769 	    (mnt || S_ISDIR(inode->i_mode)) &&
1770 	    !(flags & FAN_MARK_IGNORED_SURV_MODIFY))
1771 		goto path_put_and_out;
1772 
1773 	/* Mask out FAN_EVENT_ON_CHILD flag for sb/mount/non-dir marks */
1774 	if (mnt || !S_ISDIR(inode->i_mode)) {
1775 		mask &= ~FAN_EVENT_ON_CHILD;
1776 		umask = FAN_EVENT_ON_CHILD;
1777 		/*
1778 		 * If group needs to report parent fid, register for getting
1779 		 * events with parent/name info for non-directory.
1780 		 */
1781 		if ((fid_mode & FAN_REPORT_DIR_FID) &&
1782 		    (flags & FAN_MARK_ADD) && !ignore)
1783 			mask |= FAN_EVENT_ON_CHILD;
1784 	}
1785 
1786 	/* create/update an inode mark */
1787 	switch (mark_cmd) {
1788 	case FAN_MARK_ADD:
1789 		if (mark_type == FAN_MARK_MOUNT)
1790 			ret = fanotify_add_vfsmount_mark(group, mnt, mask,
1791 							 flags, fsid);
1792 		else if (mark_type == FAN_MARK_FILESYSTEM)
1793 			ret = fanotify_add_sb_mark(group, mnt->mnt_sb, mask,
1794 						   flags, fsid);
1795 		else
1796 			ret = fanotify_add_inode_mark(group, inode, mask,
1797 						      flags, fsid);
1798 		break;
1799 	case FAN_MARK_REMOVE:
1800 		if (mark_type == FAN_MARK_MOUNT)
1801 			ret = fanotify_remove_vfsmount_mark(group, mnt, mask,
1802 							    flags, umask);
1803 		else if (mark_type == FAN_MARK_FILESYSTEM)
1804 			ret = fanotify_remove_sb_mark(group, mnt->mnt_sb, mask,
1805 						      flags, umask);
1806 		else
1807 			ret = fanotify_remove_inode_mark(group, inode, mask,
1808 							 flags, umask);
1809 		break;
1810 	default:
1811 		ret = -EINVAL;
1812 	}
1813 
1814 path_put_and_out:
1815 	path_put(&path);
1816 fput_and_out:
1817 	fdput(f);
1818 	return ret;
1819 }
1820 
1821 #ifndef CONFIG_ARCH_SPLIT_ARG64
1822 SYSCALL_DEFINE5(fanotify_mark, int, fanotify_fd, unsigned int, flags,
1823 			      __u64, mask, int, dfd,
1824 			      const char  __user *, pathname)
1825 {
1826 	return do_fanotify_mark(fanotify_fd, flags, mask, dfd, pathname);
1827 }
1828 #endif
1829 
1830 #if defined(CONFIG_ARCH_SPLIT_ARG64) || defined(CONFIG_COMPAT)
1831 SYSCALL32_DEFINE6(fanotify_mark,
1832 				int, fanotify_fd, unsigned int, flags,
1833 				SC_ARG64(mask), int, dfd,
1834 				const char  __user *, pathname)
1835 {
1836 	return do_fanotify_mark(fanotify_fd, flags, SC_VAL64(__u64, mask),
1837 				dfd, pathname);
1838 }
1839 #endif
1840 
1841 /*
1842  * fanotify_user_setup - Our initialization function.  Note that we cannot return
1843  * error because we have compiled-in VFS hooks.  So an (unlikely) failure here
1844  * must result in panic().
1845  */
1846 static int __init fanotify_user_setup(void)
1847 {
1848 	struct sysinfo si;
1849 	int max_marks;
1850 
1851 	si_meminfo(&si);
1852 	/*
1853 	 * Allow up to 1% of addressable memory to be accounted for per user
1854 	 * marks limited to the range [8192, 1048576]. mount and sb marks are
1855 	 * a lot cheaper than inode marks, but there is no reason for a user
1856 	 * to have many of those, so calculate by the cost of inode marks.
1857 	 */
1858 	max_marks = (((si.totalram - si.totalhigh) / 100) << PAGE_SHIFT) /
1859 		    INODE_MARK_COST;
1860 	max_marks = clamp(max_marks, FANOTIFY_OLD_DEFAULT_MAX_MARKS,
1861 				     FANOTIFY_DEFAULT_MAX_USER_MARKS);
1862 
1863 	BUILD_BUG_ON(FANOTIFY_INIT_FLAGS & FANOTIFY_INTERNAL_GROUP_FLAGS);
1864 	BUILD_BUG_ON(HWEIGHT32(FANOTIFY_INIT_FLAGS) != 12);
1865 	BUILD_BUG_ON(HWEIGHT32(FANOTIFY_MARK_FLAGS) != 11);
1866 
1867 	fanotify_mark_cache = KMEM_CACHE(fsnotify_mark,
1868 					 SLAB_PANIC|SLAB_ACCOUNT);
1869 	fanotify_fid_event_cachep = KMEM_CACHE(fanotify_fid_event,
1870 					       SLAB_PANIC);
1871 	fanotify_path_event_cachep = KMEM_CACHE(fanotify_path_event,
1872 						SLAB_PANIC);
1873 	if (IS_ENABLED(CONFIG_FANOTIFY_ACCESS_PERMISSIONS)) {
1874 		fanotify_perm_event_cachep =
1875 			KMEM_CACHE(fanotify_perm_event, SLAB_PANIC);
1876 	}
1877 
1878 	fanotify_max_queued_events = FANOTIFY_DEFAULT_MAX_EVENTS;
1879 	init_user_ns.ucount_max[UCOUNT_FANOTIFY_GROUPS] =
1880 					FANOTIFY_DEFAULT_MAX_GROUPS;
1881 	init_user_ns.ucount_max[UCOUNT_FANOTIFY_MARKS] = max_marks;
1882 	fanotify_sysctls_init();
1883 
1884 	return 0;
1885 }
1886 device_initcall(fanotify_user_setup);
1887