forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/fs/ext4/ioctl.c
....@@ -86,7 +86,7 @@
8686 	i_size_write(inode2, isize);
8787 }
8888 
89
-static void reset_inode_seed(struct inode *inode)
89
+void ext4_reset_inode_seed(struct inode *inode)
9090 {
9191 	struct ext4_inode_info *ei = EXT4_I(inode);
9292 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
....@@ -121,7 +121,8 @@
121121 	blkcnt_t blocks;
122122 	unsigned short bytes;
123123 
124
-	inode_bl = ext4_iget(sb, EXT4_BOOT_LOADER_INO, EXT4_IGET_SPECIAL);
124
+	inode_bl = ext4_iget(sb, EXT4_BOOT_LOADER_INO,
125
+			EXT4_IGET_SPECIAL | EXT4_IGET_BAD);
125126 	if (IS_ERR(inode_bl))
126127 		return PTR_ERR(inode_bl);
127128 	ei_bl = EXT4_I(inode_bl);
....@@ -165,11 +166,12 @@
165166 		err = -EINVAL;
166167 		goto err_out;
167168 	}
169
+	ext4_fc_start_ineligible(sb, EXT4_FC_REASON_SWAP_BOOT);
168170 
169171 	/* Protect extent tree against block allocations via delalloc */
170172 	ext4_double_down_write_data_sem(inode, inode_bl);
171173 
172
-	if (inode_bl->i_nlink == 0) {
174
+	if (is_bad_inode(inode_bl) || !S_ISREG(inode_bl->i_mode)) {
173175 		/* this inode has never been used as a BOOT_LOADER */
174176 		set_nlink(inode_bl, 1);
175177 		i_uid_write(inode_bl, 0);
....@@ -178,6 +180,7 @@
178180 		ei_bl->i_flags = 0;
179181 		inode_set_iversion(inode_bl, 1);
180182 		i_size_write(inode_bl, 0);
183
+		EXT4_I(inode_bl)->i_disksize = inode_bl->i_size;
181184 		inode_bl->i_mode = S_IFREG;
182185 		if (ext4_has_feature_extents(sb)) {
183186 			ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS);
....@@ -199,10 +202,10 @@
199202 
200203 	inode->i_generation = prandom_u32();
201204 	inode_bl->i_generation = prandom_u32();
202
-	reset_inode_seed(inode);
203
-	reset_inode_seed(inode_bl);
205
+	ext4_reset_inode_seed(inode);
206
+	ext4_reset_inode_seed(inode_bl);
204207 
205
-	ext4_discard_preallocations(inode);
208
+	ext4_discard_preallocations(inode, 0);
206209 
207210 	err = ext4_mark_inode_dirty(handle, inode);
208211 	if (err < 0) {
....@@ -247,6 +250,7 @@
247250 
248251 err_out1:
249252 	ext4_journal_stop(handle);
253
+	ext4_fc_stop_ineligible(sb);
250254 	ext4_double_up_write_data_sem(inode, inode_bl);
251255 
252256 err_out:
....@@ -292,6 +296,44 @@
292296 	return 0;
293297 }
294298 
299
+static void ext4_dax_dontcache(struct inode *inode, unsigned int flags)
300
+{
301
+	struct ext4_inode_info *ei = EXT4_I(inode);
302
+
303
+	if (S_ISDIR(inode->i_mode))
304
+		return;
305
+
306
+	if (test_opt2(inode->i_sb, DAX_NEVER) ||
307
+	    test_opt(inode->i_sb, DAX_ALWAYS))
308
+		return;
309
+
310
+	if ((ei->i_flags ^ flags) & EXT4_DAX_FL)
311
+		d_mark_dontcache(inode);
312
+}
313
+
314
+static bool dax_compatible(struct inode *inode, unsigned int oldflags,
315
+			   unsigned int flags)
316
+{
317
+	/* Allow the DAX flag to be changed on inline directories */
318
+	if (S_ISDIR(inode->i_mode)) {
319
+		flags &= ~EXT4_INLINE_DATA_FL;
320
+		oldflags &= ~EXT4_INLINE_DATA_FL;
321
+	}
322
+
323
+	if (flags & EXT4_DAX_FL) {
324
+		if ((oldflags & EXT4_DAX_MUT_EXCL) ||
325
+		     ext4_test_inode_state(inode,
326
+					  EXT4_STATE_VERITY_IN_PROGRESS)) {
327
+			return false;
328
+		}
329
+	}
330
+
331
+	if ((flags & EXT4_DAX_MUT_EXCL) && (oldflags & EXT4_DAX_FL))
332
+			return false;
333
+
334
+	return true;
335
+}
336
+
295337 static int ext4_ioctl_setflags(struct inode *inode,
296338 			       unsigned int flags)
297339 {
....@@ -300,7 +342,6 @@
300342 	int err = -EPERM, migrate = 0;
301343 	struct ext4_iloc iloc;
302344 	unsigned int oldflags, mask, i;
303
-	unsigned int jflag;
304345 	struct super_block *sb = inode->i_sb;
305346 
306347 	/* Is it quota file? Do not allow user to mess with it */
....@@ -309,42 +350,26 @@
309350 
310351 	oldflags = ei->i_flags;
311352 
312
-	/* The JOURNAL_DATA flag is modifiable only by root */
313
-	jflag = flags & EXT4_JOURNAL_DATA_FL;
314
-
315
-	/*
316
-	 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
317
-	 * the relevant capability.
318
-	 *
319
-	 * This test looks nicer. Thanks to Pauline Middelink
320
-	 */
321
-	if ((flags ^ oldflags) & (EXT4_APPEND_FL | EXT4_IMMUTABLE_FL)) {
322
-		if (!capable(CAP_LINUX_IMMUTABLE))
323
-			goto flags_out;
324
-	}
353
+	err = vfs_ioc_setflags_prepare(inode, oldflags, flags);
354
+	if (err)
355
+		goto flags_out;
325356 
326357 	/*
327358 	 * The JOURNAL_DATA flag can only be changed by
328359 	 * the relevant capability.
329360 	 */
330
-	if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
361
+	if ((flags ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
331362 		if (!capable(CAP_SYS_RESOURCE))
332363 			goto flags_out;
333364 	}
365
+
366
+	if (!dax_compatible(inode, oldflags, flags)) {
367
+		err = -EOPNOTSUPP;
368
+		goto flags_out;
369
+	}
370
+
334371 	if ((flags ^ oldflags) & EXT4_EXTENTS_FL)
335372 		migrate = 1;
336
-
337
-	if (flags & EXT4_EOFBLOCKS_FL) {
338
-		/* we don't support adding EOFBLOCKS flag */
339
-		if (!(oldflags & EXT4_EOFBLOCKS_FL)) {
340
-			err = -EOPNOTSUPP;
341
-			goto flags_out;
342
-		}
343
-	} else if (oldflags & EXT4_EOFBLOCKS_FL) {
344
-		err = ext4_truncate(inode);
345
-		if (err)
346
-			goto flags_out;
347
-	}
348373 
349374 	if ((flags ^ oldflags) & EXT4_CASEFOLD_FL) {
350375 		if (!ext4_has_feature_casefold(sb)) {
....@@ -388,6 +413,8 @@
388413 	if (err)
389414 		goto flags_err;
390415 
416
+	ext4_dax_dontcache(inode, flags);
417
+
391418 	for (i = 0, mask = 1; i < 32; i++, mask <<= 1) {
392419 		if (!(mask & EXT4_FL_USER_MODIFIABLE))
393420 			continue;
....@@ -400,7 +427,8 @@
400427 			ext4_clear_inode_flag(inode, i);
401428 	}
402429 
403
-	ext4_set_inode_flags(inode);
430
+	ext4_set_inode_flags(inode, false);
431
+
404432 	inode->i_ctime = current_time(inode);
405433 
406434 	err = ext4_mark_iloc_dirty(handle, inode, &iloc);
....@@ -409,17 +437,18 @@
409437 	if (err)
410438 		goto flags_out;
411439 
412
-	if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
440
+	if ((flags ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
413441 		/*
414442 		 * Changes to the journaling mode can cause unsafe changes to
415
-		 * S_DAX if we are using the DAX mount option.
443
+		 * S_DAX if the inode is DAX
416444 		 */
417
-		if (test_opt(inode->i_sb, DAX)) {
445
+		if (IS_DAX(inode)) {
418446 			err = -EBUSY;
419447 			goto flags_out;
420448 		}
421449 
422
-		err = ext4_change_inode_journal_flag(inode, jflag);
450
+		err = ext4_change_inode_journal_flag(inode,
451
+						     flags & EXT4_JOURNAL_DATA_FL);
423452 		if (err)
424453 			goto flags_out;
425454 	}
....@@ -467,6 +496,10 @@
467496 	if (ext4_is_quota_file(inode))
468497 		return err;
469498 
499
+	err = dquot_initialize(inode);
500
+	if (err)
501
+		return err;
502
+
470503 	err = ext4_get_inode_loc(inode, &iloc);
471504 	if (err)
472505 		return err;
....@@ -481,10 +514,6 @@
481514 	} else {
482515 		brelse(iloc.bh);
483516 	}
484
-
485
-	err = dquot_initialize(inode);
486
-	if (err)
487
-		return err;
488517 
489518 	handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
490519 		EXT4_QUOTA_INIT_BLOCKS(sb) +
....@@ -546,12 +575,15 @@
546575 		xflags |= FS_XFLAG_NOATIME;
547576 	if (iflags & EXT4_PROJINHERIT_FL)
548577 		xflags |= FS_XFLAG_PROJINHERIT;
578
+	if (iflags & EXT4_DAX_FL)
579
+		xflags |= FS_XFLAG_DAX;
549580 	return xflags;
550581 }
551582 
552583 #define EXT4_SUPPORTED_FS_XFLAGS (FS_XFLAG_SYNC | FS_XFLAG_IMMUTABLE | \
553584 				  FS_XFLAG_APPEND | FS_XFLAG_NODUMP | \
554
-				  FS_XFLAG_NOATIME | FS_XFLAG_PROJINHERIT)
585
+				  FS_XFLAG_NOATIME | FS_XFLAG_PROJINHERIT | \
586
+				  FS_XFLAG_DAX)
555587 
556588 /* Transfer xflags flags to internal */
557589 static inline unsigned long ext4_xflags_to_iflags(__u32 xflags)
....@@ -570,6 +602,8 @@
570602 		iflags |= EXT4_NOATIME_FL;
571603 	if (xflags & FS_XFLAG_PROJINHERIT)
572604 		iflags |= EXT4_PROJINHERIT_FL;
605
+	if (xflags & FS_XFLAG_DAX)
606
+		iflags |= EXT4_DAX_FL;
573607 
574608 	return iflags;
575609 }
....@@ -578,6 +612,7 @@
578612 {
579613 	struct ext4_sb_info *sbi = EXT4_SB(sb);
580614 	__u32 flags;
615
+	int ret;
581616 
582617 	if (!capable(CAP_SYS_ADMIN))
583618 		return -EPERM;
....@@ -596,9 +631,11 @@
596631 
597632 	switch (flags) {
598633 	case EXT4_GOING_FLAGS_DEFAULT:
599
-		freeze_bdev(sb->s_bdev);
634
+		ret = freeze_bdev(sb->s_bdev);
635
+		if (ret)
636
+			return ret;
600637 		set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
601
-		thaw_bdev(sb->s_bdev, sb);
638
+		thaw_bdev(sb->s_bdev);
602639 		break;
603640 	case EXT4_GOING_FLAGS_LOGFLUSH:
604641 		set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
....@@ -645,7 +682,7 @@
645682 static int ext4_ioc_getfsmap(struct super_block *sb,
646683 			     struct fsmap_head __user *arg)
647684 {
648
-	struct getfsmap_info info = {0};
685
+	struct getfsmap_info info = { NULL };
649686 	struct ext4_fsmap_head xhead = {0};
650687 	struct fsmap_head head;
651688 	bool aborted = false;
....@@ -741,31 +778,49 @@
741778 	return err;
742779 }
743780 
744
-static int ext4_ioctl_check_project(struct inode *inode, struct fsxattr *fa)
781
+static void ext4_fill_fsxattr(struct inode *inode, struct fsxattr *fa)
745782 {
746
-	/*
747
-	 * Project Quota ID state is only allowed to change from within the init
748
-	 * namespace. Enforce that restriction only if we are trying to change
749
-	 * the quota ID state. Everything else is allowed in user namespaces.
750
-	 */
751
-	if (current_user_ns() == &init_user_ns)
752
-		return 0;
783
+	struct ext4_inode_info *ei = EXT4_I(inode);
753784 
754
-	if (__kprojid_val(EXT4_I(inode)->i_projid) != fa->fsx_projid)
755
-		return -EINVAL;
785
+	simple_fill_fsxattr(fa, ext4_iflags_to_xflags(ei->i_flags &
786
+						      EXT4_FL_USER_VISIBLE));
756787 
757
-	if (ext4_test_inode_flag(inode, EXT4_INODE_PROJINHERIT)) {
758
-		if (!(fa->fsx_xflags & FS_XFLAG_PROJINHERIT))
759
-			return -EINVAL;
760
-	} else {
761
-		if (fa->fsx_xflags & FS_XFLAG_PROJINHERIT)
762
-			return -EINVAL;
763
-	}
764
-
765
-	return 0;
788
+	if (ext4_has_feature_project(inode->i_sb))
789
+		fa->fsx_projid = from_kprojid(&init_user_ns, ei->i_projid);
766790 }
767791 
768
-long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
792
+/* So that the fiemap access checks can't overflow on 32 bit machines. */
793
+#define FIEMAP_MAX_EXTENTS	(UINT_MAX / sizeof(struct fiemap_extent))
794
+
795
+static int ext4_ioctl_get_es_cache(struct file *filp, unsigned long arg)
796
+{
797
+	struct fiemap fiemap;
798
+	struct fiemap __user *ufiemap = (struct fiemap __user *) arg;
799
+	struct fiemap_extent_info fieinfo = { 0, };
800
+	struct inode *inode = file_inode(filp);
801
+	int error;
802
+
803
+	if (copy_from_user(&fiemap, ufiemap, sizeof(fiemap)))
804
+		return -EFAULT;
805
+
806
+	if (fiemap.fm_extent_count > FIEMAP_MAX_EXTENTS)
807
+		return -EINVAL;
808
+
809
+	fieinfo.fi_flags = fiemap.fm_flags;
810
+	fieinfo.fi_extents_max = fiemap.fm_extent_count;
811
+	fieinfo.fi_extents_start = ufiemap->fm_extents;
812
+
813
+	error = ext4_get_es_cache(inode, &fieinfo, fiemap.fm_start,
814
+			fiemap.fm_length);
815
+	fiemap.fm_flags = fieinfo.fi_flags;
816
+	fiemap.fm_mapped_extents = fieinfo.fi_extents_mapped;
817
+	if (copy_to_user(ufiemap, &fiemap, sizeof(fiemap)))
818
+		error = -EFAULT;
819
+
820
+	return error;
821
+}
822
+
823
+static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
769824 {
770825 	struct inode *inode = file_inode(filp);
771826 	struct super_block *sb = inode->i_sb;
....@@ -777,10 +832,12 @@
777832 	switch (cmd) {
778833 	case FS_IOC_GETFSMAP:
779834 		return ext4_ioc_getfsmap(sb, (void __user *)arg);
780
-	case EXT4_IOC_GETFLAGS:
835
+	case FS_IOC_GETFLAGS:
781836 		flags = ei->i_flags & EXT4_FL_USER_VISIBLE;
837
+		if (S_ISREG(inode->i_mode))
838
+			flags &= ~EXT4_PROJINHERIT_FL;
782839 		return put_user(flags, (int __user *) arg);
783
-	case EXT4_IOC_SETFLAGS: {
840
+	case FS_IOC_SETFLAGS: {
784841 		int err;
785842 
786843 		if (!inode_owner_or_capable(inode))
....@@ -1030,6 +1087,7 @@
10301087 
10311088 		err = ext4_resize_fs(sb, n_blocks_count);
10321089 		if (EXT4_SB(sb)->s_journal) {
1090
+			ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_RESIZE);
10331091 			jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
10341092 			err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
10351093 			jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
....@@ -1083,12 +1141,12 @@
10831141 	case EXT4_IOC_PRECACHE_EXTENTS:
10841142 		return ext4_ext_precache(inode);
10851143 
1086
-	case EXT4_IOC_SET_ENCRYPTION_POLICY:
1144
+	case FS_IOC_SET_ENCRYPTION_POLICY:
10871145 		if (!ext4_has_feature_encrypt(sb))
10881146 			return -EOPNOTSUPP;
10891147 		return fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
10901148 
1091
-	case EXT4_IOC_GET_ENCRYPTION_PWSALT: {
1149
+	case FS_IOC_GET_ENCRYPTION_PWSALT: {
10921150 #ifdef CONFIG_FS_ENCRYPTION
10931151 		int err, err2;
10941152 		struct ext4_sb_info *sbi = EXT4_SB(sb);
....@@ -1131,7 +1189,7 @@
11311189 		return -EOPNOTSUPP;
11321190 #endif
11331191 	}
1134
-	case EXT4_IOC_GET_ENCRYPTION_POLICY:
1192
+	case FS_IOC_GET_ENCRYPTION_POLICY:
11351193 		if (!ext4_has_feature_encrypt(sb))
11361194 			return -EOPNOTSUPP;
11371195 		return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
....@@ -1166,26 +1224,47 @@
11661224 			return -EOPNOTSUPP;
11671225 		return fscrypt_ioctl_get_nonce(filp, (void __user *)arg);
11681226 
1169
-	case EXT4_IOC_FSGETXATTR:
1227
+	case EXT4_IOC_CLEAR_ES_CACHE:
1228
+	{
1229
+		if (!inode_owner_or_capable(inode))
1230
+			return -EACCES;
1231
+		ext4_clear_inode_es(inode);
1232
+		return 0;
1233
+	}
1234
+
1235
+	case EXT4_IOC_GETSTATE:
1236
+	{
1237
+		__u32	state = 0;
1238
+
1239
+		if (ext4_test_inode_state(inode, EXT4_STATE_EXT_PRECACHED))
1240
+			state |= EXT4_STATE_FLAG_EXT_PRECACHED;
1241
+		if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
1242
+			state |= EXT4_STATE_FLAG_NEW;
1243
+		if (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY))
1244
+			state |= EXT4_STATE_FLAG_NEWENTRY;
1245
+		if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE))
1246
+			state |= EXT4_STATE_FLAG_DA_ALLOC_CLOSE;
1247
+
1248
+		return put_user(state, (__u32 __user *) arg);
1249
+	}
1250
+
1251
+	case EXT4_IOC_GET_ES_CACHE:
1252
+		return ext4_ioctl_get_es_cache(filp, arg);
1253
+
1254
+	case FS_IOC_FSGETXATTR:
11701255 	{
11711256 		struct fsxattr fa;
11721257 
1173
-		memset(&fa, 0, sizeof(struct fsxattr));
1174
-		fa.fsx_xflags = ext4_iflags_to_xflags(ei->i_flags & EXT4_FL_USER_VISIBLE);
1175
-
1176
-		if (ext4_has_feature_project(inode->i_sb)) {
1177
-			fa.fsx_projid = (__u32)from_kprojid(&init_user_ns,
1178
-				EXT4_I(inode)->i_projid);
1179
-		}
1258
+		ext4_fill_fsxattr(inode, &fa);
11801259 
11811260 		if (copy_to_user((struct fsxattr __user *)arg,
11821261 				 &fa, sizeof(fa)))
11831262 			return -EFAULT;
11841263 		return 0;
11851264 	}
1186
-	case EXT4_IOC_FSSETXATTR:
1265
+	case FS_IOC_FSSETXATTR:
11871266 	{
1188
-		struct fsxattr fa;
1267
+		struct fsxattr fa, old_fa;
11891268 		int err;
11901269 
11911270 		if (copy_from_user(&fa, (struct fsxattr __user *)arg,
....@@ -1208,7 +1287,8 @@
12081287 			return err;
12091288 
12101289 		inode_lock(inode);
1211
-		err = ext4_ioctl_check_project(inode, &fa);
1290
+		ext4_fill_fsxattr(inode, &old_fa);
1291
+		err = vfs_ioc_fssetxattr_check(inode, &old_fa, &fa);
12121292 		if (err)
12131293 			goto out;
12141294 		flags = (ei->i_flags & ~EXT4_FL_XFLAG_VISIBLE) |
....@@ -1238,9 +1318,20 @@
12381318 			return -EOPNOTSUPP;
12391319 		return fsverity_ioctl_measure(filp, (void __user *)arg);
12401320 
1321
+	case FS_IOC_READ_VERITY_METADATA:
1322
+		if (!ext4_has_feature_verity(sb))
1323
+			return -EOPNOTSUPP;
1324
+		return fsverity_ioctl_read_metadata(filp,
1325
+						    (const void __user *)arg);
1326
+
12411327 	default:
12421328 		return -ENOTTY;
12431329 	}
1330
+}
1331
+
1332
+long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1333
+{
1334
+	return __ext4_ioctl(filp, cmd, arg);
12441335 }
12451336 
12461337 #ifdef CONFIG_COMPAT
....@@ -1248,11 +1339,11 @@
12481339 {
12491340 	/* These are just misnamed, they actually get/put from/to user an int */
12501341 	switch (cmd) {
1251
-	case EXT4_IOC32_GETFLAGS:
1252
-		cmd = EXT4_IOC_GETFLAGS;
1342
+	case FS_IOC32_GETFLAGS:
1343
+		cmd = FS_IOC_GETFLAGS;
12531344 		break;
1254
-	case EXT4_IOC32_SETFLAGS:
1255
-		cmd = EXT4_IOC_SETFLAGS;
1345
+	case FS_IOC32_SETFLAGS:
1346
+		cmd = FS_IOC_SETFLAGS;
12561347 		break;
12571348 	case EXT4_IOC32_GETVERSION:
12581349 		cmd = EXT4_IOC_GETVERSION;
....@@ -1294,10 +1385,11 @@
12941385 	}
12951386 	case EXT4_IOC_MOVE_EXT:
12961387 	case EXT4_IOC_RESIZE_FS:
1388
+	case FITRIM:
12971389 	case EXT4_IOC_PRECACHE_EXTENTS:
1298
-	case EXT4_IOC_SET_ENCRYPTION_POLICY:
1299
-	case EXT4_IOC_GET_ENCRYPTION_PWSALT:
1300
-	case EXT4_IOC_GET_ENCRYPTION_POLICY:
1390
+	case FS_IOC_SET_ENCRYPTION_POLICY:
1391
+	case FS_IOC_GET_ENCRYPTION_PWSALT:
1392
+	case FS_IOC_GET_ENCRYPTION_POLICY:
13011393 	case FS_IOC_GET_ENCRYPTION_POLICY_EX:
13021394 	case FS_IOC_ADD_ENCRYPTION_KEY:
13031395 	case FS_IOC_REMOVE_ENCRYPTION_KEY:
....@@ -1308,8 +1400,12 @@
13081400 	case FS_IOC_GETFSMAP:
13091401 	case FS_IOC_ENABLE_VERITY:
13101402 	case FS_IOC_MEASURE_VERITY:
1311
-	case EXT4_IOC_FSGETXATTR:
1312
-	case EXT4_IOC_FSSETXATTR:
1403
+	case FS_IOC_READ_VERITY_METADATA:
1404
+	case EXT4_IOC_CLEAR_ES_CACHE:
1405
+	case EXT4_IOC_GETSTATE:
1406
+	case EXT4_IOC_GET_ES_CACHE:
1407
+	case FS_IOC_FSGETXATTR:
1408
+	case FS_IOC_FSSETXATTR:
13131409 		break;
13141410 	default:
13151411 		return -ENOIOCTLCMD;