xref: /openbmc/linux/fs/ext4/ioctl.c (revision 0b26ca68)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * linux/fs/ext4/ioctl.c
4  *
5  * Copyright (C) 1993, 1994, 1995
6  * Remy Card (card@masi.ibp.fr)
7  * Laboratoire MASI - Institut Blaise Pascal
8  * Universite Pierre et Marie Curie (Paris VI)
9  */
10 
11 #include <linux/fs.h>
12 #include <linux/capability.h>
13 #include <linux/time.h>
14 #include <linux/compat.h>
15 #include <linux/mount.h>
16 #include <linux/file.h>
17 #include <linux/quotaops.h>
18 #include <linux/random.h>
19 #include <linux/uuid.h>
20 #include <linux/uaccess.h>
21 #include <linux/delay.h>
22 #include <linux/iversion.h>
23 #include "ext4_jbd2.h"
24 #include "ext4.h"
25 #include <linux/fsmap.h>
26 #include "fsmap.h"
27 #include <trace/events/ext4.h>
28 
29 /**
30  * Swap memory between @a and @b for @len bytes.
31  *
32  * @a:          pointer to first memory area
33  * @b:          pointer to second memory area
34  * @len:        number of bytes to swap
35  *
36  */
37 static void memswap(void *a, void *b, size_t len)
38 {
39 	unsigned char *ap, *bp;
40 
41 	ap = (unsigned char *)a;
42 	bp = (unsigned char *)b;
43 	while (len-- > 0) {
44 		swap(*ap, *bp);
45 		ap++;
46 		bp++;
47 	}
48 }
49 
50 /**
51  * Swap i_data and associated attributes between @inode1 and @inode2.
52  * This function is used for the primary swap between inode1 and inode2
53  * and also to revert this primary swap in case of errors.
54  *
55  * Therefore you have to make sure, that calling this method twice
56  * will revert all changes.
57  *
58  * @inode1:     pointer to first inode
59  * @inode2:     pointer to second inode
60  */
61 static void swap_inode_data(struct inode *inode1, struct inode *inode2)
62 {
63 	loff_t isize;
64 	struct ext4_inode_info *ei1;
65 	struct ext4_inode_info *ei2;
66 	unsigned long tmp;
67 
68 	ei1 = EXT4_I(inode1);
69 	ei2 = EXT4_I(inode2);
70 
71 	swap(inode1->i_version, inode2->i_version);
72 	swap(inode1->i_atime, inode2->i_atime);
73 	swap(inode1->i_mtime, inode2->i_mtime);
74 
75 	memswap(ei1->i_data, ei2->i_data, sizeof(ei1->i_data));
76 	tmp = ei1->i_flags & EXT4_FL_SHOULD_SWAP;
77 	ei1->i_flags = (ei2->i_flags & EXT4_FL_SHOULD_SWAP) |
78 		(ei1->i_flags & ~EXT4_FL_SHOULD_SWAP);
79 	ei2->i_flags = tmp | (ei2->i_flags & ~EXT4_FL_SHOULD_SWAP);
80 	swap(ei1->i_disksize, ei2->i_disksize);
81 	ext4_es_remove_extent(inode1, 0, EXT_MAX_BLOCKS);
82 	ext4_es_remove_extent(inode2, 0, EXT_MAX_BLOCKS);
83 
84 	isize = i_size_read(inode1);
85 	i_size_write(inode1, i_size_read(inode2));
86 	i_size_write(inode2, isize);
87 }
88 
89 void ext4_reset_inode_seed(struct inode *inode)
90 {
91 	struct ext4_inode_info *ei = EXT4_I(inode);
92 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
93 	__le32 inum = cpu_to_le32(inode->i_ino);
94 	__le32 gen = cpu_to_le32(inode->i_generation);
95 	__u32 csum;
96 
97 	if (!ext4_has_metadata_csum(inode->i_sb))
98 		return;
99 
100 	csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum, sizeof(inum));
101 	ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen, sizeof(gen));
102 }
103 
104 /**
105  * Swap the information from the given @inode and the inode
106  * EXT4_BOOT_LOADER_INO. It will basically swap i_data and all other
107  * important fields of the inodes.
108  *
109  * @sb:         the super block of the filesystem
110  * @inode:      the inode to swap with EXT4_BOOT_LOADER_INO
111  *
112  */
113 static long swap_inode_boot_loader(struct super_block *sb,
114 				struct inode *inode)
115 {
116 	handle_t *handle;
117 	int err;
118 	struct inode *inode_bl;
119 	struct ext4_inode_info *ei_bl;
120 	qsize_t size, size_bl, diff;
121 	blkcnt_t blocks;
122 	unsigned short bytes;
123 
124 	inode_bl = ext4_iget(sb, EXT4_BOOT_LOADER_INO, EXT4_IGET_SPECIAL);
125 	if (IS_ERR(inode_bl))
126 		return PTR_ERR(inode_bl);
127 	ei_bl = EXT4_I(inode_bl);
128 
129 	/* Protect orig inodes against a truncate and make sure,
130 	 * that only 1 swap_inode_boot_loader is running. */
131 	lock_two_nondirectories(inode, inode_bl);
132 
133 	if (inode->i_nlink != 1 || !S_ISREG(inode->i_mode) ||
134 	    IS_SWAPFILE(inode) || IS_ENCRYPTED(inode) ||
135 	    (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL) ||
136 	    ext4_has_inline_data(inode)) {
137 		err = -EINVAL;
138 		goto journal_err_out;
139 	}
140 
141 	if (IS_RDONLY(inode) || IS_APPEND(inode) || IS_IMMUTABLE(inode) ||
142 	    !inode_owner_or_capable(inode) || !capable(CAP_SYS_ADMIN)) {
143 		err = -EPERM;
144 		goto journal_err_out;
145 	}
146 
147 	down_write(&EXT4_I(inode)->i_mmap_sem);
148 	err = filemap_write_and_wait(inode->i_mapping);
149 	if (err)
150 		goto err_out;
151 
152 	err = filemap_write_and_wait(inode_bl->i_mapping);
153 	if (err)
154 		goto err_out;
155 
156 	/* Wait for all existing dio workers */
157 	inode_dio_wait(inode);
158 	inode_dio_wait(inode_bl);
159 
160 	truncate_inode_pages(&inode->i_data, 0);
161 	truncate_inode_pages(&inode_bl->i_data, 0);
162 
163 	handle = ext4_journal_start(inode_bl, EXT4_HT_MOVE_EXTENTS, 2);
164 	if (IS_ERR(handle)) {
165 		err = -EINVAL;
166 		goto err_out;
167 	}
168 	ext4_fc_start_ineligible(sb, EXT4_FC_REASON_SWAP_BOOT);
169 
170 	/* Protect extent tree against block allocations via delalloc */
171 	ext4_double_down_write_data_sem(inode, inode_bl);
172 
173 	if (inode_bl->i_nlink == 0) {
174 		/* this inode has never been used as a BOOT_LOADER */
175 		set_nlink(inode_bl, 1);
176 		i_uid_write(inode_bl, 0);
177 		i_gid_write(inode_bl, 0);
178 		inode_bl->i_flags = 0;
179 		ei_bl->i_flags = 0;
180 		inode_set_iversion(inode_bl, 1);
181 		i_size_write(inode_bl, 0);
182 		inode_bl->i_mode = S_IFREG;
183 		if (ext4_has_feature_extents(sb)) {
184 			ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS);
185 			ext4_ext_tree_init(handle, inode_bl);
186 		} else
187 			memset(ei_bl->i_data, 0, sizeof(ei_bl->i_data));
188 	}
189 
190 	err = dquot_initialize(inode);
191 	if (err)
192 		goto err_out1;
193 
194 	size = (qsize_t)(inode->i_blocks) * (1 << 9) + inode->i_bytes;
195 	size_bl = (qsize_t)(inode_bl->i_blocks) * (1 << 9) + inode_bl->i_bytes;
196 	diff = size - size_bl;
197 	swap_inode_data(inode, inode_bl);
198 
199 	inode->i_ctime = inode_bl->i_ctime = current_time(inode);
200 
201 	inode->i_generation = prandom_u32();
202 	inode_bl->i_generation = prandom_u32();
203 	ext4_reset_inode_seed(inode);
204 	ext4_reset_inode_seed(inode_bl);
205 
206 	ext4_discard_preallocations(inode, 0);
207 
208 	err = ext4_mark_inode_dirty(handle, inode);
209 	if (err < 0) {
210 		/* No need to update quota information. */
211 		ext4_warning(inode->i_sb,
212 			"couldn't mark inode #%lu dirty (err %d)",
213 			inode->i_ino, err);
214 		/* Revert all changes: */
215 		swap_inode_data(inode, inode_bl);
216 		ext4_mark_inode_dirty(handle, inode);
217 		goto err_out1;
218 	}
219 
220 	blocks = inode_bl->i_blocks;
221 	bytes = inode_bl->i_bytes;
222 	inode_bl->i_blocks = inode->i_blocks;
223 	inode_bl->i_bytes = inode->i_bytes;
224 	err = ext4_mark_inode_dirty(handle, inode_bl);
225 	if (err < 0) {
226 		/* No need to update quota information. */
227 		ext4_warning(inode_bl->i_sb,
228 			"couldn't mark inode #%lu dirty (err %d)",
229 			inode_bl->i_ino, err);
230 		goto revert;
231 	}
232 
233 	/* Bootloader inode should not be counted into quota information. */
234 	if (diff > 0)
235 		dquot_free_space(inode, diff);
236 	else
237 		err = dquot_alloc_space(inode, -1 * diff);
238 
239 	if (err < 0) {
240 revert:
241 		/* Revert all changes: */
242 		inode_bl->i_blocks = blocks;
243 		inode_bl->i_bytes = bytes;
244 		swap_inode_data(inode, inode_bl);
245 		ext4_mark_inode_dirty(handle, inode);
246 		ext4_mark_inode_dirty(handle, inode_bl);
247 	}
248 
249 err_out1:
250 	ext4_journal_stop(handle);
251 	ext4_fc_stop_ineligible(sb);
252 	ext4_double_up_write_data_sem(inode, inode_bl);
253 
254 err_out:
255 	up_write(&EXT4_I(inode)->i_mmap_sem);
256 journal_err_out:
257 	unlock_two_nondirectories(inode, inode_bl);
258 	iput(inode_bl);
259 	return err;
260 }
261 
262 #ifdef CONFIG_FS_ENCRYPTION
263 static int uuid_is_zero(__u8 u[16])
264 {
265 	int	i;
266 
267 	for (i = 0; i < 16; i++)
268 		if (u[i])
269 			return 0;
270 	return 1;
271 }
272 #endif
273 
274 /*
275  * If immutable is set and we are not clearing it, we're not allowed to change
276  * anything else in the inode.  Don't error out if we're only trying to set
277  * immutable on an immutable file.
278  */
279 static int ext4_ioctl_check_immutable(struct inode *inode, __u32 new_projid,
280 				      unsigned int flags)
281 {
282 	struct ext4_inode_info *ei = EXT4_I(inode);
283 	unsigned int oldflags = ei->i_flags;
284 
285 	if (!(oldflags & EXT4_IMMUTABLE_FL) || !(flags & EXT4_IMMUTABLE_FL))
286 		return 0;
287 
288 	if ((oldflags & ~EXT4_IMMUTABLE_FL) != (flags & ~EXT4_IMMUTABLE_FL))
289 		return -EPERM;
290 	if (ext4_has_feature_project(inode->i_sb) &&
291 	    __kprojid_val(ei->i_projid) != new_projid)
292 		return -EPERM;
293 
294 	return 0;
295 }
296 
297 static void ext4_dax_dontcache(struct inode *inode, unsigned int flags)
298 {
299 	struct ext4_inode_info *ei = EXT4_I(inode);
300 
301 	if (S_ISDIR(inode->i_mode))
302 		return;
303 
304 	if (test_opt2(inode->i_sb, DAX_NEVER) ||
305 	    test_opt(inode->i_sb, DAX_ALWAYS))
306 		return;
307 
308 	if ((ei->i_flags ^ flags) & EXT4_DAX_FL)
309 		d_mark_dontcache(inode);
310 }
311 
312 static bool dax_compatible(struct inode *inode, unsigned int oldflags,
313 			   unsigned int flags)
314 {
315 	if (flags & EXT4_DAX_FL) {
316 		if ((oldflags & EXT4_DAX_MUT_EXCL) ||
317 		     ext4_test_inode_state(inode,
318 					  EXT4_STATE_VERITY_IN_PROGRESS)) {
319 			return false;
320 		}
321 	}
322 
323 	if ((flags & EXT4_DAX_MUT_EXCL) && (oldflags & EXT4_DAX_FL))
324 			return false;
325 
326 	return true;
327 }
328 
329 static int ext4_ioctl_setflags(struct inode *inode,
330 			       unsigned int flags)
331 {
332 	struct ext4_inode_info *ei = EXT4_I(inode);
333 	handle_t *handle = NULL;
334 	int err = -EPERM, migrate = 0;
335 	struct ext4_iloc iloc;
336 	unsigned int oldflags, mask, i;
337 	struct super_block *sb = inode->i_sb;
338 
339 	/* Is it quota file? Do not allow user to mess with it */
340 	if (ext4_is_quota_file(inode))
341 		goto flags_out;
342 
343 	oldflags = ei->i_flags;
344 
345 	err = vfs_ioc_setflags_prepare(inode, oldflags, flags);
346 	if (err)
347 		goto flags_out;
348 
349 	/*
350 	 * The JOURNAL_DATA flag can only be changed by
351 	 * the relevant capability.
352 	 */
353 	if ((flags ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
354 		if (!capable(CAP_SYS_RESOURCE))
355 			goto flags_out;
356 	}
357 
358 	if (!dax_compatible(inode, oldflags, flags)) {
359 		err = -EOPNOTSUPP;
360 		goto flags_out;
361 	}
362 
363 	if ((flags ^ oldflags) & EXT4_EXTENTS_FL)
364 		migrate = 1;
365 
366 	if ((flags ^ oldflags) & EXT4_CASEFOLD_FL) {
367 		if (!ext4_has_feature_casefold(sb)) {
368 			err = -EOPNOTSUPP;
369 			goto flags_out;
370 		}
371 
372 		if (!S_ISDIR(inode->i_mode)) {
373 			err = -ENOTDIR;
374 			goto flags_out;
375 		}
376 
377 		if (!ext4_empty_dir(inode)) {
378 			err = -ENOTEMPTY;
379 			goto flags_out;
380 		}
381 	}
382 
383 	/*
384 	 * Wait for all pending directio and then flush all the dirty pages
385 	 * for this file.  The flush marks all the pages readonly, so any
386 	 * subsequent attempt to write to the file (particularly mmap pages)
387 	 * will come through the filesystem and fail.
388 	 */
389 	if (S_ISREG(inode->i_mode) && !IS_IMMUTABLE(inode) &&
390 	    (flags & EXT4_IMMUTABLE_FL)) {
391 		inode_dio_wait(inode);
392 		err = filemap_write_and_wait(inode->i_mapping);
393 		if (err)
394 			goto flags_out;
395 	}
396 
397 	handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
398 	if (IS_ERR(handle)) {
399 		err = PTR_ERR(handle);
400 		goto flags_out;
401 	}
402 	if (IS_SYNC(inode))
403 		ext4_handle_sync(handle);
404 	err = ext4_reserve_inode_write(handle, inode, &iloc);
405 	if (err)
406 		goto flags_err;
407 
408 	ext4_dax_dontcache(inode, flags);
409 
410 	for (i = 0, mask = 1; i < 32; i++, mask <<= 1) {
411 		if (!(mask & EXT4_FL_USER_MODIFIABLE))
412 			continue;
413 		/* These flags get special treatment later */
414 		if (mask == EXT4_JOURNAL_DATA_FL || mask == EXT4_EXTENTS_FL)
415 			continue;
416 		if (mask & flags)
417 			ext4_set_inode_flag(inode, i);
418 		else
419 			ext4_clear_inode_flag(inode, i);
420 	}
421 
422 	ext4_set_inode_flags(inode, false);
423 
424 	inode->i_ctime = current_time(inode);
425 
426 	err = ext4_mark_iloc_dirty(handle, inode, &iloc);
427 flags_err:
428 	ext4_journal_stop(handle);
429 	if (err)
430 		goto flags_out;
431 
432 	if ((flags ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
433 		/*
434 		 * Changes to the journaling mode can cause unsafe changes to
435 		 * S_DAX if the inode is DAX
436 		 */
437 		if (IS_DAX(inode)) {
438 			err = -EBUSY;
439 			goto flags_out;
440 		}
441 
442 		err = ext4_change_inode_journal_flag(inode,
443 						     flags & EXT4_JOURNAL_DATA_FL);
444 		if (err)
445 			goto flags_out;
446 	}
447 	if (migrate) {
448 		if (flags & EXT4_EXTENTS_FL)
449 			err = ext4_ext_migrate(inode);
450 		else
451 			err = ext4_ind_migrate(inode);
452 	}
453 
454 flags_out:
455 	return err;
456 }
457 
458 #ifdef CONFIG_QUOTA
459 static int ext4_ioctl_setproject(struct file *filp, __u32 projid)
460 {
461 	struct inode *inode = file_inode(filp);
462 	struct super_block *sb = inode->i_sb;
463 	struct ext4_inode_info *ei = EXT4_I(inode);
464 	int err, rc;
465 	handle_t *handle;
466 	kprojid_t kprojid;
467 	struct ext4_iloc iloc;
468 	struct ext4_inode *raw_inode;
469 	struct dquot *transfer_to[MAXQUOTAS] = { };
470 
471 	if (!ext4_has_feature_project(sb)) {
472 		if (projid != EXT4_DEF_PROJID)
473 			return -EOPNOTSUPP;
474 		else
475 			return 0;
476 	}
477 
478 	if (EXT4_INODE_SIZE(sb) <= EXT4_GOOD_OLD_INODE_SIZE)
479 		return -EOPNOTSUPP;
480 
481 	kprojid = make_kprojid(&init_user_ns, (projid_t)projid);
482 
483 	if (projid_eq(kprojid, EXT4_I(inode)->i_projid))
484 		return 0;
485 
486 	err = -EPERM;
487 	/* Is it quota file? Do not allow user to mess with it */
488 	if (ext4_is_quota_file(inode))
489 		return err;
490 
491 	err = ext4_get_inode_loc(inode, &iloc);
492 	if (err)
493 		return err;
494 
495 	raw_inode = ext4_raw_inode(&iloc);
496 	if (!EXT4_FITS_IN_INODE(raw_inode, ei, i_projid)) {
497 		err = ext4_expand_extra_isize(inode,
498 					      EXT4_SB(sb)->s_want_extra_isize,
499 					      &iloc);
500 		if (err)
501 			return err;
502 	} else {
503 		brelse(iloc.bh);
504 	}
505 
506 	err = dquot_initialize(inode);
507 	if (err)
508 		return err;
509 
510 	handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
511 		EXT4_QUOTA_INIT_BLOCKS(sb) +
512 		EXT4_QUOTA_DEL_BLOCKS(sb) + 3);
513 	if (IS_ERR(handle))
514 		return PTR_ERR(handle);
515 
516 	err = ext4_reserve_inode_write(handle, inode, &iloc);
517 	if (err)
518 		goto out_stop;
519 
520 	transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid));
521 	if (!IS_ERR(transfer_to[PRJQUOTA])) {
522 
523 		/* __dquot_transfer() calls back ext4_get_inode_usage() which
524 		 * counts xattr inode references.
525 		 */
526 		down_read(&EXT4_I(inode)->xattr_sem);
527 		err = __dquot_transfer(inode, transfer_to);
528 		up_read(&EXT4_I(inode)->xattr_sem);
529 		dqput(transfer_to[PRJQUOTA]);
530 		if (err)
531 			goto out_dirty;
532 	}
533 
534 	EXT4_I(inode)->i_projid = kprojid;
535 	inode->i_ctime = current_time(inode);
536 out_dirty:
537 	rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
538 	if (!err)
539 		err = rc;
540 out_stop:
541 	ext4_journal_stop(handle);
542 	return err;
543 }
544 #else
545 static int ext4_ioctl_setproject(struct file *filp, __u32 projid)
546 {
547 	if (projid != EXT4_DEF_PROJID)
548 		return -EOPNOTSUPP;
549 	return 0;
550 }
551 #endif
552 
553 /* Transfer internal flags to xflags */
554 static inline __u32 ext4_iflags_to_xflags(unsigned long iflags)
555 {
556 	__u32 xflags = 0;
557 
558 	if (iflags & EXT4_SYNC_FL)
559 		xflags |= FS_XFLAG_SYNC;
560 	if (iflags & EXT4_IMMUTABLE_FL)
561 		xflags |= FS_XFLAG_IMMUTABLE;
562 	if (iflags & EXT4_APPEND_FL)
563 		xflags |= FS_XFLAG_APPEND;
564 	if (iflags & EXT4_NODUMP_FL)
565 		xflags |= FS_XFLAG_NODUMP;
566 	if (iflags & EXT4_NOATIME_FL)
567 		xflags |= FS_XFLAG_NOATIME;
568 	if (iflags & EXT4_PROJINHERIT_FL)
569 		xflags |= FS_XFLAG_PROJINHERIT;
570 	if (iflags & EXT4_DAX_FL)
571 		xflags |= FS_XFLAG_DAX;
572 	return xflags;
573 }
574 
575 #define EXT4_SUPPORTED_FS_XFLAGS (FS_XFLAG_SYNC | FS_XFLAG_IMMUTABLE | \
576 				  FS_XFLAG_APPEND | FS_XFLAG_NODUMP | \
577 				  FS_XFLAG_NOATIME | FS_XFLAG_PROJINHERIT | \
578 				  FS_XFLAG_DAX)
579 
580 /* Transfer xflags flags to internal */
581 static inline unsigned long ext4_xflags_to_iflags(__u32 xflags)
582 {
583 	unsigned long iflags = 0;
584 
585 	if (xflags & FS_XFLAG_SYNC)
586 		iflags |= EXT4_SYNC_FL;
587 	if (xflags & FS_XFLAG_IMMUTABLE)
588 		iflags |= EXT4_IMMUTABLE_FL;
589 	if (xflags & FS_XFLAG_APPEND)
590 		iflags |= EXT4_APPEND_FL;
591 	if (xflags & FS_XFLAG_NODUMP)
592 		iflags |= EXT4_NODUMP_FL;
593 	if (xflags & FS_XFLAG_NOATIME)
594 		iflags |= EXT4_NOATIME_FL;
595 	if (xflags & FS_XFLAG_PROJINHERIT)
596 		iflags |= EXT4_PROJINHERIT_FL;
597 	if (xflags & FS_XFLAG_DAX)
598 		iflags |= EXT4_DAX_FL;
599 
600 	return iflags;
601 }
602 
603 static int ext4_shutdown(struct super_block *sb, unsigned long arg)
604 {
605 	struct ext4_sb_info *sbi = EXT4_SB(sb);
606 	__u32 flags;
607 
608 	if (!capable(CAP_SYS_ADMIN))
609 		return -EPERM;
610 
611 	if (get_user(flags, (__u32 __user *)arg))
612 		return -EFAULT;
613 
614 	if (flags > EXT4_GOING_FLAGS_NOLOGFLUSH)
615 		return -EINVAL;
616 
617 	if (ext4_forced_shutdown(sbi))
618 		return 0;
619 
620 	ext4_msg(sb, KERN_ALERT, "shut down requested (%d)", flags);
621 	trace_ext4_shutdown(sb, flags);
622 
623 	switch (flags) {
624 	case EXT4_GOING_FLAGS_DEFAULT:
625 		freeze_bdev(sb->s_bdev);
626 		set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
627 		thaw_bdev(sb->s_bdev);
628 		break;
629 	case EXT4_GOING_FLAGS_LOGFLUSH:
630 		set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
631 		if (sbi->s_journal && !is_journal_aborted(sbi->s_journal)) {
632 			(void) ext4_force_commit(sb);
633 			jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN);
634 		}
635 		break;
636 	case EXT4_GOING_FLAGS_NOLOGFLUSH:
637 		set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
638 		if (sbi->s_journal && !is_journal_aborted(sbi->s_journal))
639 			jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN);
640 		break;
641 	default:
642 		return -EINVAL;
643 	}
644 	clear_opt(sb, DISCARD);
645 	return 0;
646 }
647 
648 struct getfsmap_info {
649 	struct super_block	*gi_sb;
650 	struct fsmap_head __user *gi_data;
651 	unsigned int		gi_idx;
652 	__u32			gi_last_flags;
653 };
654 
655 static int ext4_getfsmap_format(struct ext4_fsmap *xfm, void *priv)
656 {
657 	struct getfsmap_info *info = priv;
658 	struct fsmap fm;
659 
660 	trace_ext4_getfsmap_mapping(info->gi_sb, xfm);
661 
662 	info->gi_last_flags = xfm->fmr_flags;
663 	ext4_fsmap_from_internal(info->gi_sb, &fm, xfm);
664 	if (copy_to_user(&info->gi_data->fmh_recs[info->gi_idx++], &fm,
665 			sizeof(struct fsmap)))
666 		return -EFAULT;
667 
668 	return 0;
669 }
670 
671 static int ext4_ioc_getfsmap(struct super_block *sb,
672 			     struct fsmap_head __user *arg)
673 {
674 	struct getfsmap_info info = { NULL };
675 	struct ext4_fsmap_head xhead = {0};
676 	struct fsmap_head head;
677 	bool aborted = false;
678 	int error;
679 
680 	if (copy_from_user(&head, arg, sizeof(struct fsmap_head)))
681 		return -EFAULT;
682 	if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) ||
683 	    memchr_inv(head.fmh_keys[0].fmr_reserved, 0,
684 		       sizeof(head.fmh_keys[0].fmr_reserved)) ||
685 	    memchr_inv(head.fmh_keys[1].fmr_reserved, 0,
686 		       sizeof(head.fmh_keys[1].fmr_reserved)))
687 		return -EINVAL;
688 	/*
689 	 * ext4 doesn't report file extents at all, so the only valid
690 	 * file offsets are the magic ones (all zeroes or all ones).
691 	 */
692 	if (head.fmh_keys[0].fmr_offset ||
693 	    (head.fmh_keys[1].fmr_offset != 0 &&
694 	     head.fmh_keys[1].fmr_offset != -1ULL))
695 		return -EINVAL;
696 
697 	xhead.fmh_iflags = head.fmh_iflags;
698 	xhead.fmh_count = head.fmh_count;
699 	ext4_fsmap_to_internal(sb, &xhead.fmh_keys[0], &head.fmh_keys[0]);
700 	ext4_fsmap_to_internal(sb, &xhead.fmh_keys[1], &head.fmh_keys[1]);
701 
702 	trace_ext4_getfsmap_low_key(sb, &xhead.fmh_keys[0]);
703 	trace_ext4_getfsmap_high_key(sb, &xhead.fmh_keys[1]);
704 
705 	info.gi_sb = sb;
706 	info.gi_data = arg;
707 	error = ext4_getfsmap(sb, &xhead, ext4_getfsmap_format, &info);
708 	if (error == EXT4_QUERY_RANGE_ABORT) {
709 		error = 0;
710 		aborted = true;
711 	} else if (error)
712 		return error;
713 
714 	/* If we didn't abort, set the "last" flag in the last fmx */
715 	if (!aborted && info.gi_idx) {
716 		info.gi_last_flags |= FMR_OF_LAST;
717 		if (copy_to_user(&info.gi_data->fmh_recs[info.gi_idx - 1].fmr_flags,
718 				 &info.gi_last_flags,
719 				 sizeof(info.gi_last_flags)))
720 			return -EFAULT;
721 	}
722 
723 	/* copy back header */
724 	head.fmh_entries = xhead.fmh_entries;
725 	head.fmh_oflags = xhead.fmh_oflags;
726 	if (copy_to_user(arg, &head, sizeof(struct fsmap_head)))
727 		return -EFAULT;
728 
729 	return 0;
730 }
731 
732 static long ext4_ioctl_group_add(struct file *file,
733 				 struct ext4_new_group_data *input)
734 {
735 	struct super_block *sb = file_inode(file)->i_sb;
736 	int err, err2=0;
737 
738 	err = ext4_resize_begin(sb);
739 	if (err)
740 		return err;
741 
742 	if (ext4_has_feature_bigalloc(sb)) {
743 		ext4_msg(sb, KERN_ERR,
744 			 "Online resizing not supported with bigalloc");
745 		err = -EOPNOTSUPP;
746 		goto group_add_out;
747 	}
748 
749 	err = mnt_want_write_file(file);
750 	if (err)
751 		goto group_add_out;
752 
753 	err = ext4_group_add(sb, input);
754 	if (EXT4_SB(sb)->s_journal) {
755 		jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
756 		err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
757 		jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
758 	}
759 	if (err == 0)
760 		err = err2;
761 	mnt_drop_write_file(file);
762 	if (!err && ext4_has_group_desc_csum(sb) &&
763 	    test_opt(sb, INIT_INODE_TABLE))
764 		err = ext4_register_li_request(sb, input->group);
765 group_add_out:
766 	ext4_resize_end(sb);
767 	return err;
768 }
769 
770 static void ext4_fill_fsxattr(struct inode *inode, struct fsxattr *fa)
771 {
772 	struct ext4_inode_info *ei = EXT4_I(inode);
773 
774 	simple_fill_fsxattr(fa, ext4_iflags_to_xflags(ei->i_flags &
775 						      EXT4_FL_USER_VISIBLE));
776 
777 	if (ext4_has_feature_project(inode->i_sb))
778 		fa->fsx_projid = from_kprojid(&init_user_ns, ei->i_projid);
779 }
780 
781 /* So that the fiemap access checks can't overflow on 32 bit machines. */
782 #define FIEMAP_MAX_EXTENTS	(UINT_MAX / sizeof(struct fiemap_extent))
783 
784 static int ext4_ioctl_get_es_cache(struct file *filp, unsigned long arg)
785 {
786 	struct fiemap fiemap;
787 	struct fiemap __user *ufiemap = (struct fiemap __user *) arg;
788 	struct fiemap_extent_info fieinfo = { 0, };
789 	struct inode *inode = file_inode(filp);
790 	int error;
791 
792 	if (copy_from_user(&fiemap, ufiemap, sizeof(fiemap)))
793 		return -EFAULT;
794 
795 	if (fiemap.fm_extent_count > FIEMAP_MAX_EXTENTS)
796 		return -EINVAL;
797 
798 	fieinfo.fi_flags = fiemap.fm_flags;
799 	fieinfo.fi_extents_max = fiemap.fm_extent_count;
800 	fieinfo.fi_extents_start = ufiemap->fm_extents;
801 
802 	error = ext4_get_es_cache(inode, &fieinfo, fiemap.fm_start,
803 			fiemap.fm_length);
804 	fiemap.fm_flags = fieinfo.fi_flags;
805 	fiemap.fm_mapped_extents = fieinfo.fi_extents_mapped;
806 	if (copy_to_user(ufiemap, &fiemap, sizeof(fiemap)))
807 		error = -EFAULT;
808 
809 	return error;
810 }
811 
812 static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
813 {
814 	struct inode *inode = file_inode(filp);
815 	struct super_block *sb = inode->i_sb;
816 	struct ext4_inode_info *ei = EXT4_I(inode);
817 	unsigned int flags;
818 
819 	ext4_debug("cmd = %u, arg = %lu\n", cmd, arg);
820 
821 	switch (cmd) {
822 	case FS_IOC_GETFSMAP:
823 		return ext4_ioc_getfsmap(sb, (void __user *)arg);
824 	case FS_IOC_GETFLAGS:
825 		flags = ei->i_flags & EXT4_FL_USER_VISIBLE;
826 		if (S_ISREG(inode->i_mode))
827 			flags &= ~EXT4_PROJINHERIT_FL;
828 		return put_user(flags, (int __user *) arg);
829 	case FS_IOC_SETFLAGS: {
830 		int err;
831 
832 		if (!inode_owner_or_capable(inode))
833 			return -EACCES;
834 
835 		if (get_user(flags, (int __user *) arg))
836 			return -EFAULT;
837 
838 		if (flags & ~EXT4_FL_USER_VISIBLE)
839 			return -EOPNOTSUPP;
840 		/*
841 		 * chattr(1) grabs flags via GETFLAGS, modifies the result and
842 		 * passes that to SETFLAGS. So we cannot easily make SETFLAGS
843 		 * more restrictive than just silently masking off visible but
844 		 * not settable flags as we always did.
845 		 */
846 		flags &= EXT4_FL_USER_MODIFIABLE;
847 		if (ext4_mask_flags(inode->i_mode, flags) != flags)
848 			return -EOPNOTSUPP;
849 
850 		err = mnt_want_write_file(filp);
851 		if (err)
852 			return err;
853 
854 		inode_lock(inode);
855 		err = ext4_ioctl_check_immutable(inode,
856 				from_kprojid(&init_user_ns, ei->i_projid),
857 				flags);
858 		if (!err)
859 			err = ext4_ioctl_setflags(inode, flags);
860 		inode_unlock(inode);
861 		mnt_drop_write_file(filp);
862 		return err;
863 	}
864 	case EXT4_IOC_GETVERSION:
865 	case EXT4_IOC_GETVERSION_OLD:
866 		return put_user(inode->i_generation, (int __user *) arg);
867 	case EXT4_IOC_SETVERSION:
868 	case EXT4_IOC_SETVERSION_OLD: {
869 		handle_t *handle;
870 		struct ext4_iloc iloc;
871 		__u32 generation;
872 		int err;
873 
874 		if (!inode_owner_or_capable(inode))
875 			return -EPERM;
876 
877 		if (ext4_has_metadata_csum(inode->i_sb)) {
878 			ext4_warning(sb, "Setting inode version is not "
879 				     "supported with metadata_csum enabled.");
880 			return -ENOTTY;
881 		}
882 
883 		err = mnt_want_write_file(filp);
884 		if (err)
885 			return err;
886 		if (get_user(generation, (int __user *) arg)) {
887 			err = -EFAULT;
888 			goto setversion_out;
889 		}
890 
891 		inode_lock(inode);
892 		handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
893 		if (IS_ERR(handle)) {
894 			err = PTR_ERR(handle);
895 			goto unlock_out;
896 		}
897 		err = ext4_reserve_inode_write(handle, inode, &iloc);
898 		if (err == 0) {
899 			inode->i_ctime = current_time(inode);
900 			inode->i_generation = generation;
901 			err = ext4_mark_iloc_dirty(handle, inode, &iloc);
902 		}
903 		ext4_journal_stop(handle);
904 
905 unlock_out:
906 		inode_unlock(inode);
907 setversion_out:
908 		mnt_drop_write_file(filp);
909 		return err;
910 	}
911 	case EXT4_IOC_GROUP_EXTEND: {
912 		ext4_fsblk_t n_blocks_count;
913 		int err, err2=0;
914 
915 		err = ext4_resize_begin(sb);
916 		if (err)
917 			return err;
918 
919 		if (get_user(n_blocks_count, (__u32 __user *)arg)) {
920 			err = -EFAULT;
921 			goto group_extend_out;
922 		}
923 
924 		if (ext4_has_feature_bigalloc(sb)) {
925 			ext4_msg(sb, KERN_ERR,
926 				 "Online resizing not supported with bigalloc");
927 			err = -EOPNOTSUPP;
928 			goto group_extend_out;
929 		}
930 
931 		err = mnt_want_write_file(filp);
932 		if (err)
933 			goto group_extend_out;
934 
935 		err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count);
936 		if (EXT4_SB(sb)->s_journal) {
937 			jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
938 			err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
939 			jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
940 		}
941 		if (err == 0)
942 			err = err2;
943 		mnt_drop_write_file(filp);
944 group_extend_out:
945 		ext4_resize_end(sb);
946 		return err;
947 	}
948 
949 	case EXT4_IOC_MOVE_EXT: {
950 		struct move_extent me;
951 		struct fd donor;
952 		int err;
953 
954 		if (!(filp->f_mode & FMODE_READ) ||
955 		    !(filp->f_mode & FMODE_WRITE))
956 			return -EBADF;
957 
958 		if (copy_from_user(&me,
959 			(struct move_extent __user *)arg, sizeof(me)))
960 			return -EFAULT;
961 		me.moved_len = 0;
962 
963 		donor = fdget(me.donor_fd);
964 		if (!donor.file)
965 			return -EBADF;
966 
967 		if (!(donor.file->f_mode & FMODE_WRITE)) {
968 			err = -EBADF;
969 			goto mext_out;
970 		}
971 
972 		if (ext4_has_feature_bigalloc(sb)) {
973 			ext4_msg(sb, KERN_ERR,
974 				 "Online defrag not supported with bigalloc");
975 			err = -EOPNOTSUPP;
976 			goto mext_out;
977 		} else if (IS_DAX(inode)) {
978 			ext4_msg(sb, KERN_ERR,
979 				 "Online defrag not supported with DAX");
980 			err = -EOPNOTSUPP;
981 			goto mext_out;
982 		}
983 
984 		err = mnt_want_write_file(filp);
985 		if (err)
986 			goto mext_out;
987 
988 		err = ext4_move_extents(filp, donor.file, me.orig_start,
989 					me.donor_start, me.len, &me.moved_len);
990 		mnt_drop_write_file(filp);
991 
992 		if (copy_to_user((struct move_extent __user *)arg,
993 				 &me, sizeof(me)))
994 			err = -EFAULT;
995 mext_out:
996 		fdput(donor);
997 		return err;
998 	}
999 
1000 	case EXT4_IOC_GROUP_ADD: {
1001 		struct ext4_new_group_data input;
1002 
1003 		if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,
1004 				sizeof(input)))
1005 			return -EFAULT;
1006 
1007 		return ext4_ioctl_group_add(filp, &input);
1008 	}
1009 
1010 	case EXT4_IOC_MIGRATE:
1011 	{
1012 		int err;
1013 		if (!inode_owner_or_capable(inode))
1014 			return -EACCES;
1015 
1016 		err = mnt_want_write_file(filp);
1017 		if (err)
1018 			return err;
1019 		/*
1020 		 * inode_mutex prevent write and truncate on the file.
1021 		 * Read still goes through. We take i_data_sem in
1022 		 * ext4_ext_swap_inode_data before we switch the
1023 		 * inode format to prevent read.
1024 		 */
1025 		inode_lock((inode));
1026 		err = ext4_ext_migrate(inode);
1027 		inode_unlock((inode));
1028 		mnt_drop_write_file(filp);
1029 		return err;
1030 	}
1031 
1032 	case EXT4_IOC_ALLOC_DA_BLKS:
1033 	{
1034 		int err;
1035 		if (!inode_owner_or_capable(inode))
1036 			return -EACCES;
1037 
1038 		err = mnt_want_write_file(filp);
1039 		if (err)
1040 			return err;
1041 		err = ext4_alloc_da_blocks(inode);
1042 		mnt_drop_write_file(filp);
1043 		return err;
1044 	}
1045 
1046 	case EXT4_IOC_SWAP_BOOT:
1047 	{
1048 		int err;
1049 		if (!(filp->f_mode & FMODE_WRITE))
1050 			return -EBADF;
1051 		err = mnt_want_write_file(filp);
1052 		if (err)
1053 			return err;
1054 		err = swap_inode_boot_loader(sb, inode);
1055 		mnt_drop_write_file(filp);
1056 		return err;
1057 	}
1058 
1059 	case EXT4_IOC_RESIZE_FS: {
1060 		ext4_fsblk_t n_blocks_count;
1061 		int err = 0, err2 = 0;
1062 		ext4_group_t o_group = EXT4_SB(sb)->s_groups_count;
1063 
1064 		if (copy_from_user(&n_blocks_count, (__u64 __user *)arg,
1065 				   sizeof(__u64))) {
1066 			return -EFAULT;
1067 		}
1068 
1069 		err = ext4_resize_begin(sb);
1070 		if (err)
1071 			return err;
1072 
1073 		err = mnt_want_write_file(filp);
1074 		if (err)
1075 			goto resizefs_out;
1076 
1077 		err = ext4_resize_fs(sb, n_blocks_count);
1078 		if (EXT4_SB(sb)->s_journal) {
1079 			ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_RESIZE);
1080 			jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
1081 			err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
1082 			jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
1083 		}
1084 		if (err == 0)
1085 			err = err2;
1086 		mnt_drop_write_file(filp);
1087 		if (!err && (o_group < EXT4_SB(sb)->s_groups_count) &&
1088 		    ext4_has_group_desc_csum(sb) &&
1089 		    test_opt(sb, INIT_INODE_TABLE))
1090 			err = ext4_register_li_request(sb, o_group);
1091 
1092 resizefs_out:
1093 		ext4_resize_end(sb);
1094 		return err;
1095 	}
1096 
1097 	case FITRIM:
1098 	{
1099 		struct request_queue *q = bdev_get_queue(sb->s_bdev);
1100 		struct fstrim_range range;
1101 		int ret = 0;
1102 
1103 		if (!capable(CAP_SYS_ADMIN))
1104 			return -EPERM;
1105 
1106 		if (!blk_queue_discard(q))
1107 			return -EOPNOTSUPP;
1108 
1109 		/*
1110 		 * We haven't replayed the journal, so we cannot use our
1111 		 * block-bitmap-guided storage zapping commands.
1112 		 */
1113 		if (test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb))
1114 			return -EROFS;
1115 
1116 		if (copy_from_user(&range, (struct fstrim_range __user *)arg,
1117 		    sizeof(range)))
1118 			return -EFAULT;
1119 
1120 		range.minlen = max((unsigned int)range.minlen,
1121 				   q->limits.discard_granularity);
1122 		ret = ext4_trim_fs(sb, &range);
1123 		if (ret < 0)
1124 			return ret;
1125 
1126 		if (copy_to_user((struct fstrim_range __user *)arg, &range,
1127 		    sizeof(range)))
1128 			return -EFAULT;
1129 
1130 		return 0;
1131 	}
1132 	case EXT4_IOC_PRECACHE_EXTENTS:
1133 		return ext4_ext_precache(inode);
1134 
1135 	case FS_IOC_SET_ENCRYPTION_POLICY:
1136 		if (!ext4_has_feature_encrypt(sb))
1137 			return -EOPNOTSUPP;
1138 		return fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
1139 
1140 	case FS_IOC_GET_ENCRYPTION_PWSALT: {
1141 #ifdef CONFIG_FS_ENCRYPTION
1142 		int err, err2;
1143 		struct ext4_sb_info *sbi = EXT4_SB(sb);
1144 		handle_t *handle;
1145 
1146 		if (!ext4_has_feature_encrypt(sb))
1147 			return -EOPNOTSUPP;
1148 		if (uuid_is_zero(sbi->s_es->s_encrypt_pw_salt)) {
1149 			err = mnt_want_write_file(filp);
1150 			if (err)
1151 				return err;
1152 			handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
1153 			if (IS_ERR(handle)) {
1154 				err = PTR_ERR(handle);
1155 				goto pwsalt_err_exit;
1156 			}
1157 			err = ext4_journal_get_write_access(handle, sbi->s_sbh);
1158 			if (err)
1159 				goto pwsalt_err_journal;
1160 			lock_buffer(sbi->s_sbh);
1161 			generate_random_uuid(sbi->s_es->s_encrypt_pw_salt);
1162 			ext4_superblock_csum_set(sb);
1163 			unlock_buffer(sbi->s_sbh);
1164 			err = ext4_handle_dirty_metadata(handle, NULL,
1165 							 sbi->s_sbh);
1166 		pwsalt_err_journal:
1167 			err2 = ext4_journal_stop(handle);
1168 			if (err2 && !err)
1169 				err = err2;
1170 		pwsalt_err_exit:
1171 			mnt_drop_write_file(filp);
1172 			if (err)
1173 				return err;
1174 		}
1175 		if (copy_to_user((void __user *) arg,
1176 				 sbi->s_es->s_encrypt_pw_salt, 16))
1177 			return -EFAULT;
1178 		return 0;
1179 #else
1180 		return -EOPNOTSUPP;
1181 #endif
1182 	}
1183 	case FS_IOC_GET_ENCRYPTION_POLICY:
1184 		if (!ext4_has_feature_encrypt(sb))
1185 			return -EOPNOTSUPP;
1186 		return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
1187 
1188 	case FS_IOC_GET_ENCRYPTION_POLICY_EX:
1189 		if (!ext4_has_feature_encrypt(sb))
1190 			return -EOPNOTSUPP;
1191 		return fscrypt_ioctl_get_policy_ex(filp, (void __user *)arg);
1192 
1193 	case FS_IOC_ADD_ENCRYPTION_KEY:
1194 		if (!ext4_has_feature_encrypt(sb))
1195 			return -EOPNOTSUPP;
1196 		return fscrypt_ioctl_add_key(filp, (void __user *)arg);
1197 
1198 	case FS_IOC_REMOVE_ENCRYPTION_KEY:
1199 		if (!ext4_has_feature_encrypt(sb))
1200 			return -EOPNOTSUPP;
1201 		return fscrypt_ioctl_remove_key(filp, (void __user *)arg);
1202 
1203 	case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
1204 		if (!ext4_has_feature_encrypt(sb))
1205 			return -EOPNOTSUPP;
1206 		return fscrypt_ioctl_remove_key_all_users(filp,
1207 							  (void __user *)arg);
1208 	case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
1209 		if (!ext4_has_feature_encrypt(sb))
1210 			return -EOPNOTSUPP;
1211 		return fscrypt_ioctl_get_key_status(filp, (void __user *)arg);
1212 
1213 	case FS_IOC_GET_ENCRYPTION_NONCE:
1214 		if (!ext4_has_feature_encrypt(sb))
1215 			return -EOPNOTSUPP;
1216 		return fscrypt_ioctl_get_nonce(filp, (void __user *)arg);
1217 
1218 	case EXT4_IOC_CLEAR_ES_CACHE:
1219 	{
1220 		if (!inode_owner_or_capable(inode))
1221 			return -EACCES;
1222 		ext4_clear_inode_es(inode);
1223 		return 0;
1224 	}
1225 
1226 	case EXT4_IOC_GETSTATE:
1227 	{
1228 		__u32	state = 0;
1229 
1230 		if (ext4_test_inode_state(inode, EXT4_STATE_EXT_PRECACHED))
1231 			state |= EXT4_STATE_FLAG_EXT_PRECACHED;
1232 		if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
1233 			state |= EXT4_STATE_FLAG_NEW;
1234 		if (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY))
1235 			state |= EXT4_STATE_FLAG_NEWENTRY;
1236 		if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE))
1237 			state |= EXT4_STATE_FLAG_DA_ALLOC_CLOSE;
1238 
1239 		return put_user(state, (__u32 __user *) arg);
1240 	}
1241 
1242 	case EXT4_IOC_GET_ES_CACHE:
1243 		return ext4_ioctl_get_es_cache(filp, arg);
1244 
1245 	case FS_IOC_FSGETXATTR:
1246 	{
1247 		struct fsxattr fa;
1248 
1249 		ext4_fill_fsxattr(inode, &fa);
1250 
1251 		if (copy_to_user((struct fsxattr __user *)arg,
1252 				 &fa, sizeof(fa)))
1253 			return -EFAULT;
1254 		return 0;
1255 	}
1256 	case FS_IOC_FSSETXATTR:
1257 	{
1258 		struct fsxattr fa, old_fa;
1259 		int err;
1260 
1261 		if (copy_from_user(&fa, (struct fsxattr __user *)arg,
1262 				   sizeof(fa)))
1263 			return -EFAULT;
1264 
1265 		/* Make sure caller has proper permission */
1266 		if (!inode_owner_or_capable(inode))
1267 			return -EACCES;
1268 
1269 		if (fa.fsx_xflags & ~EXT4_SUPPORTED_FS_XFLAGS)
1270 			return -EOPNOTSUPP;
1271 
1272 		flags = ext4_xflags_to_iflags(fa.fsx_xflags);
1273 		if (ext4_mask_flags(inode->i_mode, flags) != flags)
1274 			return -EOPNOTSUPP;
1275 
1276 		err = mnt_want_write_file(filp);
1277 		if (err)
1278 			return err;
1279 
1280 		inode_lock(inode);
1281 		ext4_fill_fsxattr(inode, &old_fa);
1282 		err = vfs_ioc_fssetxattr_check(inode, &old_fa, &fa);
1283 		if (err)
1284 			goto out;
1285 		flags = (ei->i_flags & ~EXT4_FL_XFLAG_VISIBLE) |
1286 			 (flags & EXT4_FL_XFLAG_VISIBLE);
1287 		err = ext4_ioctl_check_immutable(inode, fa.fsx_projid, flags);
1288 		if (err)
1289 			goto out;
1290 		err = ext4_ioctl_setflags(inode, flags);
1291 		if (err)
1292 			goto out;
1293 		err = ext4_ioctl_setproject(filp, fa.fsx_projid);
1294 out:
1295 		inode_unlock(inode);
1296 		mnt_drop_write_file(filp);
1297 		return err;
1298 	}
1299 	case EXT4_IOC_SHUTDOWN:
1300 		return ext4_shutdown(sb, arg);
1301 
1302 	case FS_IOC_ENABLE_VERITY:
1303 		if (!ext4_has_feature_verity(sb))
1304 			return -EOPNOTSUPP;
1305 		return fsverity_ioctl_enable(filp, (const void __user *)arg);
1306 
1307 	case FS_IOC_MEASURE_VERITY:
1308 		if (!ext4_has_feature_verity(sb))
1309 			return -EOPNOTSUPP;
1310 		return fsverity_ioctl_measure(filp, (void __user *)arg);
1311 
1312 	default:
1313 		return -ENOTTY;
1314 	}
1315 }
1316 
1317 long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1318 {
1319 	long ret;
1320 
1321 	ext4_fc_start_update(file_inode(filp));
1322 	ret = __ext4_ioctl(filp, cmd, arg);
1323 	ext4_fc_stop_update(file_inode(filp));
1324 
1325 	return ret;
1326 }
1327 
1328 #ifdef CONFIG_COMPAT
1329 long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1330 {
1331 	/* These are just misnamed, they actually get/put from/to user an int */
1332 	switch (cmd) {
1333 	case FS_IOC32_GETFLAGS:
1334 		cmd = FS_IOC_GETFLAGS;
1335 		break;
1336 	case FS_IOC32_SETFLAGS:
1337 		cmd = FS_IOC_SETFLAGS;
1338 		break;
1339 	case EXT4_IOC32_GETVERSION:
1340 		cmd = EXT4_IOC_GETVERSION;
1341 		break;
1342 	case EXT4_IOC32_SETVERSION:
1343 		cmd = EXT4_IOC_SETVERSION;
1344 		break;
1345 	case EXT4_IOC32_GROUP_EXTEND:
1346 		cmd = EXT4_IOC_GROUP_EXTEND;
1347 		break;
1348 	case EXT4_IOC32_GETVERSION_OLD:
1349 		cmd = EXT4_IOC_GETVERSION_OLD;
1350 		break;
1351 	case EXT4_IOC32_SETVERSION_OLD:
1352 		cmd = EXT4_IOC_SETVERSION_OLD;
1353 		break;
1354 	case EXT4_IOC32_GETRSVSZ:
1355 		cmd = EXT4_IOC_GETRSVSZ;
1356 		break;
1357 	case EXT4_IOC32_SETRSVSZ:
1358 		cmd = EXT4_IOC_SETRSVSZ;
1359 		break;
1360 	case EXT4_IOC32_GROUP_ADD: {
1361 		struct compat_ext4_new_group_input __user *uinput;
1362 		struct ext4_new_group_data input;
1363 		int err;
1364 
1365 		uinput = compat_ptr(arg);
1366 		err = get_user(input.group, &uinput->group);
1367 		err |= get_user(input.block_bitmap, &uinput->block_bitmap);
1368 		err |= get_user(input.inode_bitmap, &uinput->inode_bitmap);
1369 		err |= get_user(input.inode_table, &uinput->inode_table);
1370 		err |= get_user(input.blocks_count, &uinput->blocks_count);
1371 		err |= get_user(input.reserved_blocks,
1372 				&uinput->reserved_blocks);
1373 		if (err)
1374 			return -EFAULT;
1375 		return ext4_ioctl_group_add(file, &input);
1376 	}
1377 	case EXT4_IOC_MOVE_EXT:
1378 	case EXT4_IOC_RESIZE_FS:
1379 	case FITRIM:
1380 	case EXT4_IOC_PRECACHE_EXTENTS:
1381 	case FS_IOC_SET_ENCRYPTION_POLICY:
1382 	case FS_IOC_GET_ENCRYPTION_PWSALT:
1383 	case FS_IOC_GET_ENCRYPTION_POLICY:
1384 	case FS_IOC_GET_ENCRYPTION_POLICY_EX:
1385 	case FS_IOC_ADD_ENCRYPTION_KEY:
1386 	case FS_IOC_REMOVE_ENCRYPTION_KEY:
1387 	case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
1388 	case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
1389 	case FS_IOC_GET_ENCRYPTION_NONCE:
1390 	case EXT4_IOC_SHUTDOWN:
1391 	case FS_IOC_GETFSMAP:
1392 	case FS_IOC_ENABLE_VERITY:
1393 	case FS_IOC_MEASURE_VERITY:
1394 	case EXT4_IOC_CLEAR_ES_CACHE:
1395 	case EXT4_IOC_GETSTATE:
1396 	case EXT4_IOC_GET_ES_CACHE:
1397 	case FS_IOC_FSGETXATTR:
1398 	case FS_IOC_FSSETXATTR:
1399 		break;
1400 	default:
1401 		return -ENOIOCTLCMD;
1402 	}
1403 	return ext4_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
1404 }
1405 #endif
1406