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