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