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 */
ext4_sb_setlabel(struct ext4_super_block * es,const void * arg)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 */
ext4_sb_setuuid(struct ext4_super_block * es,const void * arg)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
ext4_update_primary_sb(struct super_block * sb,handle_t * handle,ext4_update_sb_callback func,const void * arg)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 */
ext4_update_backup_sb(struct super_block * sb,handle_t * handle,ext4_group_t grp,ext4_update_sb_callback func,const void * arg)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
ext4_update_superblocks_fn(struct super_block * sb,ext4_update_sb_callback func,const void * arg)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 */
memswap(void * a,void * b,size_t len)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 */
swap_inode_data(struct inode * inode1,struct inode * inode2)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
ext4_reset_inode_seed(struct inode * inode)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 */
swap_inode_boot_loader(struct super_block * sb,struct mnt_idmap * idmap,struct inode * inode)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_set_ctime_current(inode);
453a642c2c0SJeff Layton inode_set_ctime_current(inode_bl);
454393d1d1dSDr. Tilmann Bubeck inode_inc_iversion(inode);
455a251c17aSJason A. Donenfeld
456a251c17aSJason A. Donenfeld inode->i_generation = get_random_u32();
4578016e29fSHarshad Shirwadkar inode_bl->i_generation = get_random_u32();
4588016e29fSHarshad Shirwadkar ext4_reset_inode_seed(inode);
459393d1d1dSDr. Tilmann Bubeck ext4_reset_inode_seed(inode_bl);
46027bc446eSbrookxu
461393d1d1dSDr. Tilmann Bubeck ext4_discard_preallocations(inode, 0);
462393d1d1dSDr. Tilmann Bubeck
463393d1d1dSDr. Tilmann Bubeck err = ext4_mark_inode_dirty(handle, inode);
464aa507b5fSyangerkun if (err < 0) {
465393d1d1dSDr. Tilmann Bubeck /* No need to update quota information. */
466393d1d1dSDr. Tilmann Bubeck ext4_warning(inode->i_sb,
467393d1d1dSDr. Tilmann Bubeck "couldn't mark inode #%lu dirty (err %d)",
468393d1d1dSDr. Tilmann Bubeck inode->i_ino, err);
469393d1d1dSDr. Tilmann Bubeck /* Revert all changes: */
47018aded17STheodore Ts'o swap_inode_data(inode, inode_bl);
471aa507b5fSyangerkun ext4_mark_inode_dirty(handle, inode);
472aa507b5fSyangerkun goto err_out1;
473aa507b5fSyangerkun }
474aa507b5fSyangerkun
475aa507b5fSyangerkun blocks = inode_bl->i_blocks;
476aa507b5fSyangerkun bytes = inode_bl->i_bytes;
477aa507b5fSyangerkun inode_bl->i_blocks = inode->i_blocks;
478393d1d1dSDr. Tilmann Bubeck inode_bl->i_bytes = inode->i_bytes;
479393d1d1dSDr. Tilmann Bubeck err = ext4_mark_inode_dirty(handle, inode_bl);
480aa507b5fSyangerkun if (err < 0) {
481393d1d1dSDr. Tilmann Bubeck /* No need to update quota information. */
482393d1d1dSDr. Tilmann Bubeck ext4_warning(inode_bl->i_sb,
483393d1d1dSDr. Tilmann Bubeck "couldn't mark inode #%lu dirty (err %d)",
484aa507b5fSyangerkun inode_bl->i_ino, err);
485aa507b5fSyangerkun goto revert;
486aa507b5fSyangerkun }
487aa507b5fSyangerkun
488aa507b5fSyangerkun /* Bootloader inode should not be counted into quota information. */
489aa507b5fSyangerkun if (diff > 0)
490aa507b5fSyangerkun dquot_free_space(inode, diff);
491aa507b5fSyangerkun else
492aa507b5fSyangerkun err = dquot_alloc_space(inode, -1 * diff);
493aa507b5fSyangerkun
494aa507b5fSyangerkun if (err < 0) {
495393d1d1dSDr. Tilmann Bubeck revert:
496aa507b5fSyangerkun /* Revert all changes: */
497aa507b5fSyangerkun inode_bl->i_blocks = blocks;
498393d1d1dSDr. Tilmann Bubeck inode_bl->i_bytes = bytes;
499393d1d1dSDr. Tilmann Bubeck swap_inode_data(inode, inode_bl);
50018aded17STheodore Ts'o ext4_mark_inode_dirty(handle, inode);
501393d1d1dSDr. Tilmann Bubeck ext4_mark_inode_dirty(handle, inode_bl);
502aa507b5fSyangerkun }
503aa507b5fSyangerkun
504393d1d1dSDr. Tilmann Bubeck err_out1:
505393d1d1dSDr. Tilmann Bubeck ext4_journal_stop(handle);
506393d1d1dSDr. Tilmann Bubeck ext4_double_up_write_data_sem(inode, inode_bl);
507a46c68a3Syangerkun
508d4f5258eSJan Kara err_out:
50930d29b11SZheng Liu filemap_invalidate_unlock(inode->i_mapping);
510375e289eSJ. Bruce Fields journal_err_out:
511393d1d1dSDr. Tilmann Bubeck unlock_two_nondirectories(inode, inode_bl);
512393d1d1dSDr. Tilmann Bubeck iput(inode_bl);
513393d1d1dSDr. Tilmann Bubeck return err;
514393d1d1dSDr. Tilmann Bubeck }
5152e538403SDarrick J. Wong
5162e538403SDarrick J. Wong /*
5172e538403SDarrick J. Wong * If immutable is set and we are not clearing it, we're not allowed to change
5182e538403SDarrick J. Wong * anything else in the inode. Don't error out if we're only trying to set
5192e538403SDarrick J. Wong * immutable on an immutable file.
5202e538403SDarrick J. Wong */
ext4_ioctl_check_immutable(struct inode * inode,__u32 new_projid,unsigned int flags)5212e538403SDarrick J. Wong static int ext4_ioctl_check_immutable(struct inode *inode, __u32 new_projid,
5222e538403SDarrick J. Wong unsigned int flags)
5232e538403SDarrick J. Wong {
5242e538403SDarrick J. Wong struct ext4_inode_info *ei = EXT4_I(inode);
5252e538403SDarrick J. Wong unsigned int oldflags = ei->i_flags;
5262e538403SDarrick J. Wong
5272e538403SDarrick J. Wong if (!(oldflags & EXT4_IMMUTABLE_FL) || !(flags & EXT4_IMMUTABLE_FL))
5282e538403SDarrick J. Wong return 0;
5292e538403SDarrick J. Wong
5302e538403SDarrick J. Wong if ((oldflags & ~EXT4_IMMUTABLE_FL) != (flags & ~EXT4_IMMUTABLE_FL))
5312e538403SDarrick J. Wong return -EPERM;
5322e538403SDarrick J. Wong if (ext4_has_feature_project(inode->i_sb) &&
5332e538403SDarrick J. Wong __kprojid_val(ei->i_projid) != new_projid)
5342e538403SDarrick J. Wong return -EPERM;
5352e538403SDarrick J. Wong
5362e538403SDarrick J. Wong return 0;
5372e538403SDarrick J. Wong }
538b383a73fSIra Weiny
ext4_dax_dontcache(struct inode * inode,unsigned int flags)539b383a73fSIra Weiny static void ext4_dax_dontcache(struct inode *inode, unsigned int flags)
540b383a73fSIra Weiny {
541b383a73fSIra Weiny struct ext4_inode_info *ei = EXT4_I(inode);
542b383a73fSIra Weiny
543b383a73fSIra Weiny if (S_ISDIR(inode->i_mode))
544b383a73fSIra Weiny return;
545b383a73fSIra Weiny
546b383a73fSIra Weiny if (test_opt2(inode->i_sb, DAX_NEVER) ||
547b383a73fSIra Weiny test_opt(inode->i_sb, DAX_ALWAYS))
548b383a73fSIra Weiny return;
549b383a73fSIra Weiny
550b383a73fSIra Weiny if ((ei->i_flags ^ flags) & EXT4_DAX_FL)
551b383a73fSIra Weiny d_mark_dontcache(inode);
552b383a73fSIra Weiny }
553b383a73fSIra Weiny
dax_compatible(struct inode * inode,unsigned int oldflags,unsigned int flags)554b383a73fSIra Weiny static bool dax_compatible(struct inode *inode, unsigned int oldflags,
555b383a73fSIra Weiny unsigned int flags)
5564811d992STheodore Ts'o {
5574811d992STheodore Ts'o /* Allow the DAX flag to be changed on inline directories */
5584811d992STheodore Ts'o if (S_ISDIR(inode->i_mode)) {
5594811d992STheodore Ts'o flags &= ~EXT4_INLINE_DATA_FL;
5604811d992STheodore Ts'o oldflags &= ~EXT4_INLINE_DATA_FL;
5614811d992STheodore Ts'o }
562b383a73fSIra Weiny
563b383a73fSIra Weiny if (flags & EXT4_DAX_FL) {
564b383a73fSIra Weiny if ((oldflags & EXT4_DAX_MUT_EXCL) ||
565b383a73fSIra Weiny ext4_test_inode_state(inode,
566b383a73fSIra Weiny EXT4_STATE_VERITY_IN_PROGRESS)) {
567b383a73fSIra Weiny return false;
568b383a73fSIra Weiny }
569b383a73fSIra Weiny }
570b383a73fSIra Weiny
571b383a73fSIra Weiny if ((flags & EXT4_DAX_MUT_EXCL) && (oldflags & EXT4_DAX_FL))
572b383a73fSIra Weiny return false;
573b383a73fSIra Weiny
574b383a73fSIra Weiny return true;
575b383a73fSIra Weiny }
5769b7365fcSLi Xi
ext4_ioctl_setflags(struct inode * inode,unsigned int flags)5779b7365fcSLi Xi static int ext4_ioctl_setflags(struct inode *inode,
578ac27a0ecSDave Kleikamp unsigned int flags)
579617ba13bSMingming Cao {
580ac27a0ecSDave Kleikamp struct ext4_inode_info *ei = EXT4_I(inode);
581fdde368eSAnton Protopopov handle_t *handle = NULL;
582617ba13bSMingming Cao int err = -EPERM, migrate = 0;
58379906964STheodore Ts'o struct ext4_iloc iloc;
584b886ee3eSGabriel Krisman Bertazi unsigned int oldflags, mask, i;
585ac27a0ecSDave Kleikamp struct super_block *sb = inode->i_sb;
586e47776a0SJan Kara
58702749a4cSTahsin Erdogan /* Is it quota file? Do not allow user to mess with it */
58842a74f20SDave Hansen if (ext4_is_quota_file(inode))
58942a74f20SDave Hansen goto flags_out;
590ac27a0ecSDave Kleikamp
591ac27a0ecSDave Kleikamp oldflags = ei->i_flags;
592ac27a0ecSDave Kleikamp /*
593ac27a0ecSDave Kleikamp * The JOURNAL_DATA flag can only be changed by
594ac27a0ecSDave Kleikamp * the relevant capability.
595fcebc794SIra Weiny */
59642a74f20SDave Hansen if ((flags ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
59742a74f20SDave Hansen if (!capable(CAP_SYS_RESOURCE))
598ac27a0ecSDave Kleikamp goto flags_out;
599b383a73fSIra Weiny }
600b383a73fSIra Weiny
601b383a73fSIra Weiny if (!dax_compatible(inode, oldflags, flags)) {
602b383a73fSIra Weiny err = -EOPNOTSUPP;
603b383a73fSIra Weiny goto flags_out;
604b383a73fSIra Weiny }
605996bb9fdSTheodore Ts'o
6064db46fc2SAneesh Kumar K.V if ((flags ^ oldflags) & EXT4_EXTENTS_FL)
607ac27a0ecSDave Kleikamp migrate = 1;
608b886ee3eSGabriel Krisman Bertazi
609b886ee3eSGabriel Krisman Bertazi if ((flags ^ oldflags) & EXT4_CASEFOLD_FL) {
610b886ee3eSGabriel Krisman Bertazi if (!ext4_has_feature_casefold(sb)) {
611b886ee3eSGabriel Krisman Bertazi err = -EOPNOTSUPP;
612b886ee3eSGabriel Krisman Bertazi goto flags_out;
613b886ee3eSGabriel Krisman Bertazi }
614b886ee3eSGabriel Krisman Bertazi
615b886ee3eSGabriel Krisman Bertazi if (!S_ISDIR(inode->i_mode)) {
616b886ee3eSGabriel Krisman Bertazi err = -ENOTDIR;
617b886ee3eSGabriel Krisman Bertazi goto flags_out;
618b886ee3eSGabriel Krisman Bertazi }
619b886ee3eSGabriel Krisman Bertazi
620b886ee3eSGabriel Krisman Bertazi if (!ext4_empty_dir(inode)) {
621b886ee3eSGabriel Krisman Bertazi err = -ENOTEMPTY;
622b886ee3eSGabriel Krisman Bertazi goto flags_out;
623b886ee3eSGabriel Krisman Bertazi }
624b886ee3eSGabriel Krisman Bertazi }
6252e538403SDarrick J. Wong
6262e538403SDarrick J. Wong /*
6272e538403SDarrick J. Wong * Wait for all pending directio and then flush all the dirty pages
6282e538403SDarrick J. Wong * for this file. The flush marks all the pages readonly, so any
6292e538403SDarrick J. Wong * subsequent attempt to write to the file (particularly mmap pages)
6302e538403SDarrick J. Wong * will come through the filesystem and fail.
6312e538403SDarrick J. Wong */
6322e538403SDarrick J. Wong if (S_ISREG(inode->i_mode) && !IS_IMMUTABLE(inode) &&
6332e538403SDarrick J. Wong (flags & EXT4_IMMUTABLE_FL)) {
6342e538403SDarrick J. Wong inode_dio_wait(inode);
6352e538403SDarrick J. Wong err = filemap_write_and_wait(inode->i_mapping);
6362e538403SDarrick J. Wong if (err)
6372e538403SDarrick J. Wong goto flags_out;
6382e538403SDarrick J. Wong }
6399924a92aSTheodore Ts'o
640ac27a0ecSDave Kleikamp handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
64142a74f20SDave Hansen if (IS_ERR(handle)) {
64242a74f20SDave Hansen err = PTR_ERR(handle);
643ac27a0ecSDave Kleikamp goto flags_out;
644ac27a0ecSDave Kleikamp }
6450390131bSFrank Mayhar if (IS_SYNC(inode))
646617ba13bSMingming Cao ext4_handle_sync(handle);
647ac27a0ecSDave Kleikamp err = ext4_reserve_inode_write(handle, inode, &iloc);
648ac27a0ecSDave Kleikamp if (err)
649ac27a0ecSDave Kleikamp goto flags_err;
650b383a73fSIra Weiny
651b383a73fSIra Weiny ext4_dax_dontcache(inode, flags);
65279906964STheodore Ts'o
65379906964STheodore Ts'o for (i = 0, mask = 1; i < 32; i++, mask <<= 1) {
65479906964STheodore Ts'o if (!(mask & EXT4_FL_USER_MODIFIABLE))
655f8011d93SJan Kara continue;
656f8011d93SJan Kara /* These flags get special treatment later */
657f8011d93SJan Kara if (mask == EXT4_JOURNAL_DATA_FL || mask == EXT4_EXTENTS_FL)
65879906964STheodore Ts'o continue;
65979906964STheodore Ts'o if (mask & flags)
66079906964STheodore Ts'o ext4_set_inode_flag(inode, i);
66179906964STheodore Ts'o else
66279906964STheodore Ts'o ext4_clear_inode_flag(inode, i);
663ac27a0ecSDave Kleikamp }
664043546e4SIra Weiny
665043546e4SIra Weiny ext4_set_inode_flags(inode, false);
666eeca7ea1SDeepa Dinamani
667a642c2c0SJeff Layton inode_set_ctime_current(inode);
668ac27a0ecSDave Kleikamp inode_inc_iversion(inode);
669617ba13bSMingming Cao
670ac27a0ecSDave Kleikamp err = ext4_mark_iloc_dirty(handle, inode, &iloc);
671617ba13bSMingming Cao flags_err:
67242a74f20SDave Hansen ext4_journal_stop(handle);
67342a74f20SDave Hansen if (err)
674ac27a0ecSDave Kleikamp goto flags_out;
675fcebc794SIra Weiny
676e9072d85SRoss Zwisler if ((flags ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
677e9072d85SRoss Zwisler /*
678ff694ab6SIra Weiny * Changes to the journaling mode can cause unsafe changes to
679e9072d85SRoss Zwisler * S_DAX if the inode is DAX
680ff694ab6SIra Weiny */
681e9072d85SRoss Zwisler if (IS_DAX(inode)) {
682e9072d85SRoss Zwisler err = -EBUSY;
683e9072d85SRoss Zwisler goto flags_out;
684e9072d85SRoss Zwisler }
685fcebc794SIra Weiny
686fcebc794SIra Weiny err = ext4_change_inode_journal_flag(inode,
6874db46fc2SAneesh Kumar K.V flags & EXT4_JOURNAL_DATA_FL);
6884db46fc2SAneesh Kumar K.V if (err)
689e9072d85SRoss Zwisler goto flags_out;
690996bb9fdSTheodore Ts'o }
691996bb9fdSTheodore Ts'o if (migrate) {
6924db46fc2SAneesh Kumar K.V if (flags & EXT4_EXTENTS_FL)
693996bb9fdSTheodore Ts'o err = ext4_ext_migrate(inode);
694996bb9fdSTheodore Ts'o else
695996bb9fdSTheodore Ts'o err = ext4_ind_migrate(inode);
696996bb9fdSTheodore Ts'o }
69742a74f20SDave Hansen
6989b7365fcSLi Xi flags_out:
6999b7365fcSLi Xi return err;
7009b7365fcSLi Xi }
7019b7365fcSLi Xi
7024db5c2e6SMiklos Szeredi #ifdef CONFIG_QUOTA
ext4_ioctl_setproject(struct inode * inode,__u32 projid)7039b7365fcSLi Xi static int ext4_ioctl_setproject(struct inode *inode, __u32 projid)
7049b7365fcSLi Xi {
7059b7365fcSLi Xi struct super_block *sb = inode->i_sb;
7069b7365fcSLi Xi struct ext4_inode_info *ei = EXT4_I(inode);
7079b7365fcSLi Xi int err, rc;
7089b7365fcSLi Xi handle_t *handle;
7099b7365fcSLi Xi kprojid_t kprojid;
7109b7365fcSLi Xi struct ext4_iloc iloc;
711079788d0SWang Shilong struct ext4_inode *raw_inode;
7129b7365fcSLi Xi struct dquot *transfer_to[MAXQUOTAS] = { };
7130b7b7779SKaho Ng
7149b7365fcSLi Xi if (!ext4_has_feature_project(sb)) {
7159b7365fcSLi Xi if (projid != EXT4_DEF_PROJID)
7169b7365fcSLi Xi return -EOPNOTSUPP;
7179b7365fcSLi Xi else
7189b7365fcSLi Xi return 0;
7199b7365fcSLi Xi }
7209b7365fcSLi Xi
7219b7365fcSLi Xi if (EXT4_INODE_SIZE(sb) <= EXT4_GOOD_OLD_INODE_SIZE)
7229b7365fcSLi Xi return -EOPNOTSUPP;
7239b7365fcSLi Xi
7249b7365fcSLi Xi kprojid = make_kprojid(&init_user_ns, (projid_t)projid);
7259b7365fcSLi Xi
7269b7365fcSLi Xi if (projid_eq(kprojid, EXT4_I(inode)->i_projid))
7279b7365fcSLi Xi return 0;
7289b7365fcSLi Xi
7299b7365fcSLi Xi err = -EPERM;
73002749a4cSTahsin Erdogan /* Is it quota file? Do not allow user to mess with it */
731dc7ac6c4SWang Shilong if (ext4_is_quota_file(inode))
7329b7365fcSLi Xi return err;
7331485f726SJan Kara
7341485f726SJan Kara err = dquot_initialize(inode);
7351485f726SJan Kara if (err)
7361485f726SJan Kara return err;
7379b7365fcSLi Xi
7389b7365fcSLi Xi err = ext4_get_inode_loc(inode, &iloc);
739dc7ac6c4SWang Shilong if (err)
7409b7365fcSLi Xi return err;
7419b7365fcSLi Xi
7429b7365fcSLi Xi raw_inode = ext4_raw_inode(&iloc);
743c03b45b8SMiao Xie if (!EXT4_FITS_IN_INODE(raw_inode, ei, i_projid)) {
744c03b45b8SMiao Xie err = ext4_expand_extra_isize(inode,
745c03b45b8SMiao Xie EXT4_SB(sb)->s_want_extra_isize,
746c03b45b8SMiao Xie &iloc);
747dc7ac6c4SWang Shilong if (err)
748c03b45b8SMiao Xie return err;
7499b7365fcSLi Xi } else {
750c03b45b8SMiao Xie brelse(iloc.bh);
7519b7365fcSLi Xi }
7529b7365fcSLi Xi
7539b7365fcSLi Xi handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
7549b7365fcSLi Xi EXT4_QUOTA_INIT_BLOCKS(sb) +
755dc7ac6c4SWang Shilong EXT4_QUOTA_DEL_BLOCKS(sb) + 3);
756dc7ac6c4SWang Shilong if (IS_ERR(handle))
7579b7365fcSLi Xi return PTR_ERR(handle);
7589b7365fcSLi Xi
7599b7365fcSLi Xi err = ext4_reserve_inode_write(handle, inode, &iloc);
7609b7365fcSLi Xi if (err)
7619b7365fcSLi Xi goto out_stop;
7629b7365fcSLi Xi
763ff0bc084SSeth Forshee transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid));
7647a9ca53aSTahsin Erdogan if (!IS_ERR(transfer_to[PRJQUOTA])) {
7657a9ca53aSTahsin Erdogan
7667a9ca53aSTahsin Erdogan /* __dquot_transfer() calls back ext4_get_inode_usage() which
7677a9ca53aSTahsin Erdogan * counts xattr inode references.
7687a9ca53aSTahsin Erdogan */
7699b7365fcSLi Xi down_read(&EXT4_I(inode)->xattr_sem);
7707a9ca53aSTahsin Erdogan err = __dquot_transfer(inode, transfer_to);
7719b7365fcSLi Xi up_read(&EXT4_I(inode)->xattr_sem);
7729b7365fcSLi Xi dqput(transfer_to[PRJQUOTA]);
7739b7365fcSLi Xi if (err)
7749b7365fcSLi Xi goto out_dirty;
775079788d0SWang Shilong }
7769b7365fcSLi Xi
777eeca7ea1SDeepa Dinamani EXT4_I(inode)->i_projid = kprojid;
778a642c2c0SJeff Layton inode_set_ctime_current(inode);
7799b7365fcSLi Xi inode_inc_iversion(inode);
7809b7365fcSLi Xi out_dirty:
7819b7365fcSLi Xi rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
7829b7365fcSLi Xi if (!err)
7839b7365fcSLi Xi err = rc;
7849b7365fcSLi Xi out_stop:
7859b7365fcSLi Xi ext4_journal_stop(handle);
7869b7365fcSLi Xi return err;
7879b7365fcSLi Xi }
7884db5c2e6SMiklos Szeredi #else
ext4_ioctl_setproject(struct inode * inode,__u32 projid)7899b7365fcSLi Xi static int ext4_ioctl_setproject(struct inode *inode, __u32 projid)
7909b7365fcSLi Xi {
7919b7365fcSLi Xi if (projid != EXT4_DEF_PROJID)
7929b7365fcSLi Xi return -EOPNOTSUPP;
7939b7365fcSLi Xi return 0;
7949b7365fcSLi Xi }
7959b7365fcSLi Xi #endif
79697524b45SChristoph Hellwig
ext4_force_shutdown(struct super_block * sb,u32 flags)797783d9485STheodore Ts'o int ext4_force_shutdown(struct super_block *sb, u32 flags)
798783d9485STheodore Ts'o {
799c4d13222SChao Yu struct ext4_sb_info *sbi = EXT4_SB(sb);
800783d9485STheodore Ts'o int ret;
801783d9485STheodore Ts'o
802783d9485STheodore Ts'o if (flags > EXT4_GOING_FLAGS_NOLOGFLUSH)
803783d9485STheodore Ts'o return -EINVAL;
804*eb8ab444SJan Kara
805783d9485STheodore Ts'o if (ext4_forced_shutdown(sb))
806783d9485STheodore Ts'o return 0;
807783d9485STheodore Ts'o
808ccf0f32aSTheodore Ts'o ext4_msg(sb, KERN_ALERT, "shut down requested (%d)", flags);
809783d9485STheodore Ts'o trace_ext4_shutdown(sb, flags);
810783d9485STheodore Ts'o
811783d9485STheodore Ts'o switch (flags) {
812c4d13222SChao Yu case EXT4_GOING_FLAGS_DEFAULT:
813c4d13222SChao Yu ret = freeze_bdev(sb->s_bdev);
814c4d13222SChao Yu if (ret)
815783d9485STheodore Ts'o return ret;
816040f04bdSChristoph Hellwig set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
817783d9485STheodore Ts'o thaw_bdev(sb->s_bdev);
818783d9485STheodore Ts'o break;
819783d9485STheodore Ts'o case EXT4_GOING_FLAGS_LOGFLUSH:
820783d9485STheodore Ts'o set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
821783d9485STheodore Ts'o if (sbi->s_journal && !is_journal_aborted(sbi->s_journal)) {
822fb7c0244STheodore Ts'o (void) ext4_force_commit(sb);
823783d9485STheodore Ts'o jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN);
824783d9485STheodore Ts'o }
825783d9485STheodore Ts'o break;
826783d9485STheodore Ts'o case EXT4_GOING_FLAGS_NOLOGFLUSH:
827a6d9946bSTheodore Ts'o set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
828fb7c0244STheodore Ts'o if (sbi->s_journal && !is_journal_aborted(sbi->s_journal))
829783d9485STheodore Ts'o jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN);
830783d9485STheodore Ts'o break;
831783d9485STheodore Ts'o default:
832783d9485STheodore Ts'o return -EINVAL;
833783d9485STheodore Ts'o }
834783d9485STheodore Ts'o clear_opt(sb, DISCARD);
835783d9485STheodore Ts'o return 0;
836783d9485STheodore Ts'o }
83797524b45SChristoph Hellwig
ext4_ioctl_shutdown(struct super_block * sb,unsigned long arg)83897524b45SChristoph Hellwig static int ext4_ioctl_shutdown(struct super_block *sb, unsigned long arg)
83997524b45SChristoph Hellwig {
84097524b45SChristoph Hellwig u32 flags;
84197524b45SChristoph Hellwig
84297524b45SChristoph Hellwig if (!capable(CAP_SYS_ADMIN))
84397524b45SChristoph Hellwig return -EPERM;
84497524b45SChristoph Hellwig
84597524b45SChristoph Hellwig if (get_user(flags, (__u32 __user *)arg))
84697524b45SChristoph Hellwig return -EFAULT;
84797524b45SChristoph Hellwig
84897524b45SChristoph Hellwig return ext4_force_shutdown(sb, flags);
84997524b45SChristoph Hellwig }
8500c9ec4beSDarrick J. Wong
8510c9ec4beSDarrick J. Wong struct getfsmap_info {
8520c9ec4beSDarrick J. Wong struct super_block *gi_sb;
8530c9ec4beSDarrick J. Wong struct fsmap_head __user *gi_data;
8540c9ec4beSDarrick J. Wong unsigned int gi_idx;
8550c9ec4beSDarrick J. Wong __u32 gi_last_flags;
8560c9ec4beSDarrick J. Wong };
8570c9ec4beSDarrick J. Wong
ext4_getfsmap_format(struct ext4_fsmap * xfm,void * priv)8580c9ec4beSDarrick J. Wong static int ext4_getfsmap_format(struct ext4_fsmap *xfm, void *priv)
8590c9ec4beSDarrick J. Wong {
8600c9ec4beSDarrick J. Wong struct getfsmap_info *info = priv;
8610c9ec4beSDarrick J. Wong struct fsmap fm;
8620c9ec4beSDarrick J. Wong
8630c9ec4beSDarrick J. Wong trace_ext4_getfsmap_mapping(info->gi_sb, xfm);
8640c9ec4beSDarrick J. Wong
8650c9ec4beSDarrick J. Wong info->gi_last_flags = xfm->fmr_flags;
8660c9ec4beSDarrick J. Wong ext4_fsmap_from_internal(info->gi_sb, &fm, xfm);
8670c9ec4beSDarrick J. Wong if (copy_to_user(&info->gi_data->fmh_recs[info->gi_idx++], &fm,
8680c9ec4beSDarrick J. Wong sizeof(struct fsmap)))
8690c9ec4beSDarrick J. Wong return -EFAULT;
8700c9ec4beSDarrick J. Wong
8710c9ec4beSDarrick J. Wong return 0;
8720c9ec4beSDarrick J. Wong }
8730c9ec4beSDarrick J. Wong
ext4_ioc_getfsmap(struct super_block * sb,struct fsmap_head __user * arg)8740c9ec4beSDarrick J. Wong static int ext4_ioc_getfsmap(struct super_block *sb,
8750c9ec4beSDarrick J. Wong struct fsmap_head __user *arg)
8760ba33facSTheodore Ts'o {
8770c9ec4beSDarrick J. Wong struct getfsmap_info info = { NULL };
8780c9ec4beSDarrick J. Wong struct ext4_fsmap_head xhead = {0};
8790c9ec4beSDarrick J. Wong struct fsmap_head head;
8800c9ec4beSDarrick J. Wong bool aborted = false;
8810c9ec4beSDarrick J. Wong int error;
8820c9ec4beSDarrick J. Wong
8830c9ec4beSDarrick J. Wong if (copy_from_user(&head, arg, sizeof(struct fsmap_head)))
8840c9ec4beSDarrick J. Wong return -EFAULT;
8850c9ec4beSDarrick J. Wong if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) ||
8860c9ec4beSDarrick J. Wong memchr_inv(head.fmh_keys[0].fmr_reserved, 0,
8870c9ec4beSDarrick J. Wong sizeof(head.fmh_keys[0].fmr_reserved)) ||
8880c9ec4beSDarrick J. Wong memchr_inv(head.fmh_keys[1].fmr_reserved, 0,
8890c9ec4beSDarrick J. Wong sizeof(head.fmh_keys[1].fmr_reserved)))
8900c9ec4beSDarrick J. Wong return -EINVAL;
8910c9ec4beSDarrick J. Wong /*
8920c9ec4beSDarrick J. Wong * ext4 doesn't report file extents at all, so the only valid
8930c9ec4beSDarrick J. Wong * file offsets are the magic ones (all zeroes or all ones).
8940c9ec4beSDarrick J. Wong */
8950c9ec4beSDarrick J. Wong if (head.fmh_keys[0].fmr_offset ||
8960c9ec4beSDarrick J. Wong (head.fmh_keys[1].fmr_offset != 0 &&
8970c9ec4beSDarrick J. Wong head.fmh_keys[1].fmr_offset != -1ULL))
8980c9ec4beSDarrick J. Wong return -EINVAL;
8990c9ec4beSDarrick J. Wong
9000c9ec4beSDarrick J. Wong xhead.fmh_iflags = head.fmh_iflags;
9010c9ec4beSDarrick J. Wong xhead.fmh_count = head.fmh_count;
9020c9ec4beSDarrick J. Wong ext4_fsmap_to_internal(sb, &xhead.fmh_keys[0], &head.fmh_keys[0]);
9030c9ec4beSDarrick J. Wong ext4_fsmap_to_internal(sb, &xhead.fmh_keys[1], &head.fmh_keys[1]);
9040c9ec4beSDarrick J. Wong
9050c9ec4beSDarrick J. Wong trace_ext4_getfsmap_low_key(sb, &xhead.fmh_keys[0]);
9060c9ec4beSDarrick J. Wong trace_ext4_getfsmap_high_key(sb, &xhead.fmh_keys[1]);
9070c9ec4beSDarrick J. Wong
9080c9ec4beSDarrick J. Wong info.gi_sb = sb;
9090c9ec4beSDarrick J. Wong info.gi_data = arg;
9101fc57ca5SJiapeng Chong error = ext4_getfsmap(sb, &xhead, ext4_getfsmap_format, &info);
9110c9ec4beSDarrick J. Wong if (error == EXT4_QUERY_RANGE_ABORT)
9121fc57ca5SJiapeng Chong aborted = true;
9130c9ec4beSDarrick J. Wong else if (error)
9140c9ec4beSDarrick J. Wong return error;
9150c9ec4beSDarrick J. Wong
9160c9ec4beSDarrick J. Wong /* If we didn't abort, set the "last" flag in the last fmx */
9170c9ec4beSDarrick J. Wong if (!aborted && info.gi_idx) {
9180c9ec4beSDarrick J. Wong info.gi_last_flags |= FMR_OF_LAST;
9190c9ec4beSDarrick J. Wong if (copy_to_user(&info.gi_data->fmh_recs[info.gi_idx - 1].fmr_flags,
9200c9ec4beSDarrick J. Wong &info.gi_last_flags,
9210c9ec4beSDarrick J. Wong sizeof(info.gi_last_flags)))
9220c9ec4beSDarrick J. Wong return -EFAULT;
9230c9ec4beSDarrick J. Wong }
9240c9ec4beSDarrick J. Wong
9250c9ec4beSDarrick J. Wong /* copy back header */
9260c9ec4beSDarrick J. Wong head.fmh_entries = xhead.fmh_entries;
9270c9ec4beSDarrick J. Wong head.fmh_oflags = xhead.fmh_oflags;
9280c9ec4beSDarrick J. Wong if (copy_to_user(arg, &head, sizeof(struct fsmap_head)))
9290c9ec4beSDarrick J. Wong return -EFAULT;
9300c9ec4beSDarrick J. Wong
9310c9ec4beSDarrick J. Wong return 0;
9320c9ec4beSDarrick J. Wong }
933e145b35bSAl Viro
ext4_ioctl_group_add(struct file * file,struct ext4_new_group_data * input)934e145b35bSAl Viro static long ext4_ioctl_group_add(struct file *file,
935e145b35bSAl Viro struct ext4_new_group_data *input)
936e145b35bSAl Viro {
937e145b35bSAl Viro struct super_block *sb = file_inode(file)->i_sb;
938e145b35bSAl Viro int err, err2=0;
939e145b35bSAl Viro
940e145b35bSAl Viro err = ext4_resize_begin(sb);
941e145b35bSAl Viro if (err)
942e145b35bSAl Viro return err;
9438813587aSTheodore Ts'o
9448813587aSTheodore Ts'o if (ext4_has_feature_bigalloc(sb)) {
9458813587aSTheodore Ts'o ext4_msg(sb, KERN_ERR,
9468813587aSTheodore Ts'o "Online resizing not supported with bigalloc");
9478813587aSTheodore Ts'o err = -EOPNOTSUPP;
9488813587aSTheodore Ts'o goto group_add_out;
9498813587aSTheodore Ts'o }
950e145b35bSAl Viro
951e145b35bSAl Viro err = mnt_want_write_file(file);
952e145b35bSAl Viro if (err)
953e145b35bSAl Viro goto group_add_out;
954e145b35bSAl Viro
955e145b35bSAl Viro err = ext4_group_add(sb, input);
956e145b35bSAl Viro if (EXT4_SB(sb)->s_journal) {
95701d5d965SLeah Rumancik jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
958e145b35bSAl Viro err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal, 0);
959e145b35bSAl Viro jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
960e145b35bSAl Viro }
961e145b35bSAl Viro if (err == 0)
962e145b35bSAl Viro err = err2;
963e145b35bSAl Viro mnt_drop_write_file(file);
964e145b35bSAl Viro if (!err && ext4_has_group_desc_csum(sb) &&
965e145b35bSAl Viro test_opt(sb, INIT_INODE_TABLE))
966e145b35bSAl Viro err = ext4_register_li_request(sb, input->group);
967827891a3STheodore Ts'o group_add_out:
968827891a3STheodore Ts'o err2 = ext4_resize_end(sb, false);
969827891a3STheodore Ts'o if (err == 0)
970e145b35bSAl Viro err = err2;
971e145b35bSAl Viro return err;
972e145b35bSAl Viro }
9734db5c2e6SMiklos Szeredi
ext4_fileattr_get(struct dentry * dentry,struct fileattr * fa)974dc7ac6c4SWang Shilong int ext4_fileattr_get(struct dentry *dentry, struct fileattr *fa)
9754db5c2e6SMiklos Szeredi {
9767b0e492eSDarrick J. Wong struct inode *inode = d_inode(dentry);
9774db5c2e6SMiklos Szeredi struct ext4_inode_info *ei = EXT4_I(inode);
978dc7ac6c4SWang Shilong u32 flags = ei->i_flags & EXT4_FL_USER_VISIBLE;
9794db5c2e6SMiklos Szeredi
9804db5c2e6SMiklos Szeredi if (S_ISREG(inode->i_mode))
981dc7ac6c4SWang Shilong flags &= ~FS_PROJINHERIT_FL;
9824db5c2e6SMiklos Szeredi
9837b0e492eSDarrick J. Wong fileattr_fill_flags(fa, flags);
9847b0e492eSDarrick J. Wong if (ext4_has_feature_project(inode->i_sb))
9854db5c2e6SMiklos Szeredi fa->fsx_projid = from_kprojid(&init_user_ns, ei->i_projid);
9864db5c2e6SMiklos Szeredi
9874db5c2e6SMiklos Szeredi return 0;
9884db5c2e6SMiklos Szeredi }
9898782a9aeSChristian Brauner
ext4_fileattr_set(struct mnt_idmap * idmap,struct dentry * dentry,struct fileattr * fa)9904db5c2e6SMiklos Szeredi int ext4_fileattr_set(struct mnt_idmap *idmap,
9914db5c2e6SMiklos Szeredi struct dentry *dentry, struct fileattr *fa)
9924db5c2e6SMiklos Szeredi {
9934db5c2e6SMiklos Szeredi struct inode *inode = d_inode(dentry);
9944db5c2e6SMiklos Szeredi u32 flags = fa->flags;
9954db5c2e6SMiklos Szeredi int err = -EOPNOTSUPP;
9964db5c2e6SMiklos Szeredi
9974db5c2e6SMiklos Szeredi if (flags & ~EXT4_FL_USER_VISIBLE)
9984db5c2e6SMiklos Szeredi goto out;
9994db5c2e6SMiklos Szeredi
10004db5c2e6SMiklos Szeredi /*
10014db5c2e6SMiklos Szeredi * chattr(1) grabs flags via GETFLAGS, modifies the result and
10024db5c2e6SMiklos Szeredi * passes that to SETFLAGS. So we cannot easily make SETFLAGS
10034db5c2e6SMiklos Szeredi * more restrictive than just silently masking off visible but
10044db5c2e6SMiklos Szeredi * not settable flags as we always did.
10054db5c2e6SMiklos Szeredi */
10064db5c2e6SMiklos Szeredi flags &= EXT4_FL_USER_MODIFIABLE;
10074db5c2e6SMiklos Szeredi if (ext4_mask_flags(inode->i_mode, flags) != flags)
10084db5c2e6SMiklos Szeredi goto out;
10094db5c2e6SMiklos Szeredi err = ext4_ioctl_check_immutable(inode, fa->fsx_projid, flags);
10104db5c2e6SMiklos Szeredi if (err)
10114db5c2e6SMiklos Szeredi goto out;
10124db5c2e6SMiklos Szeredi err = ext4_ioctl_setflags(inode, flags);
10134db5c2e6SMiklos Szeredi if (err)
10144db5c2e6SMiklos Szeredi goto out;
10154db5c2e6SMiklos Szeredi err = ext4_ioctl_setproject(inode, fa->fsx_projid);
10164db5c2e6SMiklos Szeredi out:
1017dc7ac6c4SWang Shilong return err;
1018dc7ac6c4SWang Shilong }
1019bb5835edSTheodore Ts'o
1020bb5835edSTheodore Ts'o /* So that the fiemap access checks can't overflow on 32 bit machines. */
1021bb5835edSTheodore Ts'o #define FIEMAP_MAX_EXTENTS (UINT_MAX / sizeof(struct fiemap_extent))
1022bb5835edSTheodore Ts'o
ext4_ioctl_get_es_cache(struct file * filp,unsigned long arg)1023bb5835edSTheodore Ts'o static int ext4_ioctl_get_es_cache(struct file *filp, unsigned long arg)
1024bb5835edSTheodore Ts'o {
1025bb5835edSTheodore Ts'o struct fiemap fiemap;
1026bb5835edSTheodore Ts'o struct fiemap __user *ufiemap = (struct fiemap __user *) arg;
1027bb5835edSTheodore Ts'o struct fiemap_extent_info fieinfo = { 0, };
1028bb5835edSTheodore Ts'o struct inode *inode = file_inode(filp);
1029bb5835edSTheodore Ts'o int error;
1030bb5835edSTheodore Ts'o
1031bb5835edSTheodore Ts'o if (copy_from_user(&fiemap, ufiemap, sizeof(fiemap)))
1032bb5835edSTheodore Ts'o return -EFAULT;
1033bb5835edSTheodore Ts'o
1034bb5835edSTheodore Ts'o if (fiemap.fm_extent_count > FIEMAP_MAX_EXTENTS)
1035bb5835edSTheodore Ts'o return -EINVAL;
1036bb5835edSTheodore Ts'o
1037bb5835edSTheodore Ts'o fieinfo.fi_flags = fiemap.fm_flags;
1038bb5835edSTheodore Ts'o fieinfo.fi_extents_max = fiemap.fm_extent_count;
1039bb5835edSTheodore Ts'o fieinfo.fi_extents_start = ufiemap->fm_extents;
1040328e24aeSChristoph Hellwig
1041328e24aeSChristoph Hellwig error = ext4_get_es_cache(inode, &fieinfo, fiemap.fm_start,
1042bb5835edSTheodore Ts'o fiemap.fm_length);
1043bb5835edSTheodore Ts'o fiemap.fm_flags = fieinfo.fi_flags;
1044bb5835edSTheodore Ts'o fiemap.fm_mapped_extents = fieinfo.fi_extents_mapped;
1045bb5835edSTheodore Ts'o if (copy_to_user(ufiemap, &fiemap, sizeof(fiemap)))
1046bb5835edSTheodore Ts'o error = -EFAULT;
1047bb5835edSTheodore Ts'o
1048bb5835edSTheodore Ts'o return error;
1049bb5835edSTheodore Ts'o }
1050351a0a3fSLeah Rumancik
ext4_ioctl_checkpoint(struct file * filp,unsigned long arg)1051351a0a3fSLeah Rumancik static int ext4_ioctl_checkpoint(struct file *filp, unsigned long arg)
1052351a0a3fSLeah Rumancik {
1053351a0a3fSLeah Rumancik int err = 0;
1054351a0a3fSLeah Rumancik __u32 flags = 0;
1055351a0a3fSLeah Rumancik unsigned int flush_flags = 0;
1056351a0a3fSLeah Rumancik struct super_block *sb = file_inode(filp)->i_sb;
1057351a0a3fSLeah Rumancik
1058351a0a3fSLeah Rumancik if (copy_from_user(&flags, (__u32 __user *)arg,
1059351a0a3fSLeah Rumancik sizeof(__u32)))
1060351a0a3fSLeah Rumancik return -EFAULT;
1061351a0a3fSLeah Rumancik
1062351a0a3fSLeah Rumancik if (!capable(CAP_SYS_ADMIN))
1063351a0a3fSLeah Rumancik return -EPERM;
1064351a0a3fSLeah Rumancik
1065351a0a3fSLeah Rumancik /* check for invalid bits set */
1066351a0a3fSLeah Rumancik if ((flags & ~EXT4_IOC_CHECKPOINT_FLAG_VALID) ||
1067351a0a3fSLeah Rumancik ((flags & JBD2_JOURNAL_FLUSH_DISCARD) &&
1068351a0a3fSLeah Rumancik (flags & JBD2_JOURNAL_FLUSH_ZEROOUT)))
1069351a0a3fSLeah Rumancik return -EINVAL;
1070351a0a3fSLeah Rumancik
1071351a0a3fSLeah Rumancik if (!EXT4_SB(sb)->s_journal)
1072351a0a3fSLeah Rumancik return -ENODEV;
107370200574SChristoph Hellwig
107470200574SChristoph Hellwig if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) &&
1075351a0a3fSLeah Rumancik !bdev_max_discard_sectors(EXT4_SB(sb)->s_journal->j_dev))
1076351a0a3fSLeah Rumancik return -EOPNOTSUPP;
1077351a0a3fSLeah Rumancik
1078351a0a3fSLeah Rumancik if (flags & EXT4_IOC_CHECKPOINT_FLAG_DRY_RUN)
1079351a0a3fSLeah Rumancik return 0;
1080351a0a3fSLeah Rumancik
1081351a0a3fSLeah Rumancik if (flags & EXT4_IOC_CHECKPOINT_FLAG_DISCARD)
1082351a0a3fSLeah Rumancik flush_flags |= JBD2_JOURNAL_FLUSH_DISCARD;
1083351a0a3fSLeah Rumancik
1084351a0a3fSLeah Rumancik if (flags & EXT4_IOC_CHECKPOINT_FLAG_ZEROOUT) {
1085351a0a3fSLeah Rumancik flush_flags |= JBD2_JOURNAL_FLUSH_ZEROOUT;
1086351a0a3fSLeah Rumancik pr_info_ratelimited("warning: checkpointing journal with EXT4_IOC_CHECKPOINT_FLAG_ZEROOUT can be slow");
1087351a0a3fSLeah Rumancik }
1088351a0a3fSLeah Rumancik
1089351a0a3fSLeah Rumancik jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
1090351a0a3fSLeah Rumancik err = jbd2_journal_flush(EXT4_SB(sb)->s_journal, flush_flags);
1091351a0a3fSLeah Rumancik jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
1092351a0a3fSLeah Rumancik
1093351a0a3fSLeah Rumancik return err;
1094351a0a3fSLeah Rumancik }
1095bbc605cdSLukas Czerner
ext4_ioctl_setlabel(struct file * filp,const char __user * user_label)1096bbc605cdSLukas Czerner static int ext4_ioctl_setlabel(struct file *filp, const char __user *user_label)
1097bbc605cdSLukas Czerner {
1098bbc605cdSLukas Czerner size_t len;
1099bbc605cdSLukas Czerner int ret = 0;
1100bbc605cdSLukas Czerner char new_label[EXT4_LABEL_MAX + 1];
1101bbc605cdSLukas Czerner struct super_block *sb = file_inode(filp)->i_sb;
1102bbc605cdSLukas Czerner
1103bbc605cdSLukas Czerner if (!capable(CAP_SYS_ADMIN))
1104bbc605cdSLukas Czerner return -EPERM;
1105bbc605cdSLukas Czerner
1106bbc605cdSLukas Czerner /*
1107bbc605cdSLukas Czerner * Copy the maximum length allowed for ext4 label with one more to
1108bbc605cdSLukas Czerner * find the required terminating null byte in order to test the
1109bbc605cdSLukas Czerner * label length. The on disk label doesn't need to be null terminated.
1110bbc605cdSLukas Czerner */
1111bbc605cdSLukas Czerner if (copy_from_user(new_label, user_label, EXT4_LABEL_MAX + 1))
1112bbc605cdSLukas Czerner return -EFAULT;
1113bbc605cdSLukas Czerner
1114bbc605cdSLukas Czerner len = strnlen(new_label, EXT4_LABEL_MAX + 1);
1115bbc605cdSLukas Czerner if (len > EXT4_LABEL_MAX)
1116bbc605cdSLukas Czerner return -EINVAL;
1117bbc605cdSLukas Czerner
1118bbc605cdSLukas Czerner /*
1119bbc605cdSLukas Czerner * Clear the buffer after the new label
1120bbc605cdSLukas Czerner */
1121bbc605cdSLukas Czerner memset(new_label + len, 0, EXT4_LABEL_MAX - len);
1122bbc605cdSLukas Czerner
1123bbc605cdSLukas Czerner ret = mnt_want_write_file(filp);
1124bbc605cdSLukas Czerner if (ret)
1125bbc605cdSLukas Czerner return ret;
1126bbc605cdSLukas Czerner
1127bbc605cdSLukas Czerner ret = ext4_update_superblocks_fn(sb, ext4_sb_setlabel, new_label);
1128bbc605cdSLukas Czerner
1129bbc605cdSLukas Czerner mnt_drop_write_file(filp);
1130bbc605cdSLukas Czerner return ret;
1131bbc605cdSLukas Czerner }
1132bbc605cdSLukas Czerner
ext4_ioctl_getlabel(struct ext4_sb_info * sbi,char __user * user_label)1133bbc605cdSLukas Czerner static int ext4_ioctl_getlabel(struct ext4_sb_info *sbi, char __user *user_label)
1134bbc605cdSLukas Czerner {
1135bbc605cdSLukas Czerner char label[EXT4_LABEL_MAX + 1];
1136bbc605cdSLukas Czerner
1137bbc605cdSLukas Czerner /*
1138bbc605cdSLukas Czerner * EXT4_LABEL_MAX must always be smaller than FSLABEL_MAX because
1139bbc605cdSLukas Czerner * FSLABEL_MAX must include terminating null byte, while s_volume_name
1140bbc605cdSLukas Czerner * does not have to.
1141bbc605cdSLukas Czerner */
1142bbc605cdSLukas Czerner BUILD_BUG_ON(EXT4_LABEL_MAX >= FSLABEL_MAX);
1143bbc605cdSLukas Czerner
1144bbc605cdSLukas Czerner memset(label, 0, sizeof(label));
1145bbc605cdSLukas Czerner lock_buffer(sbi->s_sbh);
1146bbc605cdSLukas Czerner strncpy(label, sbi->s_es->s_volume_name, EXT4_LABEL_MAX);
1147bbc605cdSLukas Czerner unlock_buffer(sbi->s_sbh);
1148bbc605cdSLukas Czerner
1149bbc605cdSLukas Czerner if (copy_to_user(user_label, label, sizeof(label)))
1150bbc605cdSLukas Czerner return -EFAULT;
1151bbc605cdSLukas Czerner return 0;
1152bbc605cdSLukas Czerner }
1153d95efb14SJeremy Bongio
ext4_ioctl_getuuid(struct ext4_sb_info * sbi,struct fsuuid __user * ufsuuid)1154d95efb14SJeremy Bongio static int ext4_ioctl_getuuid(struct ext4_sb_info *sbi,
1155d95efb14SJeremy Bongio struct fsuuid __user *ufsuuid)
1156d95efb14SJeremy Bongio {
1157d95efb14SJeremy Bongio struct fsuuid fsuuid;
1158d95efb14SJeremy Bongio __u8 uuid[UUID_SIZE];
1159d95efb14SJeremy Bongio
1160d95efb14SJeremy Bongio if (copy_from_user(&fsuuid, ufsuuid, sizeof(fsuuid)))
1161d95efb14SJeremy Bongio return -EFAULT;
1162d95efb14SJeremy Bongio
1163d95efb14SJeremy Bongio if (fsuuid.fsu_len == 0) {
1164b76abb51SDarrick J. Wong fsuuid.fsu_len = UUID_SIZE;
1165b76abb51SDarrick J. Wong if (copy_to_user(&ufsuuid->fsu_len, &fsuuid.fsu_len,
1166d95efb14SJeremy Bongio sizeof(fsuuid.fsu_len)))
1167b76abb51SDarrick J. Wong return -EFAULT;
1168d95efb14SJeremy Bongio return 0;
1169d95efb14SJeremy Bongio }
1170a7e9d977SDarrick J. Wong
1171d95efb14SJeremy Bongio if (fsuuid.fsu_len < UUID_SIZE || fsuuid.fsu_flags != 0)
1172d95efb14SJeremy Bongio return -EINVAL;
1173d95efb14SJeremy Bongio
1174d95efb14SJeremy Bongio lock_buffer(sbi->s_sbh);
1175d95efb14SJeremy Bongio memcpy(uuid, sbi->s_es->s_uuid, UUID_SIZE);
1176d95efb14SJeremy Bongio unlock_buffer(sbi->s_sbh);
1177a7e9d977SDarrick J. Wong
1178a7e9d977SDarrick J. Wong fsuuid.fsu_len = UUID_SIZE;
1179a7e9d977SDarrick J. Wong if (copy_to_user(ufsuuid, &fsuuid, sizeof(fsuuid)) ||
1180d95efb14SJeremy Bongio copy_to_user(&ufsuuid->fsu_uuid[0], uuid, UUID_SIZE))
1181d95efb14SJeremy Bongio return -EFAULT;
1182d95efb14SJeremy Bongio return 0;
1183d95efb14SJeremy Bongio }
1184d95efb14SJeremy Bongio
ext4_ioctl_setuuid(struct file * filp,const struct fsuuid __user * ufsuuid)1185d95efb14SJeremy Bongio static int ext4_ioctl_setuuid(struct file *filp,
1186d95efb14SJeremy Bongio const struct fsuuid __user *ufsuuid)
1187d95efb14SJeremy Bongio {
1188d95efb14SJeremy Bongio int ret = 0;
1189d95efb14SJeremy Bongio struct super_block *sb = file_inode(filp)->i_sb;
1190d95efb14SJeremy Bongio struct fsuuid fsuuid;
1191d95efb14SJeremy Bongio __u8 uuid[UUID_SIZE];
1192d95efb14SJeremy Bongio
1193d95efb14SJeremy Bongio if (!capable(CAP_SYS_ADMIN))
1194d95efb14SJeremy Bongio return -EPERM;
1195d95efb14SJeremy Bongio
1196d95efb14SJeremy Bongio /*
1197d95efb14SJeremy Bongio * If any checksums (group descriptors or metadata) are being used
1198d95efb14SJeremy Bongio * then the checksum seed feature is required to change the UUID.
1199d95efb14SJeremy Bongio */
1200d95efb14SJeremy Bongio if (((ext4_has_feature_gdt_csum(sb) || ext4_has_metadata_csum(sb))
1201d95efb14SJeremy Bongio && !ext4_has_feature_csum_seed(sb))
1202d95efb14SJeremy Bongio || ext4_has_feature_stable_inodes(sb))
1203d95efb14SJeremy Bongio return -EOPNOTSUPP;
1204d95efb14SJeremy Bongio
1205d95efb14SJeremy Bongio if (copy_from_user(&fsuuid, ufsuuid, sizeof(fsuuid)))
1206d95efb14SJeremy Bongio return -EFAULT;
1207d95efb14SJeremy Bongio
1208d95efb14SJeremy Bongio if (fsuuid.fsu_len != UUID_SIZE || fsuuid.fsu_flags != 0)
1209d95efb14SJeremy Bongio return -EINVAL;
1210d95efb14SJeremy Bongio
1211d95efb14SJeremy Bongio if (copy_from_user(uuid, &ufsuuid->fsu_uuid[0], UUID_SIZE))
1212d95efb14SJeremy Bongio return -EFAULT;
1213d95efb14SJeremy Bongio
1214d95efb14SJeremy Bongio ret = mnt_want_write_file(filp);
1215d95efb14SJeremy Bongio if (ret)
1216d95efb14SJeremy Bongio return ret;
1217d95efb14SJeremy Bongio
1218d95efb14SJeremy Bongio ret = ext4_update_superblocks_fn(sb, ext4_sb_setuuid, &uuid);
1219d95efb14SJeremy Bongio mnt_drop_write_file(filp);
1220d95efb14SJeremy Bongio
1221d95efb14SJeremy Bongio return ret;
1222d95efb14SJeremy Bongio }
1223aa75f4d3SHarshad Shirwadkar
__ext4_ioctl(struct file * filp,unsigned int cmd,unsigned long arg)12249b7365fcSLi Xi static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
12259b7365fcSLi Xi {
12269b7365fcSLi Xi struct inode *inode = file_inode(filp);
122701beba79SChristian Brauner struct super_block *sb = inode->i_sb;
12289b7365fcSLi Xi struct mnt_idmap *idmap = file_mnt_idmap(filp);
12299b7365fcSLi Xi
12309b7365fcSLi Xi ext4_debug("cmd = %u, arg = %lu\n", cmd, arg);
12319b7365fcSLi Xi
12320c9ec4beSDarrick J. Wong switch (cmd) {
12330c9ec4beSDarrick J. Wong case FS_IOC_GETFSMAP:
1234617ba13bSMingming Cao return ext4_ioc_getfsmap(sb, (void __user *)arg);
1235617ba13bSMingming Cao case EXT4_IOC_GETVERSION:
1236ac27a0ecSDave Kleikamp case EXT4_IOC_GETVERSION_OLD:
1237617ba13bSMingming Cao return put_user(inode->i_generation, (int __user *) arg);
1238617ba13bSMingming Cao case EXT4_IOC_SETVERSION:
1239ac27a0ecSDave Kleikamp case EXT4_IOC_SETVERSION_OLD: {
1240617ba13bSMingming Cao handle_t *handle;
1241ac27a0ecSDave Kleikamp struct ext4_iloc iloc;
1242ac27a0ecSDave Kleikamp __u32 generation;
1243ac27a0ecSDave Kleikamp int err;
124401beba79SChristian Brauner
1245ac27a0ecSDave Kleikamp if (!inode_owner_or_capable(idmap, inode))
124642a74f20SDave Hansen return -EPERM;
12479aa5d32bSDmitry Monakhov
1248814525f4SDarrick J. Wong if (ext4_has_metadata_csum(inode->i_sb)) {
1249814525f4SDarrick J. Wong ext4_warning(sb, "Setting inode version is not "
1250814525f4SDarrick J. Wong "supported with metadata_csum enabled.");
1251814525f4SDarrick J. Wong return -ENOTTY;
1252814525f4SDarrick J. Wong }
1253a561be71SAl Viro
125442a74f20SDave Hansen err = mnt_want_write_file(filp);
125542a74f20SDave Hansen if (err)
125642a74f20SDave Hansen return err;
125742a74f20SDave Hansen if (get_user(generation, (int __user *) arg)) {
125842a74f20SDave Hansen err = -EFAULT;
125942a74f20SDave Hansen goto setversion_out;
1260ac27a0ecSDave Kleikamp }
12615955102cSAl Viro
12629924a92aSTheodore Ts'o inode_lock(inode);
126342a74f20SDave Hansen handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
126442a74f20SDave Hansen if (IS_ERR(handle)) {
12656c2155b9SDjalal Harouni err = PTR_ERR(handle);
126642a74f20SDave Hansen goto unlock_out;
1267617ba13bSMingming Cao }
1268ac27a0ecSDave Kleikamp err = ext4_reserve_inode_write(handle, inode, &iloc);
1269eeca7ea1SDeepa Dinamani if (err == 0) {
1270a642c2c0SJeff Layton inode_set_ctime_current(inode);
1271ac27a0ecSDave Kleikamp inode_inc_iversion(inode);
1272617ba13bSMingming Cao inode->i_generation = generation;
1273ac27a0ecSDave Kleikamp err = ext4_mark_iloc_dirty(handle, inode, &iloc);
1274617ba13bSMingming Cao }
12756c2155b9SDjalal Harouni ext4_journal_stop(handle);
12766c2155b9SDjalal Harouni
12775955102cSAl Viro unlock_out:
127842a74f20SDave Hansen inode_unlock(inode);
12792a79f17eSAl Viro setversion_out:
1280ac27a0ecSDave Kleikamp mnt_drop_write_file(filp);
1281ac27a0ecSDave Kleikamp return err;
1282617ba13bSMingming Cao }
1283617ba13bSMingming Cao case EXT4_IOC_GROUP_EXTEND: {
1284ac046f1dSPeng Tao ext4_fsblk_t n_blocks_count;
1285ac27a0ecSDave Kleikamp int err, err2=0;
12868f82f840SYongqiang Yang
12878f82f840SYongqiang Yang err = ext4_resize_begin(sb);
12888f82f840SYongqiang Yang if (err)
1289ac27a0ecSDave Kleikamp return err;
1290014a1770SDjalal Harouni
1291014a1770SDjalal Harouni if (get_user(n_blocks_count, (__u32 __user *)arg)) {
1292014a1770SDjalal Harouni err = -EFAULT;
1293014a1770SDjalal Harouni goto group_extend_out;
1294ac27a0ecSDave Kleikamp }
12958813587aSTheodore Ts'o
12968813587aSTheodore Ts'o if (ext4_has_feature_bigalloc(sb)) {
12978813587aSTheodore Ts'o ext4_msg(sb, KERN_ERR,
12988813587aSTheodore Ts'o "Online resizing not supported with bigalloc");
12998813587aSTheodore Ts'o err = -EOPNOTSUPP;
13008813587aSTheodore Ts'o goto group_extend_out;
13018813587aSTheodore Ts'o }
1302a561be71SAl Viro
130342a74f20SDave Hansen err = mnt_want_write_file(filp);
1304014a1770SDjalal Harouni if (err)
130542a74f20SDave Hansen goto group_extend_out;
1306617ba13bSMingming Cao
1307ac046f1dSPeng Tao err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count);
1308dab291afSMingming Cao if (EXT4_SB(sb)->s_journal) {
130901d5d965SLeah Rumancik jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
1310dab291afSMingming Cao err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal, 0);
1311ac046f1dSPeng Tao jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
13127ffe1ea8SHidehiro Kawai }
13137ffe1ea8SHidehiro Kawai if (err == 0)
13142a79f17eSAl Viro err = err2;
1315014a1770SDjalal Harouni mnt_drop_write_file(filp);
1316827891a3STheodore Ts'o group_extend_out:
1317827891a3STheodore Ts'o err2 = ext4_resize_end(sb, false);
1318827891a3STheodore Ts'o if (err == 0)
1319ac27a0ecSDave Kleikamp err = err2;
1320ac27a0ecSDave Kleikamp return err;
1321748de673SAkira Fujita }
1322748de673SAkira Fujita
1323748de673SAkira Fujita case EXT4_IOC_MOVE_EXT: {
13242903ff01SAl Viro struct move_extent me;
13252903ff01SAl Viro struct fd donor;
1326748de673SAkira Fujita int err;
13274a58579bSAkira Fujita
13284a58579bSAkira Fujita if (!(filp->f_mode & FMODE_READ) ||
13294a58579bSAkira Fujita !(filp->f_mode & FMODE_WRITE))
13304a58579bSAkira Fujita return -EBADF;
1331748de673SAkira Fujita
1332748de673SAkira Fujita if (copy_from_user(&me,
1333748de673SAkira Fujita (struct move_extent __user *)arg, sizeof(me)))
13344a58579bSAkira Fujita return -EFAULT;
1335748de673SAkira Fujita me.moved_len = 0;
13362903ff01SAl Viro
13372903ff01SAl Viro donor = fdget(me.donor_fd);
1338748de673SAkira Fujita if (!donor.file)
1339748de673SAkira Fujita return -EBADF;
13402903ff01SAl Viro
13414a58579bSAkira Fujita if (!(donor.file->f_mode & FMODE_WRITE)) {
13424a58579bSAkira Fujita err = -EBADF;
1343748de673SAkira Fujita goto mext_out;
1344748de673SAkira Fujita }
1345e2b911c5SDarrick J. Wong
1346bab08ab9STheodore Ts'o if (ext4_has_feature_bigalloc(sb)) {
1347bab08ab9STheodore Ts'o ext4_msg(sb, KERN_ERR,
1348399c9b86SAl Viro "Online defrag not supported with bigalloc");
1349399c9b86SAl Viro err = -EOPNOTSUPP;
135073f34a5eSRoss Zwisler goto mext_out;
135173f34a5eSRoss Zwisler } else if (IS_DAX(inode)) {
135273f34a5eSRoss Zwisler ext4_msg(sb, KERN_ERR,
135373f34a5eSRoss Zwisler "Online defrag not supported with DAX");
135473f34a5eSRoss Zwisler err = -EOPNOTSUPP;
1355bab08ab9STheodore Ts'o goto mext_out;
1356bab08ab9STheodore Ts'o }
1357a561be71SAl Viro
13584a58579bSAkira Fujita err = mnt_want_write_file(filp);
13594a58579bSAkira Fujita if (err)
13604a58579bSAkira Fujita goto mext_out;
13612903ff01SAl Viro
1362748de673SAkira Fujita err = ext4_move_extents(filp, donor.file, me.orig_start,
13632a79f17eSAl Viro me.donor_start, me.len, &me.moved_len);
1364748de673SAkira Fujita mnt_drop_write_file(filp);
1365c437b273SAkira Fujita
1366c437b273SAkira Fujita if (copy_to_user((struct move_extent __user *)arg,
13674a58579bSAkira Fujita &me, sizeof(me)))
13684a58579bSAkira Fujita err = -EFAULT;
13692903ff01SAl Viro mext_out:
1370748de673SAkira Fujita fdput(donor);
1371748de673SAkira Fujita return err;
1372748de673SAkira Fujita }
1373617ba13bSMingming Cao
1374617ba13bSMingming Cao case EXT4_IOC_GROUP_ADD: {
1375ac27a0ecSDave Kleikamp struct ext4_new_group_data input;
1376617ba13bSMingming Cao
1377e145b35bSAl Viro if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,
1378e145b35bSAl Viro sizeof(input)))
1379ac27a0ecSDave Kleikamp return -EFAULT;
1380e145b35bSAl Viro
1381ac27a0ecSDave Kleikamp return ext4_ioctl_group_add(filp, &input);
1382ac27a0ecSDave Kleikamp }
1383c14c6fd5SAneesh Kumar K.V
13842a43a878SAneesh Kumar K.V case EXT4_IOC_MIGRATE:
13852a43a878SAneesh Kumar K.V {
138601beba79SChristian Brauner int err;
13872a43a878SAneesh Kumar K.V if (!inode_owner_or_capable(idmap, inode))
13882a43a878SAneesh Kumar K.V return -EACCES;
1389a561be71SAl Viro
13902a43a878SAneesh Kumar K.V err = mnt_want_write_file(filp);
13912a43a878SAneesh Kumar K.V if (err)
13922a43a878SAneesh Kumar K.V return err;
13932a43a878SAneesh Kumar K.V /*
13942a43a878SAneesh Kumar K.V * inode_mutex prevent write and truncate on the file.
13952a43a878SAneesh Kumar K.V * Read still goes through. We take i_data_sem in
13962a43a878SAneesh Kumar K.V * ext4_ext_swap_inode_data before we switch the
13972a43a878SAneesh Kumar K.V * inode format to prevent read.
13985955102cSAl Viro */
13992a43a878SAneesh Kumar K.V inode_lock((inode));
14005955102cSAl Viro err = ext4_ext_migrate(inode);
14012a79f17eSAl Viro inode_unlock((inode));
14022a43a878SAneesh Kumar K.V mnt_drop_write_file(filp);
14032a43a878SAneesh Kumar K.V return err;
1404c14c6fd5SAneesh Kumar K.V }
1405ccd2506bSTheodore Ts'o
1406ccd2506bSTheodore Ts'o case EXT4_IOC_ALLOC_DA_BLKS:
1407ccd2506bSTheodore Ts'o {
140801beba79SChristian Brauner int err;
1409ccd2506bSTheodore Ts'o if (!inode_owner_or_capable(idmap, inode))
1410ccd2506bSTheodore Ts'o return -EACCES;
1411a561be71SAl Viro
1412ccd2506bSTheodore Ts'o err = mnt_want_write_file(filp);
1413ccd2506bSTheodore Ts'o if (err)
1414ccd2506bSTheodore Ts'o return err;
14152a79f17eSAl Viro err = ext4_alloc_da_blocks(inode);
1416ccd2506bSTheodore Ts'o mnt_drop_write_file(filp);
1417ccd2506bSTheodore Ts'o return err;
1418ccd2506bSTheodore Ts'o }
1419393d1d1dSDr. Tilmann Bubeck
14203e67cfadSDmitry Monakhov case EXT4_IOC_SWAP_BOOT:
14213e67cfadSDmitry Monakhov {
1422393d1d1dSDr. Tilmann Bubeck int err;
1423393d1d1dSDr. Tilmann Bubeck if (!(filp->f_mode & FMODE_WRITE))
14243e67cfadSDmitry Monakhov return -EBADF;
14253e67cfadSDmitry Monakhov err = mnt_want_write_file(filp);
14263e67cfadSDmitry Monakhov if (err)
142701beba79SChristian Brauner return err;
14283e67cfadSDmitry Monakhov err = swap_inode_boot_loader(sb, idmap, inode);
14293e67cfadSDmitry Monakhov mnt_drop_write_file(filp);
14303e67cfadSDmitry Monakhov return err;
1431393d1d1dSDr. Tilmann Bubeck }
143219c5246dSYongqiang Yang
143319c5246dSYongqiang Yang case EXT4_IOC_RESIZE_FS: {
143419c5246dSYongqiang Yang ext4_fsblk_t n_blocks_count;
14357f511862STheodore Ts'o int err = 0, err2 = 0;
143619c5246dSYongqiang Yang ext4_group_t o_group = EXT4_SB(sb)->s_groups_count;
143719c5246dSYongqiang Yang
143819c5246dSYongqiang Yang if (copy_from_user(&n_blocks_count, (__u64 __user *)arg,
143919c5246dSYongqiang Yang sizeof(__u64))) {
144019c5246dSYongqiang Yang return -EFAULT;
144119c5246dSYongqiang Yang }
144219c5246dSYongqiang Yang
144319c5246dSYongqiang Yang err = ext4_resize_begin(sb);
144419c5246dSYongqiang Yang if (err)
144519c5246dSYongqiang Yang return err;
14468cae6f71SAl Viro
144719c5246dSYongqiang Yang err = mnt_want_write_file(filp);
144819c5246dSYongqiang Yang if (err)
144919c5246dSYongqiang Yang goto resizefs_out;
145019c5246dSYongqiang Yang
145119c5246dSYongqiang Yang err = ext4_resize_fs(sb, n_blocks_count);
1452e85c81baSXin Yin if (EXT4_SB(sb)->s_journal) {
145319c5246dSYongqiang Yang ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_RESIZE, NULL);
145401d5d965SLeah Rumancik jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
145519c5246dSYongqiang Yang err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal, 0);
145619c5246dSYongqiang Yang jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
145719c5246dSYongqiang Yang }
145819c5246dSYongqiang Yang if (err == 0)
14598cae6f71SAl Viro err = err2;
1460310a997fSKirill Tkhai mnt_drop_write_file(filp);
14617f511862STheodore Ts'o if (!err && (o_group < EXT4_SB(sb)->s_groups_count) &&
14627f511862STheodore Ts'o ext4_has_group_desc_csum(sb) &&
14637f511862STheodore Ts'o test_opt(sb, INIT_INODE_TABLE))
14647f511862STheodore Ts'o err = ext4_register_li_request(sb, o_group);
146519c5246dSYongqiang Yang
1466827891a3STheodore Ts'o resizefs_out:
1467827891a3STheodore Ts'o err2 = ext4_resize_end(sb, true);
1468827891a3STheodore Ts'o if (err == 0)
146919c5246dSYongqiang Yang err = err2;
147019c5246dSYongqiang Yang return err;
147119c5246dSYongqiang Yang }
1472e681c047SLukas Czerner
1473e681c047SLukas Czerner case FITRIM:
1474e681c047SLukas Czerner {
1475e681c047SLukas Czerner struct fstrim_range range;
1476e681c047SLukas Czerner int ret = 0;
1477e681c047SLukas Czerner
1478e681c047SLukas Czerner if (!capable(CAP_SYS_ADMIN))
1479e681c047SLukas Czerner return -EPERM;
148070200574SChristoph Hellwig
148141431792SLukas Czerner if (!bdev_max_discard_sectors(sb->s_bdev))
148241431792SLukas Czerner return -EOPNOTSUPP;
148318915b58SDarrick J. Wong
148418915b58SDarrick J. Wong /*
148518915b58SDarrick J. Wong * We haven't replayed the journal, so we cannot use our
148618915b58SDarrick J. Wong * block-bitmap-guided storage zapping commands.
148718915b58SDarrick J. Wong */
148818915b58SDarrick J. Wong if (test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb))
148918915b58SDarrick J. Wong return -EROFS;
1490e6705f7cSH Hartley Sweeten
1491e681c047SLukas Czerner if (copy_from_user(&range, (struct fstrim_range __user *)arg,
1492e681c047SLukas Czerner sizeof(range)))
1493e681c047SLukas Czerner return -EFAULT;
1494e681c047SLukas Czerner
1495e681c047SLukas Czerner ret = ext4_trim_fs(sb, &range);
1496e681c047SLukas Czerner if (ret < 0)
1497e681c047SLukas Czerner return ret;
1498e6705f7cSH Hartley Sweeten
1499e681c047SLukas Czerner if (copy_to_user((struct fstrim_range __user *)arg, &range,
1500e681c047SLukas Czerner sizeof(range)))
1501e681c047SLukas Czerner return -EFAULT;
1502e681c047SLukas Czerner
1503e681c047SLukas Czerner return 0;
15047869a4a6STheodore Ts'o }
15057869a4a6STheodore Ts'o case EXT4_IOC_PRECACHE_EXTENTS:
1506e681c047SLukas Czerner return ext4_ext_precache(inode);
1507cb29a02dSEric Biggers
15089a200d07SRichard Weinberger case FS_IOC_SET_ENCRYPTION_POLICY:
15099a200d07SRichard Weinberger if (!ext4_has_feature_encrypt(sb))
1510db717d8eSEric Biggers return -EOPNOTSUPP;
15119a200d07SRichard Weinberger return fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
151272f63f4aSRitesh Harjani
151372f63f4aSRitesh Harjani case FS_IOC_GET_ENCRYPTION_PWSALT:
15149bd8212fSMichael Halcrow return ext4_ioctl_get_encryption_pwsalt(filp, (void __user *)arg);
1515cb29a02dSEric Biggers
15160642ea24SChao Yu case FS_IOC_GET_ENCRYPTION_POLICY:
15170642ea24SChao Yu if (!ext4_has_feature_encrypt(sb))
1518db717d8eSEric Biggers return -EOPNOTSUPP;
15199bd8212fSMichael Halcrow return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
152029b3692eSEric Biggers
152129b3692eSEric Biggers case FS_IOC_GET_ENCRYPTION_POLICY_EX:
152229b3692eSEric Biggers if (!ext4_has_feature_encrypt(sb))
152329b3692eSEric Biggers return -EOPNOTSUPP;
152429b3692eSEric Biggers return fscrypt_ioctl_get_policy_ex(filp, (void __user *)arg);
152529b3692eSEric Biggers
152629b3692eSEric Biggers case FS_IOC_ADD_ENCRYPTION_KEY:
152729b3692eSEric Biggers if (!ext4_has_feature_encrypt(sb))
152829b3692eSEric Biggers return -EOPNOTSUPP;
152929b3692eSEric Biggers return fscrypt_ioctl_add_key(filp, (void __user *)arg);
153029b3692eSEric Biggers
153129b3692eSEric Biggers case FS_IOC_REMOVE_ENCRYPTION_KEY:
153229b3692eSEric Biggers if (!ext4_has_feature_encrypt(sb))
153329b3692eSEric Biggers return -EOPNOTSUPP;
153429b3692eSEric Biggers return fscrypt_ioctl_remove_key(filp, (void __user *)arg);
153529b3692eSEric Biggers
153629b3692eSEric Biggers case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
153729b3692eSEric Biggers if (!ext4_has_feature_encrypt(sb))
153829b3692eSEric Biggers return -EOPNOTSUPP;
153929b3692eSEric Biggers return fscrypt_ioctl_remove_key_all_users(filp,
154029b3692eSEric Biggers (void __user *)arg);
154129b3692eSEric Biggers case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
154229b3692eSEric Biggers if (!ext4_has_feature_encrypt(sb))
154329b3692eSEric Biggers return -EOPNOTSUPP;
154429b3692eSEric Biggers return fscrypt_ioctl_get_key_status(filp, (void __user *)arg);
15457ec9f3b4SEric Biggers
15467ec9f3b4SEric Biggers case FS_IOC_GET_ENCRYPTION_NONCE:
15477ec9f3b4SEric Biggers if (!ext4_has_feature_encrypt(sb))
15487ec9f3b4SEric Biggers return -EOPNOTSUPP;
15497ec9f3b4SEric Biggers return fscrypt_ioctl_get_nonce(filp, (void __user *)arg);
1550b0c013e2STheodore Ts'o
1551b0c013e2STheodore Ts'o case EXT4_IOC_CLEAR_ES_CACHE:
155201beba79SChristian Brauner {
1553b0c013e2STheodore Ts'o if (!inode_owner_or_capable(idmap, inode))
1554b0c013e2STheodore Ts'o return -EACCES;
1555b0c013e2STheodore Ts'o ext4_clear_inode_es(inode);
1556b0c013e2STheodore Ts'o return 0;
1557b0c013e2STheodore Ts'o }
15581ad3ea6eSTheodore Ts'o
15591ad3ea6eSTheodore Ts'o case EXT4_IOC_GETSTATE:
15601ad3ea6eSTheodore Ts'o {
15611ad3ea6eSTheodore Ts'o __u32 state = 0;
15621ad3ea6eSTheodore Ts'o
15631ad3ea6eSTheodore Ts'o if (ext4_test_inode_state(inode, EXT4_STATE_EXT_PRECACHED))
15641ad3ea6eSTheodore Ts'o state |= EXT4_STATE_FLAG_EXT_PRECACHED;
15651ad3ea6eSTheodore Ts'o if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
15661ad3ea6eSTheodore Ts'o state |= EXT4_STATE_FLAG_NEW;
15671ad3ea6eSTheodore Ts'o if (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY))
15681ad3ea6eSTheodore Ts'o state |= EXT4_STATE_FLAG_NEWENTRY;
15691ad3ea6eSTheodore Ts'o if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE))
15701ad3ea6eSTheodore Ts'o state |= EXT4_STATE_FLAG_DA_ALLOC_CLOSE;
15711ad3ea6eSTheodore Ts'o
15721ad3ea6eSTheodore Ts'o return put_user(state, (__u32 __user *) arg);
15731ad3ea6eSTheodore Ts'o }
1574bb5835edSTheodore Ts'o
1575bb5835edSTheodore Ts'o case EXT4_IOC_GET_ES_CACHE:
1576bb5835edSTheodore Ts'o return ext4_ioctl_get_es_cache(filp, arg);
1577e9be2ac7STheodore Ts'o
157897524b45SChristoph Hellwig case EXT4_IOC_SHUTDOWN:
1579c93d8f88SEric Biggers return ext4_ioctl_shutdown(sb, arg);
1580c93d8f88SEric Biggers
1581c93d8f88SEric Biggers case FS_IOC_ENABLE_VERITY:
1582c93d8f88SEric Biggers if (!ext4_has_feature_verity(sb))
1583c93d8f88SEric Biggers return -EOPNOTSUPP;
1584c93d8f88SEric Biggers return fsverity_ioctl_enable(filp, (const void __user *)arg);
1585c93d8f88SEric Biggers
1586c93d8f88SEric Biggers case FS_IOC_MEASURE_VERITY:
1587c93d8f88SEric Biggers if (!ext4_has_feature_verity(sb))
1588c93d8f88SEric Biggers return -EOPNOTSUPP;
1589c93d8f88SEric Biggers return fsverity_ioctl_measure(filp, (void __user *)arg);
1590e17fe657SEric Biggers
1591e17fe657SEric Biggers case FS_IOC_READ_VERITY_METADATA:
1592e17fe657SEric Biggers if (!ext4_has_feature_verity(sb))
1593e17fe657SEric Biggers return -EOPNOTSUPP;
1594e17fe657SEric Biggers return fsverity_ioctl_read_metadata(filp,
1595e17fe657SEric Biggers (const void __user *)arg);
1596351a0a3fSLeah Rumancik
1597351a0a3fSLeah Rumancik case EXT4_IOC_CHECKPOINT:
1598351a0a3fSLeah Rumancik return ext4_ioctl_checkpoint(filp, arg);
1599bbc605cdSLukas Czerner
1600bbc605cdSLukas Czerner case FS_IOC_GETFSLABEL:
1601bbc605cdSLukas Czerner return ext4_ioctl_getlabel(EXT4_SB(sb), (void __user *)arg);
1602bbc605cdSLukas Czerner
1603bbc605cdSLukas Czerner case FS_IOC_SETFSLABEL:
1604bbc605cdSLukas Czerner return ext4_ioctl_setlabel(filp,
1605bbc605cdSLukas Czerner (const void __user *)arg);
1606d95efb14SJeremy Bongio
1607d95efb14SJeremy Bongio case EXT4_IOC_GETFSUUID:
1608d95efb14SJeremy Bongio return ext4_ioctl_getuuid(EXT4_SB(sb), (void __user *)arg);
1609d95efb14SJeremy Bongio case EXT4_IOC_SETFSUUID:
1610ac27a0ecSDave Kleikamp return ext4_ioctl_setuuid(filp, (const void __user *)arg);
1611ac27a0ecSDave Kleikamp default:
1612ac27a0ecSDave Kleikamp return -ENOTTY;
1613ac27a0ecSDave Kleikamp }
1614ac27a0ecSDave Kleikamp }
1615aa75f4d3SHarshad Shirwadkar
ext4_ioctl(struct file * filp,unsigned int cmd,unsigned long arg)1616aa75f4d3SHarshad Shirwadkar long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
16172729cfdcSHarshad Shirwadkar {
1618aa75f4d3SHarshad Shirwadkar return __ext4_ioctl(filp, cmd, arg);
1619aa75f4d3SHarshad Shirwadkar }
1620ac27a0ecSDave Kleikamp
1621617ba13bSMingming Cao #ifdef CONFIG_COMPAT
ext4_compat_ioctl(struct file * file,unsigned int cmd,unsigned long arg)1622ac27a0ecSDave Kleikamp long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1623ac27a0ecSDave Kleikamp {
1624ac27a0ecSDave Kleikamp /* These are just misnamed, they actually get/put from/to user an int */
1625617ba13bSMingming Cao switch (cmd) {
1626617ba13bSMingming Cao case EXT4_IOC32_GETVERSION:
1627ac27a0ecSDave Kleikamp cmd = EXT4_IOC_GETVERSION;
1628617ba13bSMingming Cao break;
1629617ba13bSMingming Cao case EXT4_IOC32_SETVERSION:
1630ac27a0ecSDave Kleikamp cmd = EXT4_IOC_SETVERSION;
1631617ba13bSMingming Cao break;
1632617ba13bSMingming Cao case EXT4_IOC32_GROUP_EXTEND:
1633ac27a0ecSDave Kleikamp cmd = EXT4_IOC_GROUP_EXTEND;
1634617ba13bSMingming Cao break;
1635617ba13bSMingming Cao case EXT4_IOC32_GETVERSION_OLD:
1636ac27a0ecSDave Kleikamp cmd = EXT4_IOC_GETVERSION_OLD;
1637617ba13bSMingming Cao break;
1638617ba13bSMingming Cao case EXT4_IOC32_SETVERSION_OLD:
1639ac27a0ecSDave Kleikamp cmd = EXT4_IOC_SETVERSION_OLD;
1640617ba13bSMingming Cao break;
1641617ba13bSMingming Cao case EXT4_IOC32_GETRSVSZ:
1642ac27a0ecSDave Kleikamp cmd = EXT4_IOC_GETRSVSZ;
1643617ba13bSMingming Cao break;
1644617ba13bSMingming Cao case EXT4_IOC32_SETRSVSZ:
1645ac27a0ecSDave Kleikamp cmd = EXT4_IOC_SETRSVSZ;
16464d92dc0fSBen Hutchings break;
16474d92dc0fSBen Hutchings case EXT4_IOC32_GROUP_ADD: {
1648e145b35bSAl Viro struct compat_ext4_new_group_input __user *uinput;
16494d92dc0fSBen Hutchings struct ext4_new_group_data input;
16504d92dc0fSBen Hutchings int err;
16514d92dc0fSBen Hutchings
16524d92dc0fSBen Hutchings uinput = compat_ptr(arg);
16534d92dc0fSBen Hutchings err = get_user(input.group, &uinput->group);
16544d92dc0fSBen Hutchings err |= get_user(input.block_bitmap, &uinput->block_bitmap);
16554d92dc0fSBen Hutchings err |= get_user(input.inode_bitmap, &uinput->inode_bitmap);
16564d92dc0fSBen Hutchings err |= get_user(input.inode_table, &uinput->inode_table);
16574d92dc0fSBen Hutchings err |= get_user(input.blocks_count, &uinput->blocks_count);
16584d92dc0fSBen Hutchings err |= get_user(input.reserved_blocks,
16594d92dc0fSBen Hutchings &uinput->reserved_blocks);
16604d92dc0fSBen Hutchings if (err)
1661e145b35bSAl Viro return -EFAULT;
16624d92dc0fSBen Hutchings return ext4_ioctl_group_add(file, &input);
1663b684b2eeSChristian Borntraeger }
166419c5246dSYongqiang Yang case EXT4_IOC_MOVE_EXT:
1665314999dcSArnd Bergmann case EXT4_IOC_RESIZE_FS:
16667869a4a6STheodore Ts'o case FITRIM:
1667cb29a02dSEric Biggers case EXT4_IOC_PRECACHE_EXTENTS:
1668cb29a02dSEric Biggers case FS_IOC_SET_ENCRYPTION_POLICY:
1669cb29a02dSEric Biggers case FS_IOC_GET_ENCRYPTION_PWSALT:
167029b3692eSEric Biggers case FS_IOC_GET_ENCRYPTION_POLICY:
167129b3692eSEric Biggers case FS_IOC_GET_ENCRYPTION_POLICY_EX:
167229b3692eSEric Biggers case FS_IOC_ADD_ENCRYPTION_KEY:
167329b3692eSEric Biggers case FS_IOC_REMOVE_ENCRYPTION_KEY:
167429b3692eSEric Biggers case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
16757ec9f3b4SEric Biggers case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
1676e9be2ac7STheodore Ts'o case FS_IOC_GET_ENCRYPTION_NONCE:
16770c9ec4beSDarrick J. Wong case EXT4_IOC_SHUTDOWN:
1678c93d8f88SEric Biggers case FS_IOC_GETFSMAP:
1679c93d8f88SEric Biggers case FS_IOC_ENABLE_VERITY:
1680e17fe657SEric Biggers case FS_IOC_MEASURE_VERITY:
1681b0c013e2STheodore Ts'o case FS_IOC_READ_VERITY_METADATA:
16821ad3ea6eSTheodore Ts'o case EXT4_IOC_CLEAR_ES_CACHE:
1683bb5835edSTheodore Ts'o case EXT4_IOC_GETSTATE:
1684351a0a3fSLeah Rumancik case EXT4_IOC_GET_ES_CACHE:
1685bbc605cdSLukas Czerner case EXT4_IOC_CHECKPOINT:
1686bbc605cdSLukas Czerner case FS_IOC_GETFSLABEL:
1687d95efb14SJeremy Bongio case FS_IOC_SETFSLABEL:
1688d95efb14SJeremy Bongio case EXT4_IOC_GETFSUUID:
1689b684b2eeSChristian Borntraeger case EXT4_IOC_SETFSUUID:
1690ac27a0ecSDave Kleikamp break;
1691ac27a0ecSDave Kleikamp default:
1692ac27a0ecSDave Kleikamp return -ENOIOCTLCMD;
16935cdd7b2dSAndi Kleen }
1694ac27a0ecSDave Kleikamp return ext4_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
1695ac27a0ecSDave Kleikamp }
1696eb705421STheodore Ts'o #endif
1697eb705421STheodore Ts'o
set_overhead(struct ext4_super_block * es,const void * arg)1698eb705421STheodore Ts'o static void set_overhead(struct ext4_super_block *es, const void *arg)
1699eb705421STheodore Ts'o {
1700eb705421STheodore Ts'o es->s_overhead_clusters = cpu_to_le32(*((unsigned long *) arg));
1701eb705421STheodore Ts'o }
1702827891a3STheodore Ts'o
ext4_update_overhead(struct super_block * sb,bool force)1703eb705421STheodore Ts'o int ext4_update_overhead(struct super_block *sb, bool force)
1704eb705421STheodore Ts'o {
1705eb705421STheodore Ts'o struct ext4_sb_info *sbi = EXT4_SB(sb);
1706827891a3STheodore Ts'o
1707eb705421STheodore Ts'o if (sb_rdonly(sb))
1708827891a3STheodore Ts'o return 0;
1709827891a3STheodore Ts'o if (!force &&
1710827891a3STheodore Ts'o (sbi->s_overhead == 0 ||
1711827891a3STheodore Ts'o sbi->s_overhead == le32_to_cpu(sbi->s_es->s_overhead_clusters)))
1712eb705421STheodore Ts'o return 0;
1713eb705421STheodore Ts'o return ext4_update_superblocks_fn(sb, set_overhead, &sbi->s_overhead);
1714 }
1715