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