fs/ext4/ioctl.c

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