1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 2ac27a0ecSDave Kleikamp /* 3617ba13bSMingming Cao * linux/fs/ext4/ioctl.c 4ac27a0ecSDave Kleikamp * 5ac27a0ecSDave Kleikamp * Copyright (C) 1993, 1994, 1995 6ac27a0ecSDave Kleikamp * Remy Card (card@masi.ibp.fr) 7ac27a0ecSDave Kleikamp * Laboratoire MASI - Institut Blaise Pascal 8ac27a0ecSDave Kleikamp * Universite Pierre et Marie Curie (Paris VI) 9ac27a0ecSDave Kleikamp */ 10ac27a0ecSDave Kleikamp 11ac27a0ecSDave Kleikamp #include <linux/fs.h> 12ac27a0ecSDave Kleikamp #include <linux/capability.h> 13ac27a0ecSDave Kleikamp #include <linux/time.h> 14ac27a0ecSDave Kleikamp #include <linux/compat.h> 1542a74f20SDave Hansen #include <linux/mount.h> 16748de673SAkira Fujita #include <linux/file.h> 179b7365fcSLi Xi #include <linux/quotaops.h> 1823253068STheodore Ts'o #include <linux/random.h> 197c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 20783d9485STheodore Ts'o #include <linux/delay.h> 21ee73f9a5SJeff Layton #include <linux/iversion.h> 224db5c2e6SMiklos Szeredi #include <linux/fileattr.h> 23d95efb14SJeremy Bongio #include <linux/uuid.h> 243dcf5451SChristoph Hellwig #include "ext4_jbd2.h" 253dcf5451SChristoph Hellwig #include "ext4.h" 260c9ec4beSDarrick J. Wong #include <linux/fsmap.h> 270c9ec4beSDarrick J. Wong #include "fsmap.h" 280c9ec4beSDarrick J. Wong #include <trace/events/ext4.h> 29ac27a0ecSDave Kleikamp 30bbc605cdSLukas Czerner typedef void ext4_update_sb_callback(struct ext4_super_block *es, 31bbc605cdSLukas Czerner const void *arg); 32bbc605cdSLukas Czerner 33bbc605cdSLukas Czerner /* 34bbc605cdSLukas Czerner * Superblock modification callback function for changing file system 35bbc605cdSLukas Czerner * label 36bbc605cdSLukas Czerner */ 37bbc605cdSLukas Czerner static void ext4_sb_setlabel(struct ext4_super_block *es, const void *arg) 38bbc605cdSLukas Czerner { 39bbc605cdSLukas Czerner /* Sanity check, this should never happen */ 40bbc605cdSLukas Czerner BUILD_BUG_ON(sizeof(es->s_volume_name) < EXT4_LABEL_MAX); 41bbc605cdSLukas Czerner 42bbc605cdSLukas Czerner memcpy(es->s_volume_name, (char *)arg, EXT4_LABEL_MAX); 43bbc605cdSLukas Czerner } 44bbc605cdSLukas Czerner 45d95efb14SJeremy Bongio /* 46d95efb14SJeremy Bongio * Superblock modification callback function for changing file system 47d95efb14SJeremy Bongio * UUID. 48d95efb14SJeremy Bongio */ 49d95efb14SJeremy Bongio static void ext4_sb_setuuid(struct ext4_super_block *es, const void *arg) 50d95efb14SJeremy Bongio { 51d95efb14SJeremy Bongio memcpy(es->s_uuid, (__u8 *)arg, UUID_SIZE); 52d95efb14SJeremy Bongio } 53d95efb14SJeremy Bongio 54bbc605cdSLukas Czerner static 55bbc605cdSLukas Czerner int ext4_update_primary_sb(struct super_block *sb, handle_t *handle, 56bbc605cdSLukas Czerner ext4_update_sb_callback func, 57bbc605cdSLukas Czerner const void *arg) 58bbc605cdSLukas Czerner { 59bbc605cdSLukas Czerner int err = 0; 60bbc605cdSLukas Czerner struct ext4_sb_info *sbi = EXT4_SB(sb); 61bbc605cdSLukas Czerner struct buffer_head *bh = sbi->s_sbh; 62bbc605cdSLukas Czerner struct ext4_super_block *es = sbi->s_es; 63bbc605cdSLukas Czerner 64bbc605cdSLukas Czerner trace_ext4_update_sb(sb, bh->b_blocknr, 1); 65bbc605cdSLukas Czerner 66bbc605cdSLukas Czerner BUFFER_TRACE(bh, "get_write_access"); 67bbc605cdSLukas Czerner err = ext4_journal_get_write_access(handle, sb, 68bbc605cdSLukas Czerner bh, 69bbc605cdSLukas Czerner EXT4_JTR_NONE); 70bbc605cdSLukas Czerner if (err) 71bbc605cdSLukas Czerner goto out_err; 72bbc605cdSLukas Czerner 73bbc605cdSLukas Czerner lock_buffer(bh); 74bbc605cdSLukas Czerner func(es, arg); 75bbc605cdSLukas Czerner ext4_superblock_csum_set(sb); 76bbc605cdSLukas Czerner unlock_buffer(bh); 77bbc605cdSLukas Czerner 78bbc605cdSLukas Czerner if (buffer_write_io_error(bh) || !buffer_uptodate(bh)) { 79bbc605cdSLukas Czerner ext4_msg(sbi->s_sb, KERN_ERR, "previous I/O error to " 80bbc605cdSLukas Czerner "superblock detected"); 81bbc605cdSLukas Czerner clear_buffer_write_io_error(bh); 82bbc605cdSLukas Czerner set_buffer_uptodate(bh); 83bbc605cdSLukas Czerner } 84bbc605cdSLukas Czerner 85bbc605cdSLukas Czerner err = ext4_handle_dirty_metadata(handle, NULL, bh); 86bbc605cdSLukas Czerner if (err) 87bbc605cdSLukas Czerner goto out_err; 88bbc605cdSLukas Czerner err = sync_dirty_buffer(bh); 89bbc605cdSLukas Czerner out_err: 90bbc605cdSLukas Czerner ext4_std_error(sb, err); 91bbc605cdSLukas Czerner return err; 92bbc605cdSLukas Czerner } 93bbc605cdSLukas Czerner 94bbc605cdSLukas Czerner /* 95bbc605cdSLukas Czerner * Update one backup superblock in the group 'grp' using the callback 96bbc605cdSLukas Czerner * function 'func' and argument 'arg'. If the handle is NULL the 97bbc605cdSLukas Czerner * modification is not journalled. 98bbc605cdSLukas Czerner * 99bbc605cdSLukas Czerner * Returns: 0 when no modification was done (no superblock in the group) 100bbc605cdSLukas Czerner * 1 when the modification was successful 101bbc605cdSLukas Czerner * <0 on error 102bbc605cdSLukas Czerner */ 103bbc605cdSLukas Czerner static int ext4_update_backup_sb(struct super_block *sb, 104bbc605cdSLukas Czerner handle_t *handle, ext4_group_t grp, 105bbc605cdSLukas Czerner ext4_update_sb_callback func, const void *arg) 106bbc605cdSLukas Czerner { 107bbc605cdSLukas Czerner int err = 0; 108bbc605cdSLukas Czerner ext4_fsblk_t sb_block; 109bbc605cdSLukas Czerner struct buffer_head *bh; 110bbc605cdSLukas Czerner unsigned long offset = 0; 111bbc605cdSLukas Czerner struct ext4_super_block *es; 112bbc605cdSLukas Czerner 113bbc605cdSLukas Czerner if (!ext4_bg_has_super(sb, grp)) 114bbc605cdSLukas Czerner return 0; 115bbc605cdSLukas Czerner 116bbc605cdSLukas Czerner /* 117bbc605cdSLukas Czerner * For the group 0 there is always 1k padding, so we have 118bbc605cdSLukas Czerner * either adjust offset, or sb_block depending on blocksize 119bbc605cdSLukas Czerner */ 120bbc605cdSLukas Czerner if (grp == 0) { 121bbc605cdSLukas Czerner sb_block = 1 * EXT4_MIN_BLOCK_SIZE; 122bbc605cdSLukas Czerner offset = do_div(sb_block, sb->s_blocksize); 123bbc605cdSLukas Czerner } else { 124bbc605cdSLukas Czerner sb_block = ext4_group_first_block_no(sb, grp); 125bbc605cdSLukas Czerner offset = 0; 126bbc605cdSLukas Czerner } 127bbc605cdSLukas Czerner 128bbc605cdSLukas Czerner trace_ext4_update_sb(sb, sb_block, handle ? 1 : 0); 129bbc605cdSLukas Czerner 130bbc605cdSLukas Czerner bh = ext4_sb_bread(sb, sb_block, 0); 131bbc605cdSLukas Czerner if (IS_ERR(bh)) 132bbc605cdSLukas Czerner return PTR_ERR(bh); 133bbc605cdSLukas Czerner 134bbc605cdSLukas Czerner if (handle) { 135bbc605cdSLukas Czerner BUFFER_TRACE(bh, "get_write_access"); 136bbc605cdSLukas Czerner err = ext4_journal_get_write_access(handle, sb, 137bbc605cdSLukas Czerner bh, 138bbc605cdSLukas Czerner EXT4_JTR_NONE); 139bbc605cdSLukas Czerner if (err) 140bbc605cdSLukas Czerner goto out_bh; 141bbc605cdSLukas Czerner } 142bbc605cdSLukas Czerner 143bbc605cdSLukas Czerner es = (struct ext4_super_block *) (bh->b_data + offset); 144bbc605cdSLukas Czerner lock_buffer(bh); 145bbc605cdSLukas Czerner if (ext4_has_metadata_csum(sb) && 146bbc605cdSLukas Czerner es->s_checksum != ext4_superblock_csum(sb, es)) { 147bbc605cdSLukas Czerner ext4_msg(sb, KERN_ERR, "Invalid checksum for backup " 1489a8c5b0dSTheodore Ts'o "superblock %llu", sb_block); 149bbc605cdSLukas Czerner unlock_buffer(bh); 150bbc605cdSLukas Czerner goto out_bh; 151bbc605cdSLukas Czerner } 152bbc605cdSLukas Czerner func(es, arg); 153bbc605cdSLukas Czerner if (ext4_has_metadata_csum(sb)) 154bbc605cdSLukas Czerner es->s_checksum = ext4_superblock_csum(sb, es); 155bbc605cdSLukas Czerner set_buffer_uptodate(bh); 156bbc605cdSLukas Czerner unlock_buffer(bh); 157bbc605cdSLukas Czerner 158bbc605cdSLukas Czerner if (handle) { 159bbc605cdSLukas Czerner err = ext4_handle_dirty_metadata(handle, NULL, bh); 160bbc605cdSLukas Czerner if (err) 161bbc605cdSLukas Czerner goto out_bh; 162bbc605cdSLukas Czerner } else { 163bbc605cdSLukas Czerner BUFFER_TRACE(bh, "marking dirty"); 164bbc605cdSLukas Czerner mark_buffer_dirty(bh); 165bbc605cdSLukas Czerner } 166bbc605cdSLukas Czerner err = sync_dirty_buffer(bh); 167bbc605cdSLukas Czerner 168bbc605cdSLukas Czerner out_bh: 169bbc605cdSLukas Czerner brelse(bh); 170bbc605cdSLukas Czerner ext4_std_error(sb, err); 171bbc605cdSLukas Czerner return (err) ? err : 1; 172bbc605cdSLukas Czerner } 173bbc605cdSLukas Czerner 174bbc605cdSLukas Czerner /* 175bbc605cdSLukas Czerner * Update primary and backup superblocks using the provided function 176bbc605cdSLukas Czerner * func and argument arg. 177bbc605cdSLukas Czerner * 178bbc605cdSLukas Czerner * Only the primary superblock and at most two backup superblock 179bbc605cdSLukas Czerner * modifications are journalled; the rest is modified without journal. 180bbc605cdSLukas Czerner * This is safe because e2fsck will re-write them if there is a problem, 181bbc605cdSLukas Czerner * and we're very unlikely to ever need more than two backups. 182bbc605cdSLukas Czerner */ 183bbc605cdSLukas Czerner static 184bbc605cdSLukas Czerner int ext4_update_superblocks_fn(struct super_block *sb, 185bbc605cdSLukas Czerner ext4_update_sb_callback func, 186bbc605cdSLukas Czerner const void *arg) 187bbc605cdSLukas Czerner { 188bbc605cdSLukas Czerner handle_t *handle; 189bbc605cdSLukas Czerner ext4_group_t ngroups; 190bbc605cdSLukas Czerner unsigned int three = 1; 191bbc605cdSLukas Czerner unsigned int five = 5; 192bbc605cdSLukas Czerner unsigned int seven = 7; 193bbc605cdSLukas Czerner int err = 0, ret, i; 194bbc605cdSLukas Czerner ext4_group_t grp, primary_grp; 195bbc605cdSLukas Czerner struct ext4_sb_info *sbi = EXT4_SB(sb); 196bbc605cdSLukas Czerner 197bbc605cdSLukas Czerner /* 198bbc605cdSLukas Czerner * We can't update superblocks while the online resize is running 199bbc605cdSLukas Czerner */ 200bbc605cdSLukas Czerner if (test_and_set_bit_lock(EXT4_FLAGS_RESIZING, 201bbc605cdSLukas Czerner &sbi->s_ext4_flags)) { 202bbc605cdSLukas Czerner ext4_msg(sb, KERN_ERR, "Can't modify superblock while" 203bbc605cdSLukas Czerner "performing online resize"); 204bbc605cdSLukas Czerner return -EBUSY; 205bbc605cdSLukas Czerner } 206bbc605cdSLukas Czerner 207bbc605cdSLukas Czerner /* 208bbc605cdSLukas Czerner * We're only going to update primary superblock and two 209bbc605cdSLukas Czerner * backup superblocks in this transaction. 210bbc605cdSLukas Czerner */ 211bbc605cdSLukas Czerner handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 3); 212bbc605cdSLukas Czerner if (IS_ERR(handle)) { 213bbc605cdSLukas Czerner err = PTR_ERR(handle); 214bbc605cdSLukas Czerner goto out; 215bbc605cdSLukas Czerner } 216bbc605cdSLukas Czerner 217bbc605cdSLukas Czerner /* Update primary superblock */ 218bbc605cdSLukas Czerner err = ext4_update_primary_sb(sb, handle, func, arg); 219bbc605cdSLukas Czerner if (err) { 220bbc605cdSLukas Czerner ext4_msg(sb, KERN_ERR, "Failed to update primary " 221bbc605cdSLukas Czerner "superblock"); 222bbc605cdSLukas Czerner goto out_journal; 223bbc605cdSLukas Czerner } 224bbc605cdSLukas Czerner 225bbc605cdSLukas Czerner primary_grp = ext4_get_group_number(sb, sbi->s_sbh->b_blocknr); 226bbc605cdSLukas Czerner ngroups = ext4_get_groups_count(sb); 227bbc605cdSLukas Czerner 228bbc605cdSLukas Czerner /* 229bbc605cdSLukas Czerner * Update backup superblocks. We have to start from group 0 230bbc605cdSLukas Czerner * because it might not be where the primary superblock is 231bbc605cdSLukas Czerner * if the fs is mounted with -o sb=<backup_sb_block> 232bbc605cdSLukas Czerner */ 233bbc605cdSLukas Czerner i = 0; 234bbc605cdSLukas Czerner grp = 0; 235bbc605cdSLukas Czerner while (grp < ngroups) { 236bbc605cdSLukas Czerner /* Skip primary superblock */ 237bbc605cdSLukas Czerner if (grp == primary_grp) 238bbc605cdSLukas Czerner goto next_grp; 239bbc605cdSLukas Czerner 240bbc605cdSLukas Czerner ret = ext4_update_backup_sb(sb, handle, grp, func, arg); 241bbc605cdSLukas Czerner if (ret < 0) { 242bbc605cdSLukas Czerner /* Ignore bad checksum; try to update next sb */ 243bbc605cdSLukas Czerner if (ret == -EFSBADCRC) 244bbc605cdSLukas Czerner goto next_grp; 245bbc605cdSLukas Czerner err = ret; 246bbc605cdSLukas Czerner goto out_journal; 247bbc605cdSLukas Czerner } 248bbc605cdSLukas Czerner 249bbc605cdSLukas Czerner i += ret; 250bbc605cdSLukas Czerner if (handle && i > 1) { 251bbc605cdSLukas Czerner /* 252bbc605cdSLukas Czerner * We're only journalling primary superblock and 253bbc605cdSLukas Czerner * two backup superblocks; the rest is not 254bbc605cdSLukas Czerner * journalled. 255bbc605cdSLukas Czerner */ 256bbc605cdSLukas Czerner err = ext4_journal_stop(handle); 257bbc605cdSLukas Czerner if (err) 258bbc605cdSLukas Czerner goto out; 259bbc605cdSLukas Czerner handle = NULL; 260bbc605cdSLukas Czerner } 261bbc605cdSLukas Czerner next_grp: 262bbc605cdSLukas Czerner grp = ext4_list_backups(sb, &three, &five, &seven); 263bbc605cdSLukas Czerner } 264bbc605cdSLukas Czerner 265bbc605cdSLukas Czerner out_journal: 266bbc605cdSLukas Czerner if (handle) { 267bbc605cdSLukas Czerner ret = ext4_journal_stop(handle); 268bbc605cdSLukas Czerner if (ret && !err) 269bbc605cdSLukas Czerner err = ret; 270bbc605cdSLukas Czerner } 271bbc605cdSLukas Czerner out: 272bbc605cdSLukas Czerner clear_bit_unlock(EXT4_FLAGS_RESIZING, &sbi->s_ext4_flags); 273bbc605cdSLukas Czerner smp_mb__after_atomic(); 274bbc605cdSLukas Czerner return err ? err : 0; 275bbc605cdSLukas Czerner } 276bbc605cdSLukas Czerner 277919adbfeSTheodore Ts'o /* 278393d1d1dSDr. Tilmann Bubeck * Swap memory between @a and @b for @len bytes. 279393d1d1dSDr. Tilmann Bubeck * 280393d1d1dSDr. Tilmann Bubeck * @a: pointer to first memory area 281393d1d1dSDr. Tilmann Bubeck * @b: pointer to second memory area 282393d1d1dSDr. Tilmann Bubeck * @len: number of bytes to swap 283393d1d1dSDr. Tilmann Bubeck * 284393d1d1dSDr. Tilmann Bubeck */ 285393d1d1dSDr. Tilmann Bubeck static void memswap(void *a, void *b, size_t len) 286393d1d1dSDr. Tilmann Bubeck { 287393d1d1dSDr. Tilmann Bubeck unsigned char *ap, *bp; 288393d1d1dSDr. Tilmann Bubeck 289393d1d1dSDr. Tilmann Bubeck ap = (unsigned char *)a; 290393d1d1dSDr. Tilmann Bubeck bp = (unsigned char *)b; 291393d1d1dSDr. Tilmann Bubeck while (len-- > 0) { 2924b7e2db5SFabian Frederick swap(*ap, *bp); 293393d1d1dSDr. Tilmann Bubeck ap++; 294393d1d1dSDr. Tilmann Bubeck bp++; 295393d1d1dSDr. Tilmann Bubeck } 296393d1d1dSDr. Tilmann Bubeck } 297393d1d1dSDr. Tilmann Bubeck 298919adbfeSTheodore Ts'o /* 299393d1d1dSDr. Tilmann Bubeck * Swap i_data and associated attributes between @inode1 and @inode2. 300393d1d1dSDr. Tilmann Bubeck * This function is used for the primary swap between inode1 and inode2 301393d1d1dSDr. Tilmann Bubeck * and also to revert this primary swap in case of errors. 302393d1d1dSDr. Tilmann Bubeck * 303393d1d1dSDr. Tilmann Bubeck * Therefore you have to make sure, that calling this method twice 304393d1d1dSDr. Tilmann Bubeck * will revert all changes. 305393d1d1dSDr. Tilmann Bubeck * 306393d1d1dSDr. Tilmann Bubeck * @inode1: pointer to first inode 307393d1d1dSDr. Tilmann Bubeck * @inode2: pointer to second inode 308393d1d1dSDr. Tilmann Bubeck */ 309393d1d1dSDr. Tilmann Bubeck static void swap_inode_data(struct inode *inode1, struct inode *inode2) 310393d1d1dSDr. Tilmann Bubeck { 311393d1d1dSDr. Tilmann Bubeck loff_t isize; 312393d1d1dSDr. Tilmann Bubeck struct ext4_inode_info *ei1; 313393d1d1dSDr. Tilmann Bubeck struct ext4_inode_info *ei2; 314abdc644eSyangerkun unsigned long tmp; 315393d1d1dSDr. Tilmann Bubeck 316393d1d1dSDr. Tilmann Bubeck ei1 = EXT4_I(inode1); 317393d1d1dSDr. Tilmann Bubeck ei2 = EXT4_I(inode2); 318393d1d1dSDr. Tilmann Bubeck 3199c5d58fbSJeff Layton swap(inode1->i_version, inode2->i_version); 3209c5d58fbSJeff Layton swap(inode1->i_atime, inode2->i_atime); 3219c5d58fbSJeff Layton swap(inode1->i_mtime, inode2->i_mtime); 322393d1d1dSDr. Tilmann Bubeck 323393d1d1dSDr. Tilmann Bubeck memswap(ei1->i_data, ei2->i_data, sizeof(ei1->i_data)); 324abdc644eSyangerkun tmp = ei1->i_flags & EXT4_FL_SHOULD_SWAP; 325abdc644eSyangerkun ei1->i_flags = (ei2->i_flags & EXT4_FL_SHOULD_SWAP) | 326abdc644eSyangerkun (ei1->i_flags & ~EXT4_FL_SHOULD_SWAP); 327abdc644eSyangerkun ei2->i_flags = tmp | (ei2->i_flags & ~EXT4_FL_SHOULD_SWAP); 3289c5d58fbSJeff Layton swap(ei1->i_disksize, ei2->i_disksize); 329cde2d7a7STheodore Ts'o ext4_es_remove_extent(inode1, 0, EXT_MAX_BLOCKS); 330cde2d7a7STheodore Ts'o ext4_es_remove_extent(inode2, 0, EXT_MAX_BLOCKS); 331393d1d1dSDr. Tilmann Bubeck 332393d1d1dSDr. Tilmann Bubeck isize = i_size_read(inode1); 333393d1d1dSDr. Tilmann Bubeck i_size_write(inode1, i_size_read(inode2)); 334393d1d1dSDr. Tilmann Bubeck i_size_write(inode2, isize); 335393d1d1dSDr. Tilmann Bubeck } 336393d1d1dSDr. Tilmann Bubeck 3378016e29fSHarshad Shirwadkar void ext4_reset_inode_seed(struct inode *inode) 33818aded17STheodore Ts'o { 33918aded17STheodore Ts'o struct ext4_inode_info *ei = EXT4_I(inode); 34018aded17STheodore Ts'o struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 34118aded17STheodore Ts'o __le32 inum = cpu_to_le32(inode->i_ino); 34218aded17STheodore Ts'o __le32 gen = cpu_to_le32(inode->i_generation); 34318aded17STheodore Ts'o __u32 csum; 34418aded17STheodore Ts'o 34518aded17STheodore Ts'o if (!ext4_has_metadata_csum(inode->i_sb)) 34618aded17STheodore Ts'o return; 34718aded17STheodore Ts'o 34818aded17STheodore Ts'o csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum, sizeof(inum)); 34918aded17STheodore Ts'o ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen, sizeof(gen)); 35018aded17STheodore Ts'o } 35118aded17STheodore Ts'o 352919adbfeSTheodore Ts'o /* 353393d1d1dSDr. Tilmann Bubeck * Swap the information from the given @inode and the inode 354393d1d1dSDr. Tilmann Bubeck * EXT4_BOOT_LOADER_INO. It will basically swap i_data and all other 355393d1d1dSDr. Tilmann Bubeck * important fields of the inodes. 356393d1d1dSDr. Tilmann Bubeck * 357393d1d1dSDr. Tilmann Bubeck * @sb: the super block of the filesystem 35801beba79SChristian Brauner * @idmap: idmap of the mount the inode was found from 359393d1d1dSDr. Tilmann Bubeck * @inode: the inode to swap with EXT4_BOOT_LOADER_INO 360393d1d1dSDr. Tilmann Bubeck * 361393d1d1dSDr. Tilmann Bubeck */ 362393d1d1dSDr. Tilmann Bubeck static long swap_inode_boot_loader(struct super_block *sb, 36301beba79SChristian Brauner struct mnt_idmap *idmap, 364393d1d1dSDr. Tilmann Bubeck struct inode *inode) 365393d1d1dSDr. Tilmann Bubeck { 366393d1d1dSDr. Tilmann Bubeck handle_t *handle; 367393d1d1dSDr. Tilmann Bubeck int err; 368393d1d1dSDr. Tilmann Bubeck struct inode *inode_bl; 369393d1d1dSDr. Tilmann Bubeck struct ext4_inode_info *ei_bl; 370aa507b5fSyangerkun qsize_t size, size_bl, diff; 371aa507b5fSyangerkun blkcnt_t blocks; 372aa507b5fSyangerkun unsigned short bytes; 373393d1d1dSDr. Tilmann Bubeck 37463b1e9bcSBaokun Li inode_bl = ext4_iget(sb, EXT4_BOOT_LOADER_INO, 37563b1e9bcSBaokun Li EXT4_IGET_SPECIAL | EXT4_IGET_BAD); 376d8558a29STheodore Ts'o if (IS_ERR(inode_bl)) 377d8558a29STheodore Ts'o return PTR_ERR(inode_bl); 378393d1d1dSDr. Tilmann Bubeck ei_bl = EXT4_I(inode_bl); 379393d1d1dSDr. Tilmann Bubeck 380393d1d1dSDr. Tilmann Bubeck /* Protect orig inodes against a truncate and make sure, 381393d1d1dSDr. Tilmann Bubeck * that only 1 swap_inode_boot_loader is running. */ 382375e289eSJ. Bruce Fields lock_two_nondirectories(inode, inode_bl); 383393d1d1dSDr. Tilmann Bubeck 38467a11611Syangerkun if (inode->i_nlink != 1 || !S_ISREG(inode->i_mode) || 38567a11611Syangerkun IS_SWAPFILE(inode) || IS_ENCRYPTED(inode) || 3866e589291STheodore Ts'o (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL) || 38767a11611Syangerkun ext4_has_inline_data(inode)) { 38867a11611Syangerkun err = -EINVAL; 38967a11611Syangerkun goto journal_err_out; 39067a11611Syangerkun } 39167a11611Syangerkun 39267a11611Syangerkun if (IS_RDONLY(inode) || IS_APPEND(inode) || IS_IMMUTABLE(inode) || 39301beba79SChristian Brauner !inode_owner_or_capable(idmap, inode) || 39421cb47beSChristian Brauner !capable(CAP_SYS_ADMIN)) { 39567a11611Syangerkun err = -EPERM; 39667a11611Syangerkun goto journal_err_out; 39767a11611Syangerkun } 39867a11611Syangerkun 399d4f5258eSJan Kara filemap_invalidate_lock(inode->i_mapping); 400a46c68a3Syangerkun err = filemap_write_and_wait(inode->i_mapping); 401a46c68a3Syangerkun if (err) 402a46c68a3Syangerkun goto err_out; 403a46c68a3Syangerkun 404a46c68a3Syangerkun err = filemap_write_and_wait(inode_bl->i_mapping); 405a46c68a3Syangerkun if (err) 406a46c68a3Syangerkun goto err_out; 407a46c68a3Syangerkun 408393d1d1dSDr. Tilmann Bubeck /* Wait for all existing dio workers */ 409393d1d1dSDr. Tilmann Bubeck inode_dio_wait(inode); 410393d1d1dSDr. Tilmann Bubeck inode_dio_wait(inode_bl); 411393d1d1dSDr. Tilmann Bubeck 41218aded17STheodore Ts'o truncate_inode_pages(&inode->i_data, 0); 41318aded17STheodore Ts'o truncate_inode_pages(&inode_bl->i_data, 0); 41418aded17STheodore Ts'o 415393d1d1dSDr. Tilmann Bubeck handle = ext4_journal_start(inode_bl, EXT4_HT_MOVE_EXTENTS, 2); 416393d1d1dSDr. Tilmann Bubeck if (IS_ERR(handle)) { 417393d1d1dSDr. Tilmann Bubeck err = -EINVAL; 418a46c68a3Syangerkun goto err_out; 419393d1d1dSDr. Tilmann Bubeck } 420e85c81baSXin Yin ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_SWAP_BOOT, handle); 421393d1d1dSDr. Tilmann Bubeck 422393d1d1dSDr. Tilmann Bubeck /* Protect extent tree against block allocations via delalloc */ 423393d1d1dSDr. Tilmann Bubeck ext4_double_down_write_data_sem(inode, inode_bl); 424393d1d1dSDr. Tilmann Bubeck 425991ed014SBaokun Li if (is_bad_inode(inode_bl) || !S_ISREG(inode_bl->i_mode)) { 426393d1d1dSDr. Tilmann Bubeck /* this inode has never been used as a BOOT_LOADER */ 427393d1d1dSDr. Tilmann Bubeck set_nlink(inode_bl, 1); 428393d1d1dSDr. Tilmann Bubeck i_uid_write(inode_bl, 0); 429393d1d1dSDr. Tilmann Bubeck i_gid_write(inode_bl, 0); 430393d1d1dSDr. Tilmann Bubeck inode_bl->i_flags = 0; 431393d1d1dSDr. Tilmann Bubeck ei_bl->i_flags = 0; 432ee73f9a5SJeff Layton inode_set_iversion(inode_bl, 1); 433393d1d1dSDr. Tilmann Bubeck i_size_write(inode_bl, 0); 434f5361da1SZhihao Cheng EXT4_I(inode_bl)->i_disksize = inode_bl->i_size; 435393d1d1dSDr. Tilmann Bubeck inode_bl->i_mode = S_IFREG; 436e2b911c5SDarrick J. Wong if (ext4_has_feature_extents(sb)) { 437393d1d1dSDr. Tilmann Bubeck ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS); 438393d1d1dSDr. Tilmann Bubeck ext4_ext_tree_init(handle, inode_bl); 439393d1d1dSDr. Tilmann Bubeck } else 440393d1d1dSDr. Tilmann Bubeck memset(ei_bl->i_data, 0, sizeof(ei_bl->i_data)); 441393d1d1dSDr. Tilmann Bubeck } 442393d1d1dSDr. Tilmann Bubeck 443aa507b5fSyangerkun err = dquot_initialize(inode); 444aa507b5fSyangerkun if (err) 445aa507b5fSyangerkun goto err_out1; 446aa507b5fSyangerkun 447aa507b5fSyangerkun size = (qsize_t)(inode->i_blocks) * (1 << 9) + inode->i_bytes; 448aa507b5fSyangerkun size_bl = (qsize_t)(inode_bl->i_blocks) * (1 << 9) + inode_bl->i_bytes; 449aa507b5fSyangerkun diff = size - size_bl; 450393d1d1dSDr. Tilmann Bubeck swap_inode_data(inode, inode_bl); 451393d1d1dSDr. Tilmann Bubeck 452eeca7ea1SDeepa Dinamani inode->i_ctime = inode_bl->i_ctime = current_time(inode); 453a642c2c0SJeff Layton inode_inc_iversion(inode); 454393d1d1dSDr. Tilmann Bubeck 455a251c17aSJason A. Donenfeld inode->i_generation = get_random_u32(); 456a251c17aSJason A. Donenfeld inode_bl->i_generation = get_random_u32(); 4578016e29fSHarshad Shirwadkar ext4_reset_inode_seed(inode); 4588016e29fSHarshad Shirwadkar ext4_reset_inode_seed(inode_bl); 459393d1d1dSDr. Tilmann Bubeck 46027bc446eSbrookxu ext4_discard_preallocations(inode, 0); 461393d1d1dSDr. Tilmann Bubeck 462393d1d1dSDr. Tilmann Bubeck err = ext4_mark_inode_dirty(handle, inode); 463393d1d1dSDr. Tilmann Bubeck if (err < 0) { 464aa507b5fSyangerkun /* No need to update quota information. */ 465393d1d1dSDr. Tilmann Bubeck ext4_warning(inode->i_sb, 466393d1d1dSDr. Tilmann Bubeck "couldn't mark inode #%lu dirty (err %d)", 467393d1d1dSDr. Tilmann Bubeck inode->i_ino, err); 468393d1d1dSDr. Tilmann Bubeck /* Revert all changes: */ 469393d1d1dSDr. Tilmann Bubeck swap_inode_data(inode, inode_bl); 47018aded17STheodore Ts'o ext4_mark_inode_dirty(handle, inode); 471aa507b5fSyangerkun goto err_out1; 472aa507b5fSyangerkun } 473aa507b5fSyangerkun 474aa507b5fSyangerkun blocks = inode_bl->i_blocks; 475aa507b5fSyangerkun bytes = inode_bl->i_bytes; 476aa507b5fSyangerkun inode_bl->i_blocks = inode->i_blocks; 477aa507b5fSyangerkun inode_bl->i_bytes = inode->i_bytes; 478393d1d1dSDr. Tilmann Bubeck err = ext4_mark_inode_dirty(handle, inode_bl); 479393d1d1dSDr. Tilmann Bubeck if (err < 0) { 480aa507b5fSyangerkun /* No need to update quota information. */ 481393d1d1dSDr. Tilmann Bubeck ext4_warning(inode_bl->i_sb, 482393d1d1dSDr. Tilmann Bubeck "couldn't mark inode #%lu dirty (err %d)", 483393d1d1dSDr. Tilmann Bubeck inode_bl->i_ino, err); 484aa507b5fSyangerkun goto revert; 485aa507b5fSyangerkun } 486aa507b5fSyangerkun 487aa507b5fSyangerkun /* Bootloader inode should not be counted into quota information. */ 488aa507b5fSyangerkun if (diff > 0) 489aa507b5fSyangerkun dquot_free_space(inode, diff); 490aa507b5fSyangerkun else 491aa507b5fSyangerkun err = dquot_alloc_space(inode, -1 * diff); 492aa507b5fSyangerkun 493aa507b5fSyangerkun if (err < 0) { 494aa507b5fSyangerkun revert: 495393d1d1dSDr. Tilmann Bubeck /* Revert all changes: */ 496aa507b5fSyangerkun inode_bl->i_blocks = blocks; 497aa507b5fSyangerkun inode_bl->i_bytes = bytes; 498393d1d1dSDr. Tilmann Bubeck swap_inode_data(inode, inode_bl); 499393d1d1dSDr. Tilmann Bubeck ext4_mark_inode_dirty(handle, inode); 50018aded17STheodore Ts'o ext4_mark_inode_dirty(handle, inode_bl); 501393d1d1dSDr. Tilmann Bubeck } 502aa507b5fSyangerkun 503aa507b5fSyangerkun err_out1: 504393d1d1dSDr. Tilmann Bubeck ext4_journal_stop(handle); 505393d1d1dSDr. Tilmann Bubeck ext4_double_up_write_data_sem(inode, inode_bl); 506393d1d1dSDr. Tilmann Bubeck 507a46c68a3Syangerkun err_out: 508d4f5258eSJan Kara filemap_invalidate_unlock(inode->i_mapping); 50930d29b11SZheng Liu journal_err_out: 510375e289eSJ. Bruce Fields unlock_two_nondirectories(inode, inode_bl); 511393d1d1dSDr. Tilmann Bubeck iput(inode_bl); 512393d1d1dSDr. Tilmann Bubeck return err; 513393d1d1dSDr. Tilmann Bubeck } 514393d1d1dSDr. Tilmann Bubeck 5152e538403SDarrick J. Wong /* 5162e538403SDarrick J. Wong * If immutable is set and we are not clearing it, we're not allowed to change 5172e538403SDarrick J. Wong * anything else in the inode. Don't error out if we're only trying to set 5182e538403SDarrick J. Wong * immutable on an immutable file. 5192e538403SDarrick J. Wong */ 5202e538403SDarrick J. Wong static int ext4_ioctl_check_immutable(struct inode *inode, __u32 new_projid, 5212e538403SDarrick J. Wong unsigned int flags) 5222e538403SDarrick J. Wong { 5232e538403SDarrick J. Wong struct ext4_inode_info *ei = EXT4_I(inode); 5242e538403SDarrick J. Wong unsigned int oldflags = ei->i_flags; 5252e538403SDarrick J. Wong 5262e538403SDarrick J. Wong if (!(oldflags & EXT4_IMMUTABLE_FL) || !(flags & EXT4_IMMUTABLE_FL)) 5272e538403SDarrick J. Wong return 0; 5282e538403SDarrick J. Wong 5292e538403SDarrick J. Wong if ((oldflags & ~EXT4_IMMUTABLE_FL) != (flags & ~EXT4_IMMUTABLE_FL)) 5302e538403SDarrick J. Wong return -EPERM; 5312e538403SDarrick J. Wong if (ext4_has_feature_project(inode->i_sb) && 5322e538403SDarrick J. Wong __kprojid_val(ei->i_projid) != new_projid) 5332e538403SDarrick J. Wong return -EPERM; 5342e538403SDarrick J. Wong 5352e538403SDarrick J. Wong return 0; 5362e538403SDarrick J. Wong } 5372e538403SDarrick J. Wong 538b383a73fSIra Weiny static void ext4_dax_dontcache(struct inode *inode, unsigned int flags) 539b383a73fSIra Weiny { 540b383a73fSIra Weiny struct ext4_inode_info *ei = EXT4_I(inode); 541b383a73fSIra Weiny 542b383a73fSIra Weiny if (S_ISDIR(inode->i_mode)) 543b383a73fSIra Weiny return; 544b383a73fSIra Weiny 545b383a73fSIra Weiny if (test_opt2(inode->i_sb, DAX_NEVER) || 546b383a73fSIra Weiny test_opt(inode->i_sb, DAX_ALWAYS)) 547b383a73fSIra Weiny return; 548b383a73fSIra Weiny 549b383a73fSIra Weiny if ((ei->i_flags ^ flags) & EXT4_DAX_FL) 550b383a73fSIra Weiny d_mark_dontcache(inode); 551b383a73fSIra Weiny } 552b383a73fSIra Weiny 553b383a73fSIra Weiny static bool dax_compatible(struct inode *inode, unsigned int oldflags, 554b383a73fSIra Weiny unsigned int flags) 555b383a73fSIra Weiny { 5564811d992STheodore Ts'o /* Allow the DAX flag to be changed on inline directories */ 5574811d992STheodore Ts'o if (S_ISDIR(inode->i_mode)) { 5584811d992STheodore Ts'o flags &= ~EXT4_INLINE_DATA_FL; 5594811d992STheodore Ts'o oldflags &= ~EXT4_INLINE_DATA_FL; 5604811d992STheodore Ts'o } 5614811d992STheodore Ts'o 562b383a73fSIra Weiny if (flags & EXT4_DAX_FL) { 563b383a73fSIra Weiny if ((oldflags & EXT4_DAX_MUT_EXCL) || 564b383a73fSIra Weiny ext4_test_inode_state(inode, 565b383a73fSIra Weiny EXT4_STATE_VERITY_IN_PROGRESS)) { 566b383a73fSIra Weiny return false; 567b383a73fSIra Weiny } 568b383a73fSIra Weiny } 569b383a73fSIra Weiny 570b383a73fSIra Weiny if ((flags & EXT4_DAX_MUT_EXCL) && (oldflags & EXT4_DAX_FL)) 571b383a73fSIra Weiny return false; 572b383a73fSIra Weiny 573b383a73fSIra Weiny return true; 574b383a73fSIra Weiny } 575b383a73fSIra Weiny 5769b7365fcSLi Xi static int ext4_ioctl_setflags(struct inode *inode, 5779b7365fcSLi Xi unsigned int flags) 578ac27a0ecSDave Kleikamp { 579617ba13bSMingming Cao struct ext4_inode_info *ei = EXT4_I(inode); 580ac27a0ecSDave Kleikamp handle_t *handle = NULL; 581fdde368eSAnton Protopopov int err = -EPERM, migrate = 0; 582617ba13bSMingming Cao struct ext4_iloc iloc; 58379906964STheodore Ts'o unsigned int oldflags, mask, i; 584b886ee3eSGabriel Krisman Bertazi struct super_block *sb = inode->i_sb; 585ac27a0ecSDave Kleikamp 586e47776a0SJan Kara /* Is it quota file? Do not allow user to mess with it */ 58702749a4cSTahsin Erdogan if (ext4_is_quota_file(inode)) 58842a74f20SDave Hansen goto flags_out; 58942a74f20SDave Hansen 590ac27a0ecSDave Kleikamp oldflags = ei->i_flags; 591ac27a0ecSDave Kleikamp /* 592ac27a0ecSDave Kleikamp * The JOURNAL_DATA flag can only be changed by 593ac27a0ecSDave Kleikamp * the relevant capability. 594ac27a0ecSDave Kleikamp */ 595fcebc794SIra Weiny if ((flags ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) { 59642a74f20SDave Hansen if (!capable(CAP_SYS_RESOURCE)) 59742a74f20SDave Hansen goto flags_out; 598ac27a0ecSDave Kleikamp } 599b383a73fSIra Weiny 600b383a73fSIra Weiny if (!dax_compatible(inode, oldflags, flags)) { 601b383a73fSIra Weiny err = -EOPNOTSUPP; 602b383a73fSIra Weiny goto flags_out; 603b383a73fSIra Weiny } 604b383a73fSIra Weiny 605996bb9fdSTheodore Ts'o if ((flags ^ oldflags) & EXT4_EXTENTS_FL) 6064db46fc2SAneesh Kumar K.V migrate = 1; 607ac27a0ecSDave Kleikamp 608b886ee3eSGabriel Krisman Bertazi if ((flags ^ oldflags) & EXT4_CASEFOLD_FL) { 609b886ee3eSGabriel Krisman Bertazi if (!ext4_has_feature_casefold(sb)) { 610b886ee3eSGabriel Krisman Bertazi err = -EOPNOTSUPP; 611b886ee3eSGabriel Krisman Bertazi goto flags_out; 612b886ee3eSGabriel Krisman Bertazi } 613b886ee3eSGabriel Krisman Bertazi 614b886ee3eSGabriel Krisman Bertazi if (!S_ISDIR(inode->i_mode)) { 615b886ee3eSGabriel Krisman Bertazi err = -ENOTDIR; 616b886ee3eSGabriel Krisman Bertazi goto flags_out; 617b886ee3eSGabriel Krisman Bertazi } 618b886ee3eSGabriel Krisman Bertazi 619b886ee3eSGabriel Krisman Bertazi if (!ext4_empty_dir(inode)) { 620b886ee3eSGabriel Krisman Bertazi err = -ENOTEMPTY; 621b886ee3eSGabriel Krisman Bertazi goto flags_out; 622b886ee3eSGabriel Krisman Bertazi } 623b886ee3eSGabriel Krisman Bertazi } 624b886ee3eSGabriel Krisman Bertazi 6252e538403SDarrick J. Wong /* 6262e538403SDarrick J. Wong * Wait for all pending directio and then flush all the dirty pages 6272e538403SDarrick J. Wong * for this file. The flush marks all the pages readonly, so any 6282e538403SDarrick J. Wong * subsequent attempt to write to the file (particularly mmap pages) 6292e538403SDarrick J. Wong * will come through the filesystem and fail. 6302e538403SDarrick J. Wong */ 6312e538403SDarrick J. Wong if (S_ISREG(inode->i_mode) && !IS_IMMUTABLE(inode) && 6322e538403SDarrick J. Wong (flags & EXT4_IMMUTABLE_FL)) { 6332e538403SDarrick J. Wong inode_dio_wait(inode); 6342e538403SDarrick J. Wong err = filemap_write_and_wait(inode->i_mapping); 6352e538403SDarrick J. Wong if (err) 6362e538403SDarrick J. Wong goto flags_out; 6372e538403SDarrick J. Wong } 6382e538403SDarrick J. Wong 6399924a92aSTheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 640ac27a0ecSDave Kleikamp if (IS_ERR(handle)) { 64142a74f20SDave Hansen err = PTR_ERR(handle); 64242a74f20SDave Hansen goto flags_out; 643ac27a0ecSDave Kleikamp } 644ac27a0ecSDave Kleikamp if (IS_SYNC(inode)) 6450390131bSFrank Mayhar ext4_handle_sync(handle); 646617ba13bSMingming Cao err = ext4_reserve_inode_write(handle, inode, &iloc); 647ac27a0ecSDave Kleikamp if (err) 648ac27a0ecSDave Kleikamp goto flags_err; 649ac27a0ecSDave Kleikamp 650b383a73fSIra Weiny ext4_dax_dontcache(inode, flags); 651b383a73fSIra Weiny 65279906964STheodore Ts'o for (i = 0, mask = 1; i < 32; i++, mask <<= 1) { 65379906964STheodore Ts'o if (!(mask & EXT4_FL_USER_MODIFIABLE)) 65479906964STheodore Ts'o continue; 655f8011d93SJan Kara /* These flags get special treatment later */ 656f8011d93SJan Kara if (mask == EXT4_JOURNAL_DATA_FL || mask == EXT4_EXTENTS_FL) 657f8011d93SJan Kara continue; 65879906964STheodore Ts'o if (mask & flags) 65979906964STheodore Ts'o ext4_set_inode_flag(inode, i); 66079906964STheodore Ts'o else 66179906964STheodore Ts'o ext4_clear_inode_flag(inode, i); 66279906964STheodore Ts'o } 663ac27a0ecSDave Kleikamp 664043546e4SIra Weiny ext4_set_inode_flags(inode, false); 665043546e4SIra Weiny 666eeca7ea1SDeepa Dinamani inode->i_ctime = current_time(inode); 667a642c2c0SJeff Layton inode_inc_iversion(inode); 668ac27a0ecSDave Kleikamp 669617ba13bSMingming Cao err = ext4_mark_iloc_dirty(handle, inode, &iloc); 670ac27a0ecSDave Kleikamp flags_err: 671617ba13bSMingming Cao ext4_journal_stop(handle); 67242a74f20SDave Hansen if (err) 67342a74f20SDave Hansen goto flags_out; 674ac27a0ecSDave Kleikamp 675fcebc794SIra Weiny if ((flags ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) { 676e9072d85SRoss Zwisler /* 677e9072d85SRoss Zwisler * Changes to the journaling mode can cause unsafe changes to 678ff694ab6SIra Weiny * S_DAX if the inode is DAX 679e9072d85SRoss Zwisler */ 680ff694ab6SIra Weiny if (IS_DAX(inode)) { 681e9072d85SRoss Zwisler err = -EBUSY; 682e9072d85SRoss Zwisler goto flags_out; 683e9072d85SRoss Zwisler } 684e9072d85SRoss Zwisler 685fcebc794SIra Weiny err = ext4_change_inode_journal_flag(inode, 686fcebc794SIra Weiny flags & EXT4_JOURNAL_DATA_FL); 6874db46fc2SAneesh Kumar K.V if (err) 6884db46fc2SAneesh Kumar K.V goto flags_out; 689e9072d85SRoss Zwisler } 690996bb9fdSTheodore Ts'o if (migrate) { 691996bb9fdSTheodore Ts'o if (flags & EXT4_EXTENTS_FL) 6924db46fc2SAneesh Kumar K.V err = ext4_ext_migrate(inode); 693996bb9fdSTheodore Ts'o else 694996bb9fdSTheodore Ts'o err = ext4_ind_migrate(inode); 695996bb9fdSTheodore Ts'o } 696996bb9fdSTheodore Ts'o 69742a74f20SDave Hansen flags_out: 6989b7365fcSLi Xi return err; 6999b7365fcSLi Xi } 7009b7365fcSLi Xi 7019b7365fcSLi Xi #ifdef CONFIG_QUOTA 7024db5c2e6SMiklos Szeredi static int ext4_ioctl_setproject(struct inode *inode, __u32 projid) 7039b7365fcSLi Xi { 7049b7365fcSLi Xi struct super_block *sb = inode->i_sb; 7059b7365fcSLi Xi struct ext4_inode_info *ei = EXT4_I(inode); 7069b7365fcSLi Xi int err, rc; 7079b7365fcSLi Xi handle_t *handle; 7089b7365fcSLi Xi kprojid_t kprojid; 7099b7365fcSLi Xi struct ext4_iloc iloc; 7109b7365fcSLi Xi struct ext4_inode *raw_inode; 711079788d0SWang Shilong struct dquot *transfer_to[MAXQUOTAS] = { }; 7129b7365fcSLi Xi 7130b7b7779SKaho Ng if (!ext4_has_feature_project(sb)) { 7149b7365fcSLi Xi if (projid != EXT4_DEF_PROJID) 7159b7365fcSLi Xi return -EOPNOTSUPP; 7169b7365fcSLi Xi else 7179b7365fcSLi Xi return 0; 7189b7365fcSLi Xi } 7199b7365fcSLi Xi 7209b7365fcSLi Xi if (EXT4_INODE_SIZE(sb) <= EXT4_GOOD_OLD_INODE_SIZE) 7219b7365fcSLi Xi return -EOPNOTSUPP; 7229b7365fcSLi Xi 7239b7365fcSLi Xi kprojid = make_kprojid(&init_user_ns, (projid_t)projid); 7249b7365fcSLi Xi 7259b7365fcSLi Xi if (projid_eq(kprojid, EXT4_I(inode)->i_projid)) 7269b7365fcSLi Xi return 0; 7279b7365fcSLi Xi 7289b7365fcSLi Xi err = -EPERM; 7299b7365fcSLi Xi /* Is it quota file? Do not allow user to mess with it */ 73002749a4cSTahsin Erdogan if (ext4_is_quota_file(inode)) 731dc7ac6c4SWang Shilong return err; 7329b7365fcSLi Xi 7331485f726SJan Kara err = dquot_initialize(inode); 7341485f726SJan Kara if (err) 7351485f726SJan Kara return err; 7361485f726SJan Kara 7379b7365fcSLi Xi err = ext4_get_inode_loc(inode, &iloc); 7389b7365fcSLi Xi if (err) 739dc7ac6c4SWang Shilong return err; 7409b7365fcSLi Xi 7419b7365fcSLi Xi raw_inode = ext4_raw_inode(&iloc); 7429b7365fcSLi Xi if (!EXT4_FITS_IN_INODE(raw_inode, ei, i_projid)) { 743c03b45b8SMiao Xie err = ext4_expand_extra_isize(inode, 744c03b45b8SMiao Xie EXT4_SB(sb)->s_want_extra_isize, 745c03b45b8SMiao Xie &iloc); 746c03b45b8SMiao Xie if (err) 747dc7ac6c4SWang Shilong return err; 748c03b45b8SMiao Xie } else { 7499b7365fcSLi Xi brelse(iloc.bh); 750c03b45b8SMiao Xie } 7519b7365fcSLi Xi 7529b7365fcSLi Xi handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 7539b7365fcSLi Xi EXT4_QUOTA_INIT_BLOCKS(sb) + 7549b7365fcSLi Xi EXT4_QUOTA_DEL_BLOCKS(sb) + 3); 755dc7ac6c4SWang Shilong if (IS_ERR(handle)) 756dc7ac6c4SWang Shilong return PTR_ERR(handle); 7579b7365fcSLi Xi 7589b7365fcSLi Xi err = ext4_reserve_inode_write(handle, inode, &iloc); 7599b7365fcSLi Xi if (err) 7609b7365fcSLi Xi goto out_stop; 7619b7365fcSLi Xi 7629b7365fcSLi Xi transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid)); 763ff0bc084SSeth Forshee if (!IS_ERR(transfer_to[PRJQUOTA])) { 7647a9ca53aSTahsin Erdogan 7657a9ca53aSTahsin Erdogan /* __dquot_transfer() calls back ext4_get_inode_usage() which 7667a9ca53aSTahsin Erdogan * counts xattr inode references. 7677a9ca53aSTahsin Erdogan */ 7687a9ca53aSTahsin Erdogan down_read(&EXT4_I(inode)->xattr_sem); 7699b7365fcSLi Xi err = __dquot_transfer(inode, transfer_to); 7707a9ca53aSTahsin Erdogan up_read(&EXT4_I(inode)->xattr_sem); 7719b7365fcSLi Xi dqput(transfer_to[PRJQUOTA]); 7729b7365fcSLi Xi if (err) 7739b7365fcSLi Xi goto out_dirty; 7749b7365fcSLi Xi } 775079788d0SWang Shilong 7769b7365fcSLi Xi EXT4_I(inode)->i_projid = kprojid; 777eeca7ea1SDeepa Dinamani inode->i_ctime = current_time(inode); 778a642c2c0SJeff Layton inode_inc_iversion(inode); 7799b7365fcSLi Xi out_dirty: 7809b7365fcSLi Xi rc = ext4_mark_iloc_dirty(handle, inode, &iloc); 7819b7365fcSLi Xi if (!err) 7829b7365fcSLi Xi err = rc; 7839b7365fcSLi Xi out_stop: 7849b7365fcSLi Xi ext4_journal_stop(handle); 7859b7365fcSLi Xi return err; 7869b7365fcSLi Xi } 7879b7365fcSLi Xi #else 7884db5c2e6SMiklos Szeredi static int ext4_ioctl_setproject(struct inode *inode, __u32 projid) 7899b7365fcSLi Xi { 7909b7365fcSLi Xi if (projid != EXT4_DEF_PROJID) 7919b7365fcSLi Xi return -EOPNOTSUPP; 7929b7365fcSLi Xi return 0; 7939b7365fcSLi Xi } 7949b7365fcSLi Xi #endif 7959b7365fcSLi Xi 7961a20a630SEric Biggers static int ext4_shutdown(struct super_block *sb, unsigned long arg) 797783d9485STheodore Ts'o { 798783d9485STheodore Ts'o struct ext4_sb_info *sbi = EXT4_SB(sb); 799783d9485STheodore Ts'o __u32 flags; 800*c4d13222SChao Yu int ret; 801783d9485STheodore Ts'o 802783d9485STheodore Ts'o if (!capable(CAP_SYS_ADMIN)) 803783d9485STheodore Ts'o return -EPERM; 804783d9485STheodore Ts'o 805783d9485STheodore Ts'o if (get_user(flags, (__u32 __user *)arg)) 806783d9485STheodore Ts'o return -EFAULT; 807783d9485STheodore Ts'o 808783d9485STheodore Ts'o if (flags > EXT4_GOING_FLAGS_NOLOGFLUSH) 809783d9485STheodore Ts'o return -EINVAL; 810783d9485STheodore Ts'o 811783d9485STheodore Ts'o if (ext4_forced_shutdown(sbi)) 812783d9485STheodore Ts'o return 0; 813783d9485STheodore Ts'o 814783d9485STheodore Ts'o ext4_msg(sb, KERN_ALERT, "shut down requested (%d)", flags); 815ccf0f32aSTheodore Ts'o trace_ext4_shutdown(sb, flags); 816783d9485STheodore Ts'o 817783d9485STheodore Ts'o switch (flags) { 818783d9485STheodore Ts'o case EXT4_GOING_FLAGS_DEFAULT: 819*c4d13222SChao Yu ret = freeze_bdev(sb->s_bdev); 820*c4d13222SChao Yu if (ret) 821*c4d13222SChao Yu return ret; 822783d9485STheodore Ts'o set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags); 823040f04bdSChristoph Hellwig thaw_bdev(sb->s_bdev); 824783d9485STheodore Ts'o break; 825783d9485STheodore Ts'o case EXT4_GOING_FLAGS_LOGFLUSH: 826783d9485STheodore Ts'o set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags); 827783d9485STheodore Ts'o if (sbi->s_journal && !is_journal_aborted(sbi->s_journal)) { 828783d9485STheodore Ts'o (void) ext4_force_commit(sb); 829fb7c0244STheodore Ts'o jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN); 830783d9485STheodore Ts'o } 831783d9485STheodore Ts'o break; 832783d9485STheodore Ts'o case EXT4_GOING_FLAGS_NOLOGFLUSH: 833783d9485STheodore Ts'o set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags); 834a6d9946bSTheodore Ts'o if (sbi->s_journal && !is_journal_aborted(sbi->s_journal)) 835fb7c0244STheodore Ts'o jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN); 836783d9485STheodore Ts'o break; 837783d9485STheodore Ts'o default: 838783d9485STheodore Ts'o return -EINVAL; 839783d9485STheodore Ts'o } 840783d9485STheodore Ts'o clear_opt(sb, DISCARD); 841783d9485STheodore Ts'o return 0; 842783d9485STheodore Ts'o } 843783d9485STheodore Ts'o 8440c9ec4beSDarrick J. Wong struct getfsmap_info { 8450c9ec4beSDarrick J. Wong struct super_block *gi_sb; 8460c9ec4beSDarrick J. Wong struct fsmap_head __user *gi_data; 8470c9ec4beSDarrick J. Wong unsigned int gi_idx; 8480c9ec4beSDarrick J. Wong __u32 gi_last_flags; 8490c9ec4beSDarrick J. Wong }; 8500c9ec4beSDarrick J. Wong 8510c9ec4beSDarrick J. Wong static int ext4_getfsmap_format(struct ext4_fsmap *xfm, void *priv) 8520c9ec4beSDarrick J. Wong { 8530c9ec4beSDarrick J. Wong struct getfsmap_info *info = priv; 8540c9ec4beSDarrick J. Wong struct fsmap fm; 8550c9ec4beSDarrick J. Wong 8560c9ec4beSDarrick J. Wong trace_ext4_getfsmap_mapping(info->gi_sb, xfm); 8570c9ec4beSDarrick J. Wong 8580c9ec4beSDarrick J. Wong info->gi_last_flags = xfm->fmr_flags; 8590c9ec4beSDarrick J. Wong ext4_fsmap_from_internal(info->gi_sb, &fm, xfm); 8600c9ec4beSDarrick J. Wong if (copy_to_user(&info->gi_data->fmh_recs[info->gi_idx++], &fm, 8610c9ec4beSDarrick J. Wong sizeof(struct fsmap))) 8620c9ec4beSDarrick J. Wong return -EFAULT; 8630c9ec4beSDarrick J. Wong 8640c9ec4beSDarrick J. Wong return 0; 8650c9ec4beSDarrick J. Wong } 8660c9ec4beSDarrick J. Wong 8670c9ec4beSDarrick J. Wong static int ext4_ioc_getfsmap(struct super_block *sb, 8680c9ec4beSDarrick J. Wong struct fsmap_head __user *arg) 8690c9ec4beSDarrick J. Wong { 8700ba33facSTheodore Ts'o struct getfsmap_info info = { NULL }; 8710c9ec4beSDarrick J. Wong struct ext4_fsmap_head xhead = {0}; 8720c9ec4beSDarrick J. Wong struct fsmap_head head; 8730c9ec4beSDarrick J. Wong bool aborted = false; 8740c9ec4beSDarrick J. Wong int error; 8750c9ec4beSDarrick J. Wong 8760c9ec4beSDarrick J. Wong if (copy_from_user(&head, arg, sizeof(struct fsmap_head))) 8770c9ec4beSDarrick J. Wong return -EFAULT; 8780c9ec4beSDarrick J. Wong if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) || 8790c9ec4beSDarrick J. Wong memchr_inv(head.fmh_keys[0].fmr_reserved, 0, 8800c9ec4beSDarrick J. Wong sizeof(head.fmh_keys[0].fmr_reserved)) || 8810c9ec4beSDarrick J. Wong memchr_inv(head.fmh_keys[1].fmr_reserved, 0, 8820c9ec4beSDarrick J. Wong sizeof(head.fmh_keys[1].fmr_reserved))) 8830c9ec4beSDarrick J. Wong return -EINVAL; 8840c9ec4beSDarrick J. Wong /* 8850c9ec4beSDarrick J. Wong * ext4 doesn't report file extents at all, so the only valid 8860c9ec4beSDarrick J. Wong * file offsets are the magic ones (all zeroes or all ones). 8870c9ec4beSDarrick J. Wong */ 8880c9ec4beSDarrick J. Wong if (head.fmh_keys[0].fmr_offset || 8890c9ec4beSDarrick J. Wong (head.fmh_keys[1].fmr_offset != 0 && 8900c9ec4beSDarrick J. Wong head.fmh_keys[1].fmr_offset != -1ULL)) 8910c9ec4beSDarrick J. Wong return -EINVAL; 8920c9ec4beSDarrick J. Wong 8930c9ec4beSDarrick J. Wong xhead.fmh_iflags = head.fmh_iflags; 8940c9ec4beSDarrick J. Wong xhead.fmh_count = head.fmh_count; 8950c9ec4beSDarrick J. Wong ext4_fsmap_to_internal(sb, &xhead.fmh_keys[0], &head.fmh_keys[0]); 8960c9ec4beSDarrick J. Wong ext4_fsmap_to_internal(sb, &xhead.fmh_keys[1], &head.fmh_keys[1]); 8970c9ec4beSDarrick J. Wong 8980c9ec4beSDarrick J. Wong trace_ext4_getfsmap_low_key(sb, &xhead.fmh_keys[0]); 8990c9ec4beSDarrick J. Wong trace_ext4_getfsmap_high_key(sb, &xhead.fmh_keys[1]); 9000c9ec4beSDarrick J. Wong 9010c9ec4beSDarrick J. Wong info.gi_sb = sb; 9020c9ec4beSDarrick J. Wong info.gi_data = arg; 9030c9ec4beSDarrick J. Wong error = ext4_getfsmap(sb, &xhead, ext4_getfsmap_format, &info); 9041fc57ca5SJiapeng Chong if (error == EXT4_QUERY_RANGE_ABORT) 9050c9ec4beSDarrick J. Wong aborted = true; 9061fc57ca5SJiapeng Chong else if (error) 9070c9ec4beSDarrick J. Wong return error; 9080c9ec4beSDarrick J. Wong 9090c9ec4beSDarrick J. Wong /* If we didn't abort, set the "last" flag in the last fmx */ 9100c9ec4beSDarrick J. Wong if (!aborted && info.gi_idx) { 9110c9ec4beSDarrick J. Wong info.gi_last_flags |= FMR_OF_LAST; 9120c9ec4beSDarrick J. Wong if (copy_to_user(&info.gi_data->fmh_recs[info.gi_idx - 1].fmr_flags, 9130c9ec4beSDarrick J. Wong &info.gi_last_flags, 9140c9ec4beSDarrick J. Wong sizeof(info.gi_last_flags))) 9150c9ec4beSDarrick J. Wong return -EFAULT; 9160c9ec4beSDarrick J. Wong } 9170c9ec4beSDarrick J. Wong 9180c9ec4beSDarrick J. Wong /* copy back header */ 9190c9ec4beSDarrick J. Wong head.fmh_entries = xhead.fmh_entries; 9200c9ec4beSDarrick J. Wong head.fmh_oflags = xhead.fmh_oflags; 9210c9ec4beSDarrick J. Wong if (copy_to_user(arg, &head, sizeof(struct fsmap_head))) 9220c9ec4beSDarrick J. Wong return -EFAULT; 9230c9ec4beSDarrick J. Wong 9240c9ec4beSDarrick J. Wong return 0; 9250c9ec4beSDarrick J. Wong } 9260c9ec4beSDarrick J. Wong 927e145b35bSAl Viro static long ext4_ioctl_group_add(struct file *file, 928e145b35bSAl Viro struct ext4_new_group_data *input) 929e145b35bSAl Viro { 930e145b35bSAl Viro struct super_block *sb = file_inode(file)->i_sb; 931e145b35bSAl Viro int err, err2=0; 932e145b35bSAl Viro 933e145b35bSAl Viro err = ext4_resize_begin(sb); 934e145b35bSAl Viro if (err) 935e145b35bSAl Viro return err; 936e145b35bSAl Viro 9378813587aSTheodore Ts'o if (ext4_has_feature_bigalloc(sb)) { 9388813587aSTheodore Ts'o ext4_msg(sb, KERN_ERR, 9398813587aSTheodore Ts'o "Online resizing not supported with bigalloc"); 9408813587aSTheodore Ts'o err = -EOPNOTSUPP; 9418813587aSTheodore Ts'o goto group_add_out; 9428813587aSTheodore Ts'o } 9438813587aSTheodore Ts'o 944e145b35bSAl Viro err = mnt_want_write_file(file); 945e145b35bSAl Viro if (err) 946e145b35bSAl Viro goto group_add_out; 947e145b35bSAl Viro 948e145b35bSAl Viro err = ext4_group_add(sb, input); 949e145b35bSAl Viro if (EXT4_SB(sb)->s_journal) { 950e145b35bSAl Viro jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 95101d5d965SLeah Rumancik err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal, 0); 952e145b35bSAl Viro jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 953e145b35bSAl Viro } 954e145b35bSAl Viro if (err == 0) 955e145b35bSAl Viro err = err2; 956e145b35bSAl Viro mnt_drop_write_file(file); 957e145b35bSAl Viro if (!err && ext4_has_group_desc_csum(sb) && 958e145b35bSAl Viro test_opt(sb, INIT_INODE_TABLE)) 959e145b35bSAl Viro err = ext4_register_li_request(sb, input->group); 960e145b35bSAl Viro group_add_out: 961827891a3STheodore Ts'o err2 = ext4_resize_end(sb, false); 962827891a3STheodore Ts'o if (err == 0) 963827891a3STheodore Ts'o err = err2; 964e145b35bSAl Viro return err; 965e145b35bSAl Viro } 966e145b35bSAl Viro 9674db5c2e6SMiklos Szeredi int ext4_fileattr_get(struct dentry *dentry, struct fileattr *fa) 968dc7ac6c4SWang Shilong { 9694db5c2e6SMiklos Szeredi struct inode *inode = d_inode(dentry); 9707b0e492eSDarrick J. Wong struct ext4_inode_info *ei = EXT4_I(inode); 9714db5c2e6SMiklos Szeredi u32 flags = ei->i_flags & EXT4_FL_USER_VISIBLE; 972dc7ac6c4SWang Shilong 9734db5c2e6SMiklos Szeredi if (S_ISREG(inode->i_mode)) 9744db5c2e6SMiklos Szeredi flags &= ~FS_PROJINHERIT_FL; 975dc7ac6c4SWang Shilong 9764db5c2e6SMiklos Szeredi fileattr_fill_flags(fa, flags); 9777b0e492eSDarrick J. Wong if (ext4_has_feature_project(inode->i_sb)) 9787b0e492eSDarrick J. Wong fa->fsx_projid = from_kprojid(&init_user_ns, ei->i_projid); 9794db5c2e6SMiklos Szeredi 9804db5c2e6SMiklos Szeredi return 0; 9814db5c2e6SMiklos Szeredi } 9824db5c2e6SMiklos Szeredi 9838782a9aeSChristian Brauner int ext4_fileattr_set(struct mnt_idmap *idmap, 9844db5c2e6SMiklos Szeredi struct dentry *dentry, struct fileattr *fa) 9854db5c2e6SMiklos Szeredi { 9864db5c2e6SMiklos Szeredi struct inode *inode = d_inode(dentry); 9874db5c2e6SMiklos Szeredi u32 flags = fa->flags; 9884db5c2e6SMiklos Szeredi int err = -EOPNOTSUPP; 9894db5c2e6SMiklos Szeredi 9904db5c2e6SMiklos Szeredi if (flags & ~EXT4_FL_USER_VISIBLE) 9914db5c2e6SMiklos Szeredi goto out; 9924db5c2e6SMiklos Szeredi 9934db5c2e6SMiklos Szeredi /* 9944db5c2e6SMiklos Szeredi * chattr(1) grabs flags via GETFLAGS, modifies the result and 9954db5c2e6SMiklos Szeredi * passes that to SETFLAGS. So we cannot easily make SETFLAGS 9964db5c2e6SMiklos Szeredi * more restrictive than just silently masking off visible but 9974db5c2e6SMiklos Szeredi * not settable flags as we always did. 9984db5c2e6SMiklos Szeredi */ 9994db5c2e6SMiklos Szeredi flags &= EXT4_FL_USER_MODIFIABLE; 10004db5c2e6SMiklos Szeredi if (ext4_mask_flags(inode->i_mode, flags) != flags) 10014db5c2e6SMiklos Szeredi goto out; 10024db5c2e6SMiklos Szeredi err = ext4_ioctl_check_immutable(inode, fa->fsx_projid, flags); 10034db5c2e6SMiklos Szeredi if (err) 10044db5c2e6SMiklos Szeredi goto out; 10054db5c2e6SMiklos Szeredi err = ext4_ioctl_setflags(inode, flags); 10064db5c2e6SMiklos Szeredi if (err) 10074db5c2e6SMiklos Szeredi goto out; 10084db5c2e6SMiklos Szeredi err = ext4_ioctl_setproject(inode, fa->fsx_projid); 10094db5c2e6SMiklos Szeredi out: 10104db5c2e6SMiklos Szeredi return err; 1011dc7ac6c4SWang Shilong } 1012dc7ac6c4SWang Shilong 1013bb5835edSTheodore Ts'o /* So that the fiemap access checks can't overflow on 32 bit machines. */ 1014bb5835edSTheodore Ts'o #define FIEMAP_MAX_EXTENTS (UINT_MAX / sizeof(struct fiemap_extent)) 1015bb5835edSTheodore Ts'o 1016bb5835edSTheodore Ts'o static int ext4_ioctl_get_es_cache(struct file *filp, unsigned long arg) 1017bb5835edSTheodore Ts'o { 1018bb5835edSTheodore Ts'o struct fiemap fiemap; 1019bb5835edSTheodore Ts'o struct fiemap __user *ufiemap = (struct fiemap __user *) arg; 1020bb5835edSTheodore Ts'o struct fiemap_extent_info fieinfo = { 0, }; 1021bb5835edSTheodore Ts'o struct inode *inode = file_inode(filp); 1022bb5835edSTheodore Ts'o int error; 1023bb5835edSTheodore Ts'o 1024bb5835edSTheodore Ts'o if (copy_from_user(&fiemap, ufiemap, sizeof(fiemap))) 1025bb5835edSTheodore Ts'o return -EFAULT; 1026bb5835edSTheodore Ts'o 1027bb5835edSTheodore Ts'o if (fiemap.fm_extent_count > FIEMAP_MAX_EXTENTS) 1028bb5835edSTheodore Ts'o return -EINVAL; 1029bb5835edSTheodore Ts'o 1030bb5835edSTheodore Ts'o fieinfo.fi_flags = fiemap.fm_flags; 1031bb5835edSTheodore Ts'o fieinfo.fi_extents_max = fiemap.fm_extent_count; 1032bb5835edSTheodore Ts'o fieinfo.fi_extents_start = ufiemap->fm_extents; 1033bb5835edSTheodore Ts'o 1034328e24aeSChristoph Hellwig error = ext4_get_es_cache(inode, &fieinfo, fiemap.fm_start, 1035328e24aeSChristoph Hellwig fiemap.fm_length); 1036bb5835edSTheodore Ts'o fiemap.fm_flags = fieinfo.fi_flags; 1037bb5835edSTheodore Ts'o fiemap.fm_mapped_extents = fieinfo.fi_extents_mapped; 1038bb5835edSTheodore Ts'o if (copy_to_user(ufiemap, &fiemap, sizeof(fiemap))) 1039bb5835edSTheodore Ts'o error = -EFAULT; 1040bb5835edSTheodore Ts'o 1041bb5835edSTheodore Ts'o return error; 1042bb5835edSTheodore Ts'o } 1043bb5835edSTheodore Ts'o 1044351a0a3fSLeah Rumancik static int ext4_ioctl_checkpoint(struct file *filp, unsigned long arg) 1045351a0a3fSLeah Rumancik { 1046351a0a3fSLeah Rumancik int err = 0; 1047351a0a3fSLeah Rumancik __u32 flags = 0; 1048351a0a3fSLeah Rumancik unsigned int flush_flags = 0; 1049351a0a3fSLeah Rumancik struct super_block *sb = file_inode(filp)->i_sb; 1050351a0a3fSLeah Rumancik 1051351a0a3fSLeah Rumancik if (copy_from_user(&flags, (__u32 __user *)arg, 1052351a0a3fSLeah Rumancik sizeof(__u32))) 1053351a0a3fSLeah Rumancik return -EFAULT; 1054351a0a3fSLeah Rumancik 1055351a0a3fSLeah Rumancik if (!capable(CAP_SYS_ADMIN)) 1056351a0a3fSLeah Rumancik return -EPERM; 1057351a0a3fSLeah Rumancik 1058351a0a3fSLeah Rumancik /* check for invalid bits set */ 1059351a0a3fSLeah Rumancik if ((flags & ~EXT4_IOC_CHECKPOINT_FLAG_VALID) || 1060351a0a3fSLeah Rumancik ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && 1061351a0a3fSLeah Rumancik (flags & JBD2_JOURNAL_FLUSH_ZEROOUT))) 1062351a0a3fSLeah Rumancik return -EINVAL; 1063351a0a3fSLeah Rumancik 1064351a0a3fSLeah Rumancik if (!EXT4_SB(sb)->s_journal) 1065351a0a3fSLeah Rumancik return -ENODEV; 1066351a0a3fSLeah Rumancik 106770200574SChristoph Hellwig if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && 106870200574SChristoph Hellwig !bdev_max_discard_sectors(EXT4_SB(sb)->s_journal->j_dev)) 1069351a0a3fSLeah Rumancik return -EOPNOTSUPP; 1070351a0a3fSLeah Rumancik 1071351a0a3fSLeah Rumancik if (flags & EXT4_IOC_CHECKPOINT_FLAG_DRY_RUN) 1072351a0a3fSLeah Rumancik return 0; 1073351a0a3fSLeah Rumancik 1074351a0a3fSLeah Rumancik if (flags & EXT4_IOC_CHECKPOINT_FLAG_DISCARD) 1075351a0a3fSLeah Rumancik flush_flags |= JBD2_JOURNAL_FLUSH_DISCARD; 1076351a0a3fSLeah Rumancik 1077351a0a3fSLeah Rumancik if (flags & EXT4_IOC_CHECKPOINT_FLAG_ZEROOUT) { 1078351a0a3fSLeah Rumancik flush_flags |= JBD2_JOURNAL_FLUSH_ZEROOUT; 1079351a0a3fSLeah Rumancik pr_info_ratelimited("warning: checkpointing journal with EXT4_IOC_CHECKPOINT_FLAG_ZEROOUT can be slow"); 1080351a0a3fSLeah Rumancik } 1081351a0a3fSLeah Rumancik 1082351a0a3fSLeah Rumancik jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 1083351a0a3fSLeah Rumancik err = jbd2_journal_flush(EXT4_SB(sb)->s_journal, flush_flags); 1084351a0a3fSLeah Rumancik jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 1085351a0a3fSLeah Rumancik 1086351a0a3fSLeah Rumancik return err; 1087351a0a3fSLeah Rumancik } 1088351a0a3fSLeah Rumancik 1089bbc605cdSLukas Czerner static int ext4_ioctl_setlabel(struct file *filp, const char __user *user_label) 1090bbc605cdSLukas Czerner { 1091bbc605cdSLukas Czerner size_t len; 1092bbc605cdSLukas Czerner int ret = 0; 1093bbc605cdSLukas Czerner char new_label[EXT4_LABEL_MAX + 1]; 1094bbc605cdSLukas Czerner struct super_block *sb = file_inode(filp)->i_sb; 1095bbc605cdSLukas Czerner 1096bbc605cdSLukas Czerner if (!capable(CAP_SYS_ADMIN)) 1097bbc605cdSLukas Czerner return -EPERM; 1098bbc605cdSLukas Czerner 1099bbc605cdSLukas Czerner /* 1100bbc605cdSLukas Czerner * Copy the maximum length allowed for ext4 label with one more to 1101bbc605cdSLukas Czerner * find the required terminating null byte in order to test the 1102bbc605cdSLukas Czerner * label length. The on disk label doesn't need to be null terminated. 1103bbc605cdSLukas Czerner */ 1104bbc605cdSLukas Czerner if (copy_from_user(new_label, user_label, EXT4_LABEL_MAX + 1)) 1105bbc605cdSLukas Czerner return -EFAULT; 1106bbc605cdSLukas Czerner 1107bbc605cdSLukas Czerner len = strnlen(new_label, EXT4_LABEL_MAX + 1); 1108bbc605cdSLukas Czerner if (len > EXT4_LABEL_MAX) 1109bbc605cdSLukas Czerner return -EINVAL; 1110bbc605cdSLukas Czerner 1111bbc605cdSLukas Czerner /* 1112bbc605cdSLukas Czerner * Clear the buffer after the new label 1113bbc605cdSLukas Czerner */ 1114bbc605cdSLukas Czerner memset(new_label + len, 0, EXT4_LABEL_MAX - len); 1115bbc605cdSLukas Czerner 1116bbc605cdSLukas Czerner ret = mnt_want_write_file(filp); 1117bbc605cdSLukas Czerner if (ret) 1118bbc605cdSLukas Czerner return ret; 1119bbc605cdSLukas Czerner 1120bbc605cdSLukas Czerner ret = ext4_update_superblocks_fn(sb, ext4_sb_setlabel, new_label); 1121bbc605cdSLukas Czerner 1122bbc605cdSLukas Czerner mnt_drop_write_file(filp); 1123bbc605cdSLukas Czerner return ret; 1124bbc605cdSLukas Czerner } 1125bbc605cdSLukas Czerner 1126bbc605cdSLukas Czerner static int ext4_ioctl_getlabel(struct ext4_sb_info *sbi, char __user *user_label) 1127bbc605cdSLukas Czerner { 1128bbc605cdSLukas Czerner char label[EXT4_LABEL_MAX + 1]; 1129bbc605cdSLukas Czerner 1130bbc605cdSLukas Czerner /* 1131bbc605cdSLukas Czerner * EXT4_LABEL_MAX must always be smaller than FSLABEL_MAX because 1132bbc605cdSLukas Czerner * FSLABEL_MAX must include terminating null byte, while s_volume_name 1133bbc605cdSLukas Czerner * does not have to. 1134bbc605cdSLukas Czerner */ 1135bbc605cdSLukas Czerner BUILD_BUG_ON(EXT4_LABEL_MAX >= FSLABEL_MAX); 1136bbc605cdSLukas Czerner 1137bbc605cdSLukas Czerner memset(label, 0, sizeof(label)); 1138bbc605cdSLukas Czerner lock_buffer(sbi->s_sbh); 1139bbc605cdSLukas Czerner strncpy(label, sbi->s_es->s_volume_name, EXT4_LABEL_MAX); 1140bbc605cdSLukas Czerner unlock_buffer(sbi->s_sbh); 1141bbc605cdSLukas Czerner 1142bbc605cdSLukas Czerner if (copy_to_user(user_label, label, sizeof(label))) 1143bbc605cdSLukas Czerner return -EFAULT; 1144bbc605cdSLukas Czerner return 0; 1145bbc605cdSLukas Czerner } 1146bbc605cdSLukas Czerner 1147d95efb14SJeremy Bongio static int ext4_ioctl_getuuid(struct ext4_sb_info *sbi, 1148d95efb14SJeremy Bongio struct fsuuid __user *ufsuuid) 1149d95efb14SJeremy Bongio { 1150d95efb14SJeremy Bongio struct fsuuid fsuuid; 1151d95efb14SJeremy Bongio __u8 uuid[UUID_SIZE]; 1152d95efb14SJeremy Bongio 1153d95efb14SJeremy Bongio if (copy_from_user(&fsuuid, ufsuuid, sizeof(fsuuid))) 1154d95efb14SJeremy Bongio return -EFAULT; 1155d95efb14SJeremy Bongio 1156d95efb14SJeremy Bongio if (fsuuid.fsu_len == 0) { 1157d95efb14SJeremy Bongio fsuuid.fsu_len = UUID_SIZE; 1158b76abb51SDarrick J. Wong if (copy_to_user(&ufsuuid->fsu_len, &fsuuid.fsu_len, 1159b76abb51SDarrick J. Wong sizeof(fsuuid.fsu_len))) 1160d95efb14SJeremy Bongio return -EFAULT; 1161b76abb51SDarrick J. Wong return 0; 1162d95efb14SJeremy Bongio } 1163d95efb14SJeremy Bongio 1164a7e9d977SDarrick J. Wong if (fsuuid.fsu_len < UUID_SIZE || fsuuid.fsu_flags != 0) 1165d95efb14SJeremy Bongio return -EINVAL; 1166d95efb14SJeremy Bongio 1167d95efb14SJeremy Bongio lock_buffer(sbi->s_sbh); 1168d95efb14SJeremy Bongio memcpy(uuid, sbi->s_es->s_uuid, UUID_SIZE); 1169d95efb14SJeremy Bongio unlock_buffer(sbi->s_sbh); 1170d95efb14SJeremy Bongio 1171a7e9d977SDarrick J. Wong fsuuid.fsu_len = UUID_SIZE; 1172a7e9d977SDarrick J. Wong if (copy_to_user(ufsuuid, &fsuuid, sizeof(fsuuid)) || 1173a7e9d977SDarrick J. Wong copy_to_user(&ufsuuid->fsu_uuid[0], uuid, UUID_SIZE)) 1174d95efb14SJeremy Bongio return -EFAULT; 1175d95efb14SJeremy Bongio return 0; 1176d95efb14SJeremy Bongio } 1177d95efb14SJeremy Bongio 1178d95efb14SJeremy Bongio static int ext4_ioctl_setuuid(struct file *filp, 1179d95efb14SJeremy Bongio const struct fsuuid __user *ufsuuid) 1180d95efb14SJeremy Bongio { 1181d95efb14SJeremy Bongio int ret = 0; 1182d95efb14SJeremy Bongio struct super_block *sb = file_inode(filp)->i_sb; 1183d95efb14SJeremy Bongio struct fsuuid fsuuid; 1184d95efb14SJeremy Bongio __u8 uuid[UUID_SIZE]; 1185d95efb14SJeremy Bongio 1186d95efb14SJeremy Bongio if (!capable(CAP_SYS_ADMIN)) 1187d95efb14SJeremy Bongio return -EPERM; 1188d95efb14SJeremy Bongio 1189d95efb14SJeremy Bongio /* 1190d95efb14SJeremy Bongio * If any checksums (group descriptors or metadata) are being used 1191d95efb14SJeremy Bongio * then the checksum seed feature is required to change the UUID. 1192d95efb14SJeremy Bongio */ 1193d95efb14SJeremy Bongio if (((ext4_has_feature_gdt_csum(sb) || ext4_has_metadata_csum(sb)) 1194d95efb14SJeremy Bongio && !ext4_has_feature_csum_seed(sb)) 1195d95efb14SJeremy Bongio || ext4_has_feature_stable_inodes(sb)) 1196d95efb14SJeremy Bongio return -EOPNOTSUPP; 1197d95efb14SJeremy Bongio 1198d95efb14SJeremy Bongio if (copy_from_user(&fsuuid, ufsuuid, sizeof(fsuuid))) 1199d95efb14SJeremy Bongio return -EFAULT; 1200d95efb14SJeremy Bongio 1201d95efb14SJeremy Bongio if (fsuuid.fsu_len != UUID_SIZE || fsuuid.fsu_flags != 0) 1202d95efb14SJeremy Bongio return -EINVAL; 1203d95efb14SJeremy Bongio 1204d95efb14SJeremy Bongio if (copy_from_user(uuid, &ufsuuid->fsu_uuid[0], UUID_SIZE)) 1205d95efb14SJeremy Bongio return -EFAULT; 1206d95efb14SJeremy Bongio 1207d95efb14SJeremy Bongio ret = mnt_want_write_file(filp); 1208d95efb14SJeremy Bongio if (ret) 1209d95efb14SJeremy Bongio return ret; 1210d95efb14SJeremy Bongio 1211d95efb14SJeremy Bongio ret = ext4_update_superblocks_fn(sb, ext4_sb_setuuid, &uuid); 1212d95efb14SJeremy Bongio mnt_drop_write_file(filp); 1213d95efb14SJeremy Bongio 1214d95efb14SJeremy Bongio return ret; 1215d95efb14SJeremy Bongio } 1216d95efb14SJeremy Bongio 1217aa75f4d3SHarshad Shirwadkar static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 12189b7365fcSLi Xi { 12199b7365fcSLi Xi struct inode *inode = file_inode(filp); 12209b7365fcSLi Xi struct super_block *sb = inode->i_sb; 122101beba79SChristian Brauner struct mnt_idmap *idmap = file_mnt_idmap(filp); 12229b7365fcSLi Xi 12239b7365fcSLi Xi ext4_debug("cmd = %u, arg = %lu\n", cmd, arg); 12249b7365fcSLi Xi 12259b7365fcSLi Xi switch (cmd) { 12260c9ec4beSDarrick J. Wong case FS_IOC_GETFSMAP: 12270c9ec4beSDarrick J. Wong return ext4_ioc_getfsmap(sb, (void __user *)arg); 1228617ba13bSMingming Cao case EXT4_IOC_GETVERSION: 1229617ba13bSMingming Cao case EXT4_IOC_GETVERSION_OLD: 1230ac27a0ecSDave Kleikamp return put_user(inode->i_generation, (int __user *) arg); 1231617ba13bSMingming Cao case EXT4_IOC_SETVERSION: 1232617ba13bSMingming Cao case EXT4_IOC_SETVERSION_OLD: { 1233ac27a0ecSDave Kleikamp handle_t *handle; 1234617ba13bSMingming Cao struct ext4_iloc iloc; 1235ac27a0ecSDave Kleikamp __u32 generation; 1236ac27a0ecSDave Kleikamp int err; 1237ac27a0ecSDave Kleikamp 123801beba79SChristian Brauner if (!inode_owner_or_capable(idmap, inode)) 1239ac27a0ecSDave Kleikamp return -EPERM; 124042a74f20SDave Hansen 12419aa5d32bSDmitry Monakhov if (ext4_has_metadata_csum(inode->i_sb)) { 1242814525f4SDarrick J. Wong ext4_warning(sb, "Setting inode version is not " 1243814525f4SDarrick J. Wong "supported with metadata_csum enabled."); 1244814525f4SDarrick J. Wong return -ENOTTY; 1245814525f4SDarrick J. Wong } 1246814525f4SDarrick J. Wong 1247a561be71SAl Viro err = mnt_want_write_file(filp); 124842a74f20SDave Hansen if (err) 124942a74f20SDave Hansen return err; 125042a74f20SDave Hansen if (get_user(generation, (int __user *) arg)) { 125142a74f20SDave Hansen err = -EFAULT; 125242a74f20SDave Hansen goto setversion_out; 125342a74f20SDave Hansen } 1254ac27a0ecSDave Kleikamp 12555955102cSAl Viro inode_lock(inode); 12569924a92aSTheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 125742a74f20SDave Hansen if (IS_ERR(handle)) { 125842a74f20SDave Hansen err = PTR_ERR(handle); 12596c2155b9SDjalal Harouni goto unlock_out; 126042a74f20SDave Hansen } 1261617ba13bSMingming Cao err = ext4_reserve_inode_write(handle, inode, &iloc); 1262ac27a0ecSDave Kleikamp if (err == 0) { 1263eeca7ea1SDeepa Dinamani inode->i_ctime = current_time(inode); 1264a642c2c0SJeff Layton inode_inc_iversion(inode); 1265ac27a0ecSDave Kleikamp inode->i_generation = generation; 1266617ba13bSMingming Cao err = ext4_mark_iloc_dirty(handle, inode, &iloc); 1267ac27a0ecSDave Kleikamp } 1268617ba13bSMingming Cao ext4_journal_stop(handle); 12696c2155b9SDjalal Harouni 12706c2155b9SDjalal Harouni unlock_out: 12715955102cSAl Viro inode_unlock(inode); 127242a74f20SDave Hansen setversion_out: 12732a79f17eSAl Viro mnt_drop_write_file(filp); 1274ac27a0ecSDave Kleikamp return err; 1275ac27a0ecSDave Kleikamp } 1276617ba13bSMingming Cao case EXT4_IOC_GROUP_EXTEND: { 1277617ba13bSMingming Cao ext4_fsblk_t n_blocks_count; 1278ac046f1dSPeng Tao int err, err2=0; 1279ac27a0ecSDave Kleikamp 12808f82f840SYongqiang Yang err = ext4_resize_begin(sb); 12818f82f840SYongqiang Yang if (err) 12828f82f840SYongqiang Yang return err; 1283ac27a0ecSDave Kleikamp 1284014a1770SDjalal Harouni if (get_user(n_blocks_count, (__u32 __user *)arg)) { 1285014a1770SDjalal Harouni err = -EFAULT; 1286014a1770SDjalal Harouni goto group_extend_out; 1287014a1770SDjalal Harouni } 1288ac27a0ecSDave Kleikamp 12898813587aSTheodore Ts'o if (ext4_has_feature_bigalloc(sb)) { 12908813587aSTheodore Ts'o ext4_msg(sb, KERN_ERR, 12918813587aSTheodore Ts'o "Online resizing not supported with bigalloc"); 12928813587aSTheodore Ts'o err = -EOPNOTSUPP; 12938813587aSTheodore Ts'o goto group_extend_out; 12948813587aSTheodore Ts'o } 12958813587aSTheodore Ts'o 1296a561be71SAl Viro err = mnt_want_write_file(filp); 129742a74f20SDave Hansen if (err) 1298014a1770SDjalal Harouni goto group_extend_out; 129942a74f20SDave Hansen 1300617ba13bSMingming Cao err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count); 1301ac046f1dSPeng Tao if (EXT4_SB(sb)->s_journal) { 1302dab291afSMingming Cao jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 130301d5d965SLeah Rumancik err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal, 0); 1304dab291afSMingming Cao jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 1305ac046f1dSPeng Tao } 13067ffe1ea8SHidehiro Kawai if (err == 0) 13077ffe1ea8SHidehiro Kawai err = err2; 13082a79f17eSAl Viro mnt_drop_write_file(filp); 1309014a1770SDjalal Harouni group_extend_out: 1310827891a3STheodore Ts'o err2 = ext4_resize_end(sb, false); 1311827891a3STheodore Ts'o if (err == 0) 1312827891a3STheodore Ts'o err = err2; 1313ac27a0ecSDave Kleikamp return err; 1314ac27a0ecSDave Kleikamp } 1315748de673SAkira Fujita 1316748de673SAkira Fujita case EXT4_IOC_MOVE_EXT: { 1317748de673SAkira Fujita struct move_extent me; 13182903ff01SAl Viro struct fd donor; 13192903ff01SAl Viro int err; 1320748de673SAkira Fujita 13214a58579bSAkira Fujita if (!(filp->f_mode & FMODE_READ) || 13224a58579bSAkira Fujita !(filp->f_mode & FMODE_WRITE)) 13234a58579bSAkira Fujita return -EBADF; 13244a58579bSAkira Fujita 1325748de673SAkira Fujita if (copy_from_user(&me, 1326748de673SAkira Fujita (struct move_extent __user *)arg, sizeof(me))) 1327748de673SAkira Fujita return -EFAULT; 13284a58579bSAkira Fujita me.moved_len = 0; 1329748de673SAkira Fujita 13302903ff01SAl Viro donor = fdget(me.donor_fd); 13312903ff01SAl Viro if (!donor.file) 1332748de673SAkira Fujita return -EBADF; 1333748de673SAkira Fujita 13342903ff01SAl Viro if (!(donor.file->f_mode & FMODE_WRITE)) { 13354a58579bSAkira Fujita err = -EBADF; 13364a58579bSAkira Fujita goto mext_out; 1337748de673SAkira Fujita } 1338748de673SAkira Fujita 1339e2b911c5SDarrick J. Wong if (ext4_has_feature_bigalloc(sb)) { 1340bab08ab9STheodore Ts'o ext4_msg(sb, KERN_ERR, 1341bab08ab9STheodore Ts'o "Online defrag not supported with bigalloc"); 1342399c9b86SAl Viro err = -EOPNOTSUPP; 1343399c9b86SAl Viro goto mext_out; 134473f34a5eSRoss Zwisler } else if (IS_DAX(inode)) { 134573f34a5eSRoss Zwisler ext4_msg(sb, KERN_ERR, 134673f34a5eSRoss Zwisler "Online defrag not supported with DAX"); 134773f34a5eSRoss Zwisler err = -EOPNOTSUPP; 134873f34a5eSRoss Zwisler goto mext_out; 1349bab08ab9STheodore Ts'o } 1350bab08ab9STheodore Ts'o 1351a561be71SAl Viro err = mnt_want_write_file(filp); 13524a58579bSAkira Fujita if (err) 13534a58579bSAkira Fujita goto mext_out; 13544a58579bSAkira Fujita 13552903ff01SAl Viro err = ext4_move_extents(filp, donor.file, me.orig_start, 1356748de673SAkira Fujita me.donor_start, me.len, &me.moved_len); 13572a79f17eSAl Viro mnt_drop_write_file(filp); 1358748de673SAkira Fujita 1359c437b273SAkira Fujita if (copy_to_user((struct move_extent __user *)arg, 1360c437b273SAkira Fujita &me, sizeof(me))) 13614a58579bSAkira Fujita err = -EFAULT; 13624a58579bSAkira Fujita mext_out: 13632903ff01SAl Viro fdput(donor); 1364748de673SAkira Fujita return err; 1365748de673SAkira Fujita } 1366748de673SAkira Fujita 1367617ba13bSMingming Cao case EXT4_IOC_GROUP_ADD: { 1368617ba13bSMingming Cao struct ext4_new_group_data input; 1369ac27a0ecSDave Kleikamp 1370617ba13bSMingming Cao if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg, 1371e145b35bSAl Viro sizeof(input))) 1372e145b35bSAl Viro return -EFAULT; 1373ac27a0ecSDave Kleikamp 1374e145b35bSAl Viro return ext4_ioctl_group_add(filp, &input); 1375ac27a0ecSDave Kleikamp } 1376ac27a0ecSDave Kleikamp 1377c14c6fd5SAneesh Kumar K.V case EXT4_IOC_MIGRATE: 13782a43a878SAneesh Kumar K.V { 13792a43a878SAneesh Kumar K.V int err; 138001beba79SChristian Brauner if (!inode_owner_or_capable(idmap, inode)) 13812a43a878SAneesh Kumar K.V return -EACCES; 13822a43a878SAneesh Kumar K.V 1383a561be71SAl Viro err = mnt_want_write_file(filp); 13842a43a878SAneesh Kumar K.V if (err) 13852a43a878SAneesh Kumar K.V return err; 13862a43a878SAneesh Kumar K.V /* 13872a43a878SAneesh Kumar K.V * inode_mutex prevent write and truncate on the file. 13882a43a878SAneesh Kumar K.V * Read still goes through. We take i_data_sem in 13892a43a878SAneesh Kumar K.V * ext4_ext_swap_inode_data before we switch the 13902a43a878SAneesh Kumar K.V * inode format to prevent read. 13912a43a878SAneesh Kumar K.V */ 13925955102cSAl Viro inode_lock((inode)); 13932a43a878SAneesh Kumar K.V err = ext4_ext_migrate(inode); 13945955102cSAl Viro inode_unlock((inode)); 13952a79f17eSAl Viro mnt_drop_write_file(filp); 13962a43a878SAneesh Kumar K.V return err; 13972a43a878SAneesh Kumar K.V } 1398c14c6fd5SAneesh Kumar K.V 1399ccd2506bSTheodore Ts'o case EXT4_IOC_ALLOC_DA_BLKS: 1400ccd2506bSTheodore Ts'o { 1401ccd2506bSTheodore Ts'o int err; 140201beba79SChristian Brauner if (!inode_owner_or_capable(idmap, inode)) 1403ccd2506bSTheodore Ts'o return -EACCES; 1404ccd2506bSTheodore Ts'o 1405a561be71SAl Viro err = mnt_want_write_file(filp); 1406ccd2506bSTheodore Ts'o if (err) 1407ccd2506bSTheodore Ts'o return err; 1408ccd2506bSTheodore Ts'o err = ext4_alloc_da_blocks(inode); 14092a79f17eSAl Viro mnt_drop_write_file(filp); 1410ccd2506bSTheodore Ts'o return err; 1411ccd2506bSTheodore Ts'o } 1412ccd2506bSTheodore Ts'o 1413393d1d1dSDr. Tilmann Bubeck case EXT4_IOC_SWAP_BOOT: 14143e67cfadSDmitry Monakhov { 14153e67cfadSDmitry Monakhov int err; 1416393d1d1dSDr. Tilmann Bubeck if (!(filp->f_mode & FMODE_WRITE)) 1417393d1d1dSDr. Tilmann Bubeck return -EBADF; 14183e67cfadSDmitry Monakhov err = mnt_want_write_file(filp); 14193e67cfadSDmitry Monakhov if (err) 14203e67cfadSDmitry Monakhov return err; 142101beba79SChristian Brauner err = swap_inode_boot_loader(sb, idmap, inode); 14223e67cfadSDmitry Monakhov mnt_drop_write_file(filp); 14233e67cfadSDmitry Monakhov return err; 14243e67cfadSDmitry Monakhov } 1425393d1d1dSDr. Tilmann Bubeck 142619c5246dSYongqiang Yang case EXT4_IOC_RESIZE_FS: { 142719c5246dSYongqiang Yang ext4_fsblk_t n_blocks_count; 142819c5246dSYongqiang Yang int err = 0, err2 = 0; 14297f511862STheodore Ts'o ext4_group_t o_group = EXT4_SB(sb)->s_groups_count; 143019c5246dSYongqiang Yang 143119c5246dSYongqiang Yang if (copy_from_user(&n_blocks_count, (__u64 __user *)arg, 143219c5246dSYongqiang Yang sizeof(__u64))) { 143319c5246dSYongqiang Yang return -EFAULT; 143419c5246dSYongqiang Yang } 143519c5246dSYongqiang Yang 143619c5246dSYongqiang Yang err = ext4_resize_begin(sb); 143719c5246dSYongqiang Yang if (err) 143819c5246dSYongqiang Yang return err; 143919c5246dSYongqiang Yang 14408cae6f71SAl Viro err = mnt_want_write_file(filp); 144119c5246dSYongqiang Yang if (err) 144219c5246dSYongqiang Yang goto resizefs_out; 144319c5246dSYongqiang Yang 144419c5246dSYongqiang Yang err = ext4_resize_fs(sb, n_blocks_count); 144519c5246dSYongqiang Yang if (EXT4_SB(sb)->s_journal) { 1446e85c81baSXin Yin ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_RESIZE, NULL); 144719c5246dSYongqiang Yang jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 144801d5d965SLeah Rumancik err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal, 0); 144919c5246dSYongqiang Yang jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 145019c5246dSYongqiang Yang } 145119c5246dSYongqiang Yang if (err == 0) 145219c5246dSYongqiang Yang err = err2; 14538cae6f71SAl Viro mnt_drop_write_file(filp); 1454310a997fSKirill Tkhai if (!err && (o_group < EXT4_SB(sb)->s_groups_count) && 14557f511862STheodore Ts'o ext4_has_group_desc_csum(sb) && 14567f511862STheodore Ts'o test_opt(sb, INIT_INODE_TABLE)) 14577f511862STheodore Ts'o err = ext4_register_li_request(sb, o_group); 14587f511862STheodore Ts'o 145919c5246dSYongqiang Yang resizefs_out: 1460827891a3STheodore Ts'o err2 = ext4_resize_end(sb, true); 1461827891a3STheodore Ts'o if (err == 0) 1462827891a3STheodore Ts'o err = err2; 146319c5246dSYongqiang Yang return err; 146419c5246dSYongqiang Yang } 146519c5246dSYongqiang Yang 1466e681c047SLukas Czerner case FITRIM: 1467e681c047SLukas Czerner { 1468e681c047SLukas Czerner struct fstrim_range range; 1469e681c047SLukas Czerner int ret = 0; 1470e681c047SLukas Czerner 1471e681c047SLukas Czerner if (!capable(CAP_SYS_ADMIN)) 1472e681c047SLukas Czerner return -EPERM; 1473e681c047SLukas Czerner 147470200574SChristoph Hellwig if (!bdev_max_discard_sectors(sb->s_bdev)) 147541431792SLukas Czerner return -EOPNOTSUPP; 147641431792SLukas Czerner 147718915b58SDarrick J. Wong /* 147818915b58SDarrick J. Wong * We haven't replayed the journal, so we cannot use our 147918915b58SDarrick J. Wong * block-bitmap-guided storage zapping commands. 148018915b58SDarrick J. Wong */ 148118915b58SDarrick J. Wong if (test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb)) 148218915b58SDarrick J. Wong return -EROFS; 148318915b58SDarrick J. Wong 1484e6705f7cSH Hartley Sweeten if (copy_from_user(&range, (struct fstrim_range __user *)arg, 1485e681c047SLukas Czerner sizeof(range))) 1486e681c047SLukas Czerner return -EFAULT; 1487e681c047SLukas Czerner 1488e681c047SLukas Czerner ret = ext4_trim_fs(sb, &range); 1489e681c047SLukas Czerner if (ret < 0) 1490e681c047SLukas Czerner return ret; 1491e681c047SLukas Czerner 1492e6705f7cSH Hartley Sweeten if (copy_to_user((struct fstrim_range __user *)arg, &range, 1493e681c047SLukas Czerner sizeof(range))) 1494e681c047SLukas Czerner return -EFAULT; 1495e681c047SLukas Czerner 1496e681c047SLukas Czerner return 0; 1497e681c047SLukas Czerner } 14987869a4a6STheodore Ts'o case EXT4_IOC_PRECACHE_EXTENTS: 14997869a4a6STheodore Ts'o return ext4_ext_precache(inode); 1500e681c047SLukas Czerner 1501cb29a02dSEric Biggers case FS_IOC_SET_ENCRYPTION_POLICY: 15029a200d07SRichard Weinberger if (!ext4_has_feature_encrypt(sb)) 15039a200d07SRichard Weinberger return -EOPNOTSUPP; 1504db717d8eSEric Biggers return fscrypt_ioctl_set_policy(filp, (const void __user *)arg); 15059a200d07SRichard Weinberger 150672f63f4aSRitesh Harjani case FS_IOC_GET_ENCRYPTION_PWSALT: 150772f63f4aSRitesh Harjani return ext4_ioctl_get_encryption_pwsalt(filp, (void __user *)arg); 15089bd8212fSMichael Halcrow 1509cb29a02dSEric Biggers case FS_IOC_GET_ENCRYPTION_POLICY: 15100642ea24SChao Yu if (!ext4_has_feature_encrypt(sb)) 15110642ea24SChao Yu return -EOPNOTSUPP; 1512db717d8eSEric Biggers return fscrypt_ioctl_get_policy(filp, (void __user *)arg); 15139bd8212fSMichael Halcrow 151429b3692eSEric Biggers case FS_IOC_GET_ENCRYPTION_POLICY_EX: 151529b3692eSEric Biggers if (!ext4_has_feature_encrypt(sb)) 151629b3692eSEric Biggers return -EOPNOTSUPP; 151729b3692eSEric Biggers return fscrypt_ioctl_get_policy_ex(filp, (void __user *)arg); 151829b3692eSEric Biggers 151929b3692eSEric Biggers case FS_IOC_ADD_ENCRYPTION_KEY: 152029b3692eSEric Biggers if (!ext4_has_feature_encrypt(sb)) 152129b3692eSEric Biggers return -EOPNOTSUPP; 152229b3692eSEric Biggers return fscrypt_ioctl_add_key(filp, (void __user *)arg); 152329b3692eSEric Biggers 152429b3692eSEric Biggers case FS_IOC_REMOVE_ENCRYPTION_KEY: 152529b3692eSEric Biggers if (!ext4_has_feature_encrypt(sb)) 152629b3692eSEric Biggers return -EOPNOTSUPP; 152729b3692eSEric Biggers return fscrypt_ioctl_remove_key(filp, (void __user *)arg); 152829b3692eSEric Biggers 152929b3692eSEric Biggers case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS: 153029b3692eSEric Biggers if (!ext4_has_feature_encrypt(sb)) 153129b3692eSEric Biggers return -EOPNOTSUPP; 153229b3692eSEric Biggers return fscrypt_ioctl_remove_key_all_users(filp, 153329b3692eSEric Biggers (void __user *)arg); 153429b3692eSEric Biggers case FS_IOC_GET_ENCRYPTION_KEY_STATUS: 153529b3692eSEric Biggers if (!ext4_has_feature_encrypt(sb)) 153629b3692eSEric Biggers return -EOPNOTSUPP; 153729b3692eSEric Biggers return fscrypt_ioctl_get_key_status(filp, (void __user *)arg); 153829b3692eSEric Biggers 15397ec9f3b4SEric Biggers case FS_IOC_GET_ENCRYPTION_NONCE: 15407ec9f3b4SEric Biggers if (!ext4_has_feature_encrypt(sb)) 15417ec9f3b4SEric Biggers return -EOPNOTSUPP; 15427ec9f3b4SEric Biggers return fscrypt_ioctl_get_nonce(filp, (void __user *)arg); 15437ec9f3b4SEric Biggers 1544b0c013e2STheodore Ts'o case EXT4_IOC_CLEAR_ES_CACHE: 1545b0c013e2STheodore Ts'o { 154601beba79SChristian Brauner if (!inode_owner_or_capable(idmap, inode)) 1547b0c013e2STheodore Ts'o return -EACCES; 1548b0c013e2STheodore Ts'o ext4_clear_inode_es(inode); 1549b0c013e2STheodore Ts'o return 0; 1550b0c013e2STheodore Ts'o } 1551b0c013e2STheodore Ts'o 15521ad3ea6eSTheodore Ts'o case EXT4_IOC_GETSTATE: 15531ad3ea6eSTheodore Ts'o { 15541ad3ea6eSTheodore Ts'o __u32 state = 0; 15551ad3ea6eSTheodore Ts'o 15561ad3ea6eSTheodore Ts'o if (ext4_test_inode_state(inode, EXT4_STATE_EXT_PRECACHED)) 15571ad3ea6eSTheodore Ts'o state |= EXT4_STATE_FLAG_EXT_PRECACHED; 15581ad3ea6eSTheodore Ts'o if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) 15591ad3ea6eSTheodore Ts'o state |= EXT4_STATE_FLAG_NEW; 15601ad3ea6eSTheodore Ts'o if (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) 15611ad3ea6eSTheodore Ts'o state |= EXT4_STATE_FLAG_NEWENTRY; 15621ad3ea6eSTheodore Ts'o if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) 15631ad3ea6eSTheodore Ts'o state |= EXT4_STATE_FLAG_DA_ALLOC_CLOSE; 15641ad3ea6eSTheodore Ts'o 15651ad3ea6eSTheodore Ts'o return put_user(state, (__u32 __user *) arg); 15661ad3ea6eSTheodore Ts'o } 15671ad3ea6eSTheodore Ts'o 1568bb5835edSTheodore Ts'o case EXT4_IOC_GET_ES_CACHE: 1569bb5835edSTheodore Ts'o return ext4_ioctl_get_es_cache(filp, arg); 1570bb5835edSTheodore Ts'o 1571e9be2ac7STheodore Ts'o case EXT4_IOC_SHUTDOWN: 1572e9be2ac7STheodore Ts'o return ext4_shutdown(sb, arg); 1573c93d8f88SEric Biggers 1574c93d8f88SEric Biggers case FS_IOC_ENABLE_VERITY: 1575c93d8f88SEric Biggers if (!ext4_has_feature_verity(sb)) 1576c93d8f88SEric Biggers return -EOPNOTSUPP; 1577c93d8f88SEric Biggers return fsverity_ioctl_enable(filp, (const void __user *)arg); 1578c93d8f88SEric Biggers 1579c93d8f88SEric Biggers case FS_IOC_MEASURE_VERITY: 1580c93d8f88SEric Biggers if (!ext4_has_feature_verity(sb)) 1581c93d8f88SEric Biggers return -EOPNOTSUPP; 1582c93d8f88SEric Biggers return fsverity_ioctl_measure(filp, (void __user *)arg); 1583c93d8f88SEric Biggers 1584e17fe657SEric Biggers case FS_IOC_READ_VERITY_METADATA: 1585e17fe657SEric Biggers if (!ext4_has_feature_verity(sb)) 1586e17fe657SEric Biggers return -EOPNOTSUPP; 1587e17fe657SEric Biggers return fsverity_ioctl_read_metadata(filp, 1588e17fe657SEric Biggers (const void __user *)arg); 1589e17fe657SEric Biggers 1590351a0a3fSLeah Rumancik case EXT4_IOC_CHECKPOINT: 1591351a0a3fSLeah Rumancik return ext4_ioctl_checkpoint(filp, arg); 1592351a0a3fSLeah Rumancik 1593bbc605cdSLukas Czerner case FS_IOC_GETFSLABEL: 1594bbc605cdSLukas Czerner return ext4_ioctl_getlabel(EXT4_SB(sb), (void __user *)arg); 1595bbc605cdSLukas Czerner 1596bbc605cdSLukas Czerner case FS_IOC_SETFSLABEL: 1597bbc605cdSLukas Czerner return ext4_ioctl_setlabel(filp, 1598bbc605cdSLukas Czerner (const void __user *)arg); 1599bbc605cdSLukas Czerner 1600d95efb14SJeremy Bongio case EXT4_IOC_GETFSUUID: 1601d95efb14SJeremy Bongio return ext4_ioctl_getuuid(EXT4_SB(sb), (void __user *)arg); 1602d95efb14SJeremy Bongio case EXT4_IOC_SETFSUUID: 1603d95efb14SJeremy Bongio return ext4_ioctl_setuuid(filp, (const void __user *)arg); 1604ac27a0ecSDave Kleikamp default: 1605ac27a0ecSDave Kleikamp return -ENOTTY; 1606ac27a0ecSDave Kleikamp } 1607ac27a0ecSDave Kleikamp } 1608ac27a0ecSDave Kleikamp 1609aa75f4d3SHarshad Shirwadkar long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 1610aa75f4d3SHarshad Shirwadkar { 16112729cfdcSHarshad Shirwadkar return __ext4_ioctl(filp, cmd, arg); 1612aa75f4d3SHarshad Shirwadkar } 1613aa75f4d3SHarshad Shirwadkar 1614ac27a0ecSDave Kleikamp #ifdef CONFIG_COMPAT 1615617ba13bSMingming Cao long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 1616ac27a0ecSDave Kleikamp { 1617ac27a0ecSDave Kleikamp /* These are just misnamed, they actually get/put from/to user an int */ 1618ac27a0ecSDave Kleikamp switch (cmd) { 1619617ba13bSMingming Cao case EXT4_IOC32_GETVERSION: 1620617ba13bSMingming Cao cmd = EXT4_IOC_GETVERSION; 1621ac27a0ecSDave Kleikamp break; 1622617ba13bSMingming Cao case EXT4_IOC32_SETVERSION: 1623617ba13bSMingming Cao cmd = EXT4_IOC_SETVERSION; 1624ac27a0ecSDave Kleikamp break; 1625617ba13bSMingming Cao case EXT4_IOC32_GROUP_EXTEND: 1626617ba13bSMingming Cao cmd = EXT4_IOC_GROUP_EXTEND; 1627ac27a0ecSDave Kleikamp break; 1628617ba13bSMingming Cao case EXT4_IOC32_GETVERSION_OLD: 1629617ba13bSMingming Cao cmd = EXT4_IOC_GETVERSION_OLD; 1630ac27a0ecSDave Kleikamp break; 1631617ba13bSMingming Cao case EXT4_IOC32_SETVERSION_OLD: 1632617ba13bSMingming Cao cmd = EXT4_IOC_SETVERSION_OLD; 1633ac27a0ecSDave Kleikamp break; 1634617ba13bSMingming Cao case EXT4_IOC32_GETRSVSZ: 1635617ba13bSMingming Cao cmd = EXT4_IOC_GETRSVSZ; 1636ac27a0ecSDave Kleikamp break; 1637617ba13bSMingming Cao case EXT4_IOC32_SETRSVSZ: 1638617ba13bSMingming Cao cmd = EXT4_IOC_SETRSVSZ; 1639ac27a0ecSDave Kleikamp break; 16404d92dc0fSBen Hutchings case EXT4_IOC32_GROUP_ADD: { 16414d92dc0fSBen Hutchings struct compat_ext4_new_group_input __user *uinput; 1642e145b35bSAl Viro struct ext4_new_group_data input; 16434d92dc0fSBen Hutchings int err; 16444d92dc0fSBen Hutchings 16454d92dc0fSBen Hutchings uinput = compat_ptr(arg); 16464d92dc0fSBen Hutchings err = get_user(input.group, &uinput->group); 16474d92dc0fSBen Hutchings err |= get_user(input.block_bitmap, &uinput->block_bitmap); 16484d92dc0fSBen Hutchings err |= get_user(input.inode_bitmap, &uinput->inode_bitmap); 16494d92dc0fSBen Hutchings err |= get_user(input.inode_table, &uinput->inode_table); 16504d92dc0fSBen Hutchings err |= get_user(input.blocks_count, &uinput->blocks_count); 16514d92dc0fSBen Hutchings err |= get_user(input.reserved_blocks, 16524d92dc0fSBen Hutchings &uinput->reserved_blocks); 16534d92dc0fSBen Hutchings if (err) 16544d92dc0fSBen Hutchings return -EFAULT; 1655e145b35bSAl Viro return ext4_ioctl_group_add(file, &input); 16564d92dc0fSBen Hutchings } 1657b684b2eeSChristian Borntraeger case EXT4_IOC_MOVE_EXT: 165819c5246dSYongqiang Yang case EXT4_IOC_RESIZE_FS: 1659314999dcSArnd Bergmann case FITRIM: 16607869a4a6STheodore Ts'o case EXT4_IOC_PRECACHE_EXTENTS: 1661cb29a02dSEric Biggers case FS_IOC_SET_ENCRYPTION_POLICY: 1662cb29a02dSEric Biggers case FS_IOC_GET_ENCRYPTION_PWSALT: 1663cb29a02dSEric Biggers case FS_IOC_GET_ENCRYPTION_POLICY: 166429b3692eSEric Biggers case FS_IOC_GET_ENCRYPTION_POLICY_EX: 166529b3692eSEric Biggers case FS_IOC_ADD_ENCRYPTION_KEY: 166629b3692eSEric Biggers case FS_IOC_REMOVE_ENCRYPTION_KEY: 166729b3692eSEric Biggers case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS: 166829b3692eSEric Biggers case FS_IOC_GET_ENCRYPTION_KEY_STATUS: 16697ec9f3b4SEric Biggers case FS_IOC_GET_ENCRYPTION_NONCE: 1670e9be2ac7STheodore Ts'o case EXT4_IOC_SHUTDOWN: 16710c9ec4beSDarrick J. Wong case FS_IOC_GETFSMAP: 1672c93d8f88SEric Biggers case FS_IOC_ENABLE_VERITY: 1673c93d8f88SEric Biggers case FS_IOC_MEASURE_VERITY: 1674e17fe657SEric Biggers case FS_IOC_READ_VERITY_METADATA: 1675b0c013e2STheodore Ts'o case EXT4_IOC_CLEAR_ES_CACHE: 16761ad3ea6eSTheodore Ts'o case EXT4_IOC_GETSTATE: 1677bb5835edSTheodore Ts'o case EXT4_IOC_GET_ES_CACHE: 1678351a0a3fSLeah Rumancik case EXT4_IOC_CHECKPOINT: 1679bbc605cdSLukas Czerner case FS_IOC_GETFSLABEL: 1680bbc605cdSLukas Czerner case FS_IOC_SETFSLABEL: 1681d95efb14SJeremy Bongio case EXT4_IOC_GETFSUUID: 1682d95efb14SJeremy Bongio case EXT4_IOC_SETFSUUID: 1683b684b2eeSChristian Borntraeger break; 1684ac27a0ecSDave Kleikamp default: 1685ac27a0ecSDave Kleikamp return -ENOIOCTLCMD; 1686ac27a0ecSDave Kleikamp } 16875cdd7b2dSAndi Kleen return ext4_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); 1688ac27a0ecSDave Kleikamp } 1689ac27a0ecSDave Kleikamp #endif 1690eb705421STheodore Ts'o 1691eb705421STheodore Ts'o static void set_overhead(struct ext4_super_block *es, const void *arg) 1692eb705421STheodore Ts'o { 1693eb705421STheodore Ts'o es->s_overhead_clusters = cpu_to_le32(*((unsigned long *) arg)); 1694eb705421STheodore Ts'o } 1695eb705421STheodore Ts'o 1696827891a3STheodore Ts'o int ext4_update_overhead(struct super_block *sb, bool force) 1697eb705421STheodore Ts'o { 1698eb705421STheodore Ts'o struct ext4_sb_info *sbi = EXT4_SB(sb); 1699eb705421STheodore Ts'o 1700827891a3STheodore Ts'o if (sb_rdonly(sb)) 1701eb705421STheodore Ts'o return 0; 1702827891a3STheodore Ts'o if (!force && 1703827891a3STheodore Ts'o (sbi->s_overhead == 0 || 1704827891a3STheodore Ts'o sbi->s_overhead == le32_to_cpu(sbi->s_es->s_overhead_clusters))) 1705827891a3STheodore Ts'o return 0; 1706eb705421STheodore Ts'o return ext4_update_superblocks_fn(sb, set_overhead, &sbi->s_overhead); 1707eb705421STheodore Ts'o } 1708