?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cpuset: restore sanity to cpuset_cpus_allowed_fallback()
[linux/fpc-iii.git] / fs / ext4 / ioctl.c
blob53d57cdf3c4d8876f10095b703f80f799aece343
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * linux/fs/ext4/ioctl.c
4 *
5 * Copyright (C) 1993, 1994, 1995
6 * Remy Card (card@masi.ibp.fr)
7 * Laboratoire MASI - Institut Blaise Pascal
8 * Universite Pierre et Marie Curie (Paris VI)
9 */
10
11 #include <linux/fs.h>
12 #include <linux/capability.h>
13 #include <linux/time.h>
14 #include <linux/compat.h>
15 #include <linux/mount.h>
16 #include <linux/file.h>
17 #include <linux/quotaops.h>
18 #include <linux/random.h>
19 #include <linux/uuid.h>
20 #include <linux/uaccess.h>
21 #include <linux/delay.h>
22 #include <linux/iversion.h>
23 #include "ext4_jbd2.h"
24 #include "ext4.h"
25 #include <linux/fsmap.h>
26 #include "fsmap.h"
27 #include <trace/events/ext4.h>
28
29 /**
30 * Swap memory between @a and @b for @len bytes.
31 *
32 * @a: pointer to first memory area
33 * @b: pointer to second memory area
34 * @len: number of bytes to swap
35 *
36 */
37 static void memswap(void *a, void *b, size_t len)
38 {
39 unsigned char *ap, *bp;
40
41 ap = (unsigned char *)a;
42 bp = (unsigned char *)b;
43 while (len-- > 0) {
44 swap(*ap, *bp);
45 ap++;
46 bp++;
47 }
48 }
49
50 /**
51 * Swap i_data and associated attributes between @inode1 and @inode2.
52 * This function is used for the primary swap between inode1 and inode2
53 * and also to revert this primary swap in case of errors.
54 *
55 * Therefore you have to make sure, that calling this method twice
56 * will revert all changes.
57 *
58 * @inode1: pointer to first inode
59 * @inode2: pointer to second inode
60 */
61 static void swap_inode_data(struct inode *inode1, struct inode *inode2)
62 {
63 loff_t isize;
64 struct ext4_inode_info *ei1;
65 struct ext4_inode_info *ei2;
66 unsigned long tmp;
67
68 ei1 = EXT4_I(inode1);
69 ei2 = EXT4_I(inode2);
70
71 swap(inode1->i_version, inode2->i_version);
72 swap(inode1->i_atime, inode2->i_atime);
73 swap(inode1->i_mtime, inode2->i_mtime);
74
75 memswap(ei1->i_data, ei2->i_data, sizeof(ei1->i_data));
76 tmp = ei1->i_flags & EXT4_FL_SHOULD_SWAP;
77 ei1->i_flags = (ei2->i_flags & EXT4_FL_SHOULD_SWAP) |
78 (ei1->i_flags & ~EXT4_FL_SHOULD_SWAP);
79 ei2->i_flags = tmp | (ei2->i_flags & ~EXT4_FL_SHOULD_SWAP);
80 swap(ei1->i_disksize, ei2->i_disksize);
81 ext4_es_remove_extent(inode1, 0, EXT_MAX_BLOCKS);
82 ext4_es_remove_extent(inode2, 0, EXT_MAX_BLOCKS);
83
84 isize = i_size_read(inode1);
85 i_size_write(inode1, i_size_read(inode2));
86 i_size_write(inode2, isize);
87 }
88
89 static void reset_inode_seed(struct inode *inode)
90 {
91 struct ext4_inode_info *ei = EXT4_I(inode);
92 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
93 __le32 inum = cpu_to_le32(inode->i_ino);
94 __le32 gen = cpu_to_le32(inode->i_generation);
95 __u32 csum;
96
97 if (!ext4_has_metadata_csum(inode->i_sb))
98 return;
99
100 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum, sizeof(inum));
101 ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen, sizeof(gen));
102 }
103
104 /**
105 * Swap the information from the given @inode and the inode
106 * EXT4_BOOT_LOADER_INO. It will basically swap i_data and all other
107 * important fields of the inodes.
108 *
109 * @sb: the super block of the filesystem
110 * @inode: the inode to swap with EXT4_BOOT_LOADER_INO
111 *
112 */
113 static long swap_inode_boot_loader(struct super_block *sb,
114 struct inode *inode)
115 {
116 handle_t *handle;
117 int err;
118 struct inode *inode_bl;
119 struct ext4_inode_info *ei_bl;
120 qsize_t size, size_bl, diff;
121 blkcnt_t blocks;
122 unsigned short bytes;
123
124 inode_bl = ext4_iget(sb, EXT4_BOOT_LOADER_INO, EXT4_IGET_SPECIAL);
125 if (IS_ERR(inode_bl))
126 return PTR_ERR(inode_bl);
127 ei_bl = EXT4_I(inode_bl);
128
129 /* Protect orig inodes against a truncate and make sure,
130 * that only 1 swap_inode_boot_loader is running. */
131 lock_two_nondirectories(inode, inode_bl);
132
133 if (inode->i_nlink != 1 || !S_ISREG(inode->i_mode) ||
134 IS_SWAPFILE(inode) || IS_ENCRYPTED(inode) ||
135 ext4_has_inline_data(inode)) {
136 err = -EINVAL;
137 goto journal_err_out;
138 }
139
140 if (IS_RDONLY(inode) || IS_APPEND(inode) || IS_IMMUTABLE(inode) ||
141 !inode_owner_or_capable(inode) || !capable(CAP_SYS_ADMIN)) {
142 err = -EPERM;
143 goto journal_err_out;
144 }
145
146 down_write(&EXT4_I(inode)->i_mmap_sem);
147 err = filemap_write_and_wait(inode->i_mapping);
148 if (err)
149 goto err_out;
150
151 err = filemap_write_and_wait(inode_bl->i_mapping);
152 if (err)
153 goto err_out;
154
155 /* Wait for all existing dio workers */
156 inode_dio_wait(inode);
157 inode_dio_wait(inode_bl);
158
159 truncate_inode_pages(&inode->i_data, 0);
160 truncate_inode_pages(&inode_bl->i_data, 0);
161
162 handle = ext4_journal_start(inode_bl, EXT4_HT_MOVE_EXTENTS, 2);
163 if (IS_ERR(handle)) {
164 err = -EINVAL;
165 goto err_out;
166 }
167
168 /* Protect extent tree against block allocations via delalloc */
169 ext4_double_down_write_data_sem(inode, inode_bl);
170
171 if (inode_bl->i_nlink == 0) {
172 /* this inode has never been used as a BOOT_LOADER */
173 set_nlink(inode_bl, 1);
174 i_uid_write(inode_bl, 0);
175 i_gid_write(inode_bl, 0);
176 inode_bl->i_flags = 0;
177 ei_bl->i_flags = 0;
178 inode_set_iversion(inode_bl, 1);
179 i_size_write(inode_bl, 0);
180 inode_bl->i_mode = S_IFREG;
181 if (ext4_has_feature_extents(sb)) {
182 ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS);
183 ext4_ext_tree_init(handle, inode_bl);
184 } else
185 memset(ei_bl->i_data, 0, sizeof(ei_bl->i_data));
186 }
187
188 err = dquot_initialize(inode);
189 if (err)
190 goto err_out1;
191
192 size = (qsize_t)(inode->i_blocks) * (1 << 9) + inode->i_bytes;
193 size_bl = (qsize_t)(inode_bl->i_blocks) * (1 << 9) + inode_bl->i_bytes;
194 diff = size - size_bl;
195 swap_inode_data(inode, inode_bl);
196
197 inode->i_ctime = inode_bl->i_ctime = current_time(inode);
198
199 inode->i_generation = prandom_u32();
200 inode_bl->i_generation = prandom_u32();
201 reset_inode_seed(inode);
202 reset_inode_seed(inode_bl);
203
204 ext4_discard_preallocations(inode);
205
206 err = ext4_mark_inode_dirty(handle, inode);
207 if (err < 0) {
208 /* No need to update quota information. */
209 ext4_warning(inode->i_sb,
210 "couldn't mark inode #%lu dirty (err %d)",
211 inode->i_ino, err);
212 /* Revert all changes: */
213 swap_inode_data(inode, inode_bl);
214 ext4_mark_inode_dirty(handle, inode);
215 goto err_out1;
216 }
217
218 blocks = inode_bl->i_blocks;
219 bytes = inode_bl->i_bytes;
220 inode_bl->i_blocks = inode->i_blocks;
221 inode_bl->i_bytes = inode->i_bytes;
222 err = ext4_mark_inode_dirty(handle, inode_bl);
223 if (err < 0) {
224 /* No need to update quota information. */
225 ext4_warning(inode_bl->i_sb,
226 "couldn't mark inode #%lu dirty (err %d)",
227 inode_bl->i_ino, err);
228 goto revert;
229 }
230
231 /* Bootloader inode should not be counted into quota information. */
232 if (diff > 0)
233 dquot_free_space(inode, diff);
234 else
235 err = dquot_alloc_space(inode, -1 * diff);
236
237 if (err < 0) {
238 revert:
239 /* Revert all changes: */
240 inode_bl->i_blocks = blocks;
241 inode_bl->i_bytes = bytes;
242 swap_inode_data(inode, inode_bl);
243 ext4_mark_inode_dirty(handle, inode);
244 ext4_mark_inode_dirty(handle, inode_bl);
245 }
246
247 err_out1:
248 ext4_journal_stop(handle);
249 ext4_double_up_write_data_sem(inode, inode_bl);
250
251 err_out:
252 up_write(&EXT4_I(inode)->i_mmap_sem);
253 journal_err_out:
254 unlock_two_nondirectories(inode, inode_bl);
255 iput(inode_bl);
256 return err;
257 }
258
259 #ifdef CONFIG_EXT4_FS_ENCRYPTION
260 static int uuid_is_zero(__u8 u[16])
261 {
262 int i;
263
264 for (i = 0; i < 16; i++)
265 if (u[i])
266 return 0;
267 return 1;
268 }
269 #endif
270
271 static int ext4_ioctl_setflags(struct inode *inode,
272 unsigned int flags)
273 {
274 struct ext4_inode_info *ei = EXT4_I(inode);
275 handle_t *handle = NULL;
276 int err = -EPERM, migrate = 0;
277 struct ext4_iloc iloc;
278 unsigned int oldflags, mask, i;
279 unsigned int jflag;
280
281 /* Is it quota file? Do not allow user to mess with it */
282 if (ext4_is_quota_file(inode))
283 goto flags_out;
284
285 oldflags = ei->i_flags;
286
287 /* The JOURNAL_DATA flag is modifiable only by root */
288 jflag = flags & EXT4_JOURNAL_DATA_FL;
289
290 /*
291 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
292 * the relevant capability.
293 *
294 * This test looks nicer. Thanks to Pauline Middelink
295 */
296 if ((flags ^ oldflags) & (EXT4_APPEND_FL | EXT4_IMMUTABLE_FL)) {
297 if (!capable(CAP_LINUX_IMMUTABLE))
298 goto flags_out;
299 }
300
301 /*
302 * The JOURNAL_DATA flag can only be changed by
303 * the relevant capability.
304 */
305 if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
306 if (!capable(CAP_SYS_RESOURCE))
307 goto flags_out;
308 }
309 if ((flags ^ oldflags) & EXT4_EXTENTS_FL)
310 migrate = 1;
311
312 if (flags & EXT4_EOFBLOCKS_FL) {
313 /* we don't support adding EOFBLOCKS flag */
314 if (!(oldflags & EXT4_EOFBLOCKS_FL)) {
315 err = -EOPNOTSUPP;
316 goto flags_out;
317 }
318 } else if (oldflags & EXT4_EOFBLOCKS_FL) {
319 err = ext4_truncate(inode);
320 if (err)
321 goto flags_out;
322 }
323
324 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
325 if (IS_ERR(handle)) {
326 err = PTR_ERR(handle);
327 goto flags_out;
328 }
329 if (IS_SYNC(inode))
330 ext4_handle_sync(handle);
331 err = ext4_reserve_inode_write(handle, inode, &iloc);
332 if (err)
333 goto flags_err;
334
335 for (i = 0, mask = 1; i < 32; i++, mask <<= 1) {
336 if (!(mask & EXT4_FL_USER_MODIFIABLE))
337 continue;
338 /* These flags get special treatment later */
339 if (mask == EXT4_JOURNAL_DATA_FL || mask == EXT4_EXTENTS_FL)
340 continue;
341 if (mask & flags)
342 ext4_set_inode_flag(inode, i);
343 else
344 ext4_clear_inode_flag(inode, i);
345 }
346
347 ext4_set_inode_flags(inode);
348 inode->i_ctime = current_time(inode);
349
350 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
351 flags_err:
352 ext4_journal_stop(handle);
353 if (err)
354 goto flags_out;
355
356 if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
357 /*
358 * Changes to the journaling mode can cause unsafe changes to
359 * S_DAX if we are using the DAX mount option.
360 */
361 if (test_opt(inode->i_sb, DAX)) {
362 err = -EBUSY;
363 goto flags_out;
364 }
365
366 err = ext4_change_inode_journal_flag(inode, jflag);
367 if (err)
368 goto flags_out;
369 }
370 if (migrate) {
371 if (flags & EXT4_EXTENTS_FL)
372 err = ext4_ext_migrate(inode);
373 else
374 err = ext4_ind_migrate(inode);
375 }
376
377 flags_out:
378 return err;
379 }
380
381 #ifdef CONFIG_QUOTA
382 static int ext4_ioctl_setproject(struct file *filp, __u32 projid)
383 {
384 struct inode *inode = file_inode(filp);
385 struct super_block *sb = inode->i_sb;
386 struct ext4_inode_info *ei = EXT4_I(inode);
387 int err, rc;
388 handle_t *handle;
389 kprojid_t kprojid;
390 struct ext4_iloc iloc;
391 struct ext4_inode *raw_inode;
392 struct dquot *transfer_to[MAXQUOTAS] = { };
393
394 if (!ext4_has_feature_project(sb)) {
395 if (projid != EXT4_DEF_PROJID)
396 return -EOPNOTSUPP;
397 else
398 return 0;
399 }
400
401 if (EXT4_INODE_SIZE(sb) <= EXT4_GOOD_OLD_INODE_SIZE)
402 return -EOPNOTSUPP;
403
404 kprojid = make_kprojid(&init_user_ns, (projid_t)projid);
405
406 if (projid_eq(kprojid, EXT4_I(inode)->i_projid))
407 return 0;
408
409 err = -EPERM;
410 /* Is it quota file? Do not allow user to mess with it */
411 if (ext4_is_quota_file(inode))
412 return err;
413
414 err = ext4_get_inode_loc(inode, &iloc);
415 if (err)
416 return err;
417
418 raw_inode = ext4_raw_inode(&iloc);
419 if (!EXT4_FITS_IN_INODE(raw_inode, ei, i_projid)) {
420 err = ext4_expand_extra_isize(inode,
421 EXT4_SB(sb)->s_want_extra_isize,
422 &iloc);
423 if (err)
424 return err;
425 } else {
426 brelse(iloc.bh);
427 }
428
429 err = dquot_initialize(inode);
430 if (err)
431 return err;
432
433 handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
434 EXT4_QUOTA_INIT_BLOCKS(sb) +
435 EXT4_QUOTA_DEL_BLOCKS(sb) + 3);
436 if (IS_ERR(handle))
437 return PTR_ERR(handle);
438
439 err = ext4_reserve_inode_write(handle, inode, &iloc);
440 if (err)
441 goto out_stop;
442
443 transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid));
444 if (!IS_ERR(transfer_to[PRJQUOTA])) {
445
446 /* __dquot_transfer() calls back ext4_get_inode_usage() which
447 * counts xattr inode references.
448 */
449 down_read(&EXT4_I(inode)->xattr_sem);
450 err = __dquot_transfer(inode, transfer_to);
451 up_read(&EXT4_I(inode)->xattr_sem);
452 dqput(transfer_to[PRJQUOTA]);
453 if (err)
454 goto out_dirty;
455 }
456
457 EXT4_I(inode)->i_projid = kprojid;
458 inode->i_ctime = current_time(inode);
459 out_dirty:
460 rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
461 if (!err)
462 err = rc;
463 out_stop:
464 ext4_journal_stop(handle);
465 return err;
466 }
467 #else
468 static int ext4_ioctl_setproject(struct file *filp, __u32 projid)
469 {
470 if (projid != EXT4_DEF_PROJID)
471 return -EOPNOTSUPP;
472 return 0;
473 }
474 #endif
475
476 /* Transfer internal flags to xflags */
477 static inline __u32 ext4_iflags_to_xflags(unsigned long iflags)
478 {
479 __u32 xflags = 0;
480
481 if (iflags & EXT4_SYNC_FL)
482 xflags |= FS_XFLAG_SYNC;
483 if (iflags & EXT4_IMMUTABLE_FL)
484 xflags |= FS_XFLAG_IMMUTABLE;
485 if (iflags & EXT4_APPEND_FL)
486 xflags |= FS_XFLAG_APPEND;
487 if (iflags & EXT4_NODUMP_FL)
488 xflags |= FS_XFLAG_NODUMP;
489 if (iflags & EXT4_NOATIME_FL)
490 xflags |= FS_XFLAG_NOATIME;
491 if (iflags & EXT4_PROJINHERIT_FL)
492 xflags |= FS_XFLAG_PROJINHERIT;
493 return xflags;
494 }
495
496 #define EXT4_SUPPORTED_FS_XFLAGS (FS_XFLAG_SYNC | FS_XFLAG_IMMUTABLE | \
497 FS_XFLAG_APPEND | FS_XFLAG_NODUMP | \
498 FS_XFLAG_NOATIME | FS_XFLAG_PROJINHERIT)
499
500 /* Transfer xflags flags to internal */
501 static inline unsigned long ext4_xflags_to_iflags(__u32 xflags)
502 {
503 unsigned long iflags = 0;
504
505 if (xflags & FS_XFLAG_SYNC)
506 iflags |= EXT4_SYNC_FL;
507 if (xflags & FS_XFLAG_IMMUTABLE)
508 iflags |= EXT4_IMMUTABLE_FL;
509 if (xflags & FS_XFLAG_APPEND)
510 iflags |= EXT4_APPEND_FL;
511 if (xflags & FS_XFLAG_NODUMP)
512 iflags |= EXT4_NODUMP_FL;
513 if (xflags & FS_XFLAG_NOATIME)
514 iflags |= EXT4_NOATIME_FL;
515 if (xflags & FS_XFLAG_PROJINHERIT)
516 iflags |= EXT4_PROJINHERIT_FL;
517
518 return iflags;
519 }
520
521 static int ext4_shutdown(struct super_block *sb, unsigned long arg)
522 {
523 struct ext4_sb_info *sbi = EXT4_SB(sb);
524 __u32 flags;
525
526 if (!capable(CAP_SYS_ADMIN))
527 return -EPERM;
528
529 if (get_user(flags, (__u32 __user *)arg))
530 return -EFAULT;
531
532 if (flags > EXT4_GOING_FLAGS_NOLOGFLUSH)
533 return -EINVAL;
534
535 if (ext4_forced_shutdown(sbi))
536 return 0;
537
538 ext4_msg(sb, KERN_ALERT, "shut down requested (%d)", flags);
539 trace_ext4_shutdown(sb, flags);
540
541 switch (flags) {
542 case EXT4_GOING_FLAGS_DEFAULT:
543 freeze_bdev(sb->s_bdev);
544 set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
545 thaw_bdev(sb->s_bdev, sb);
546 break;
547 case EXT4_GOING_FLAGS_LOGFLUSH:
548 set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
549 if (sbi->s_journal && !is_journal_aborted(sbi->s_journal)) {
550 (void) ext4_force_commit(sb);
551 jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN);
552 }
553 break;
554 case EXT4_GOING_FLAGS_NOLOGFLUSH:
555 set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
556 if (sbi->s_journal && !is_journal_aborted(sbi->s_journal))
557 jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN);
558 break;
559 default:
560 return -EINVAL;
561 }
562 clear_opt(sb, DISCARD);
563 return 0;
564 }
565
566 struct getfsmap_info {
567 struct super_block *gi_sb;
568 struct fsmap_head __user *gi_data;
569 unsigned int gi_idx;
570 __u32 gi_last_flags;
571 };
572
573 static int ext4_getfsmap_format(struct ext4_fsmap *xfm, void *priv)
574 {
575 struct getfsmap_info *info = priv;
576 struct fsmap fm;
577
578 trace_ext4_getfsmap_mapping(info->gi_sb, xfm);
579
580 info->gi_last_flags = xfm->fmr_flags;
581 ext4_fsmap_from_internal(info->gi_sb, &fm, xfm);
582 if (copy_to_user(&info->gi_data->fmh_recs[info->gi_idx++], &fm,
583 sizeof(struct fsmap)))
584 return -EFAULT;
585
586 return 0;
587 }
588
589 static int ext4_ioc_getfsmap(struct super_block *sb,
590 struct fsmap_head __user *arg)
591 {
592 struct getfsmap_info info = {0};
593 struct ext4_fsmap_head xhead = {0};
594 struct fsmap_head head;
595 bool aborted = false;
596 int error;
597
598 if (copy_from_user(&head, arg, sizeof(struct fsmap_head)))
599 return -EFAULT;
600 if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) ||
601 memchr_inv(head.fmh_keys[0].fmr_reserved, 0,
602 sizeof(head.fmh_keys[0].fmr_reserved)) ||
603 memchr_inv(head.fmh_keys[1].fmr_reserved, 0,
604 sizeof(head.fmh_keys[1].fmr_reserved)))
605 return -EINVAL;
606 /*
607 * ext4 doesn't report file extents at all, so the only valid
608 * file offsets are the magic ones (all zeroes or all ones).
609 */
610 if (head.fmh_keys[0].fmr_offset ||
611 (head.fmh_keys[1].fmr_offset != 0 &&
612 head.fmh_keys[1].fmr_offset != -1ULL))
613 return -EINVAL;
614
615 xhead.fmh_iflags = head.fmh_iflags;
616 xhead.fmh_count = head.fmh_count;
617 ext4_fsmap_to_internal(sb, &xhead.fmh_keys[0], &head.fmh_keys[0]);
618 ext4_fsmap_to_internal(sb, &xhead.fmh_keys[1], &head.fmh_keys[1]);
619
620 trace_ext4_getfsmap_low_key(sb, &xhead.fmh_keys[0]);
621 trace_ext4_getfsmap_high_key(sb, &xhead.fmh_keys[1]);
622
623 info.gi_sb = sb;
624 info.gi_data = arg;
625 error = ext4_getfsmap(sb, &xhead, ext4_getfsmap_format, &info);
626 if (error == EXT4_QUERY_RANGE_ABORT) {
627 error = 0;
628 aborted = true;
629 } else if (error)
630 return error;
631
632 /* If we didn't abort, set the "last" flag in the last fmx */
633 if (!aborted && info.gi_idx) {
634 info.gi_last_flags |= FMR_OF_LAST;
635 if (copy_to_user(&info.gi_data->fmh_recs[info.gi_idx - 1].fmr_flags,
636 &info.gi_last_flags,
637 sizeof(info.gi_last_flags)))
638 return -EFAULT;
639 }
640
641 /* copy back header */
642 head.fmh_entries = xhead.fmh_entries;
643 head.fmh_oflags = xhead.fmh_oflags;
644 if (copy_to_user(arg, &head, sizeof(struct fsmap_head)))
645 return -EFAULT;
646
647 return 0;
648 }
649
650 static long ext4_ioctl_group_add(struct file *file,
651 struct ext4_new_group_data *input)
652 {
653 struct super_block *sb = file_inode(file)->i_sb;
654 int err, err2=0;
655
656 err = ext4_resize_begin(sb);
657 if (err)
658 return err;
659
660 if (ext4_has_feature_bigalloc(sb)) {
661 ext4_msg(sb, KERN_ERR,
662 "Online resizing not supported with bigalloc");
663 err = -EOPNOTSUPP;
664 goto group_add_out;
665 }
666
667 err = mnt_want_write_file(file);
668 if (err)
669 goto group_add_out;
670
671 err = ext4_group_add(sb, input);
672 if (EXT4_SB(sb)->s_journal) {
673 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
674 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
675 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
676 }
677 if (err == 0)
678 err = err2;
679 mnt_drop_write_file(file);
680 if (!err && ext4_has_group_desc_csum(sb) &&
681 test_opt(sb, INIT_INODE_TABLE))
682 err = ext4_register_li_request(sb, input->group);
683 group_add_out:
684 ext4_resize_end(sb);
685 return err;
686 }
687
688 static int ext4_ioctl_check_project(struct inode *inode, struct fsxattr *fa)
689 {
690 /*
691 * Project Quota ID state is only allowed to change from within the init
692 * namespace. Enforce that restriction only if we are trying to change
693 * the quota ID state. Everything else is allowed in user namespaces.
694 */
695 if (current_user_ns() == &init_user_ns)
696 return 0;
697
698 if (__kprojid_val(EXT4_I(inode)->i_projid) != fa->fsx_projid)
699 return -EINVAL;
700
701 if (ext4_test_inode_flag(inode, EXT4_INODE_PROJINHERIT)) {
702 if (!(fa->fsx_xflags & FS_XFLAG_PROJINHERIT))
703 return -EINVAL;
704 } else {
705 if (fa->fsx_xflags & FS_XFLAG_PROJINHERIT)
706 return -EINVAL;
707 }
708
709 return 0;
710 }
711
712 long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
713 {
714 struct inode *inode = file_inode(filp);
715 struct super_block *sb = inode->i_sb;
716 struct ext4_inode_info *ei = EXT4_I(inode);
717 unsigned int flags;
718
719 ext4_debug("cmd = %u, arg = %lu\n", cmd, arg);
720
721 switch (cmd) {
722 case FS_IOC_GETFSMAP:
723 return ext4_ioc_getfsmap(sb, (void __user *)arg);
724 case EXT4_IOC_GETFLAGS:
725 flags = ei->i_flags & EXT4_FL_USER_VISIBLE;
726 return put_user(flags, (int __user *) arg);
727 case EXT4_IOC_SETFLAGS: {
728 int err;
729
730 if (!inode_owner_or_capable(inode))
731 return -EACCES;
732
733 if (get_user(flags, (int __user *) arg))
734 return -EFAULT;
735
736 if (flags & ~EXT4_FL_USER_VISIBLE)
737 return -EOPNOTSUPP;
738 /*
739 * chattr(1) grabs flags via GETFLAGS, modifies the result and
740 * passes that to SETFLAGS. So we cannot easily make SETFLAGS
741 * more restrictive than just silently masking off visible but
742 * not settable flags as we always did.
743 */
744 flags &= EXT4_FL_USER_MODIFIABLE;
745 if (ext4_mask_flags(inode->i_mode, flags) != flags)
746 return -EOPNOTSUPP;
747
748 err = mnt_want_write_file(filp);
749 if (err)
750 return err;
751
752 inode_lock(inode);
753 err = ext4_ioctl_setflags(inode, flags);
754 inode_unlock(inode);
755 mnt_drop_write_file(filp);
756 return err;
757 }
758 case EXT4_IOC_GETVERSION:
759 case EXT4_IOC_GETVERSION_OLD:
760 return put_user(inode->i_generation, (int __user *) arg);
761 case EXT4_IOC_SETVERSION:
762 case EXT4_IOC_SETVERSION_OLD: {
763 handle_t *handle;
764 struct ext4_iloc iloc;
765 __u32 generation;
766 int err;
767
768 if (!inode_owner_or_capable(inode))
769 return -EPERM;
770
771 if (ext4_has_metadata_csum(inode->i_sb)) {
772 ext4_warning(sb, "Setting inode version is not "
773 "supported with metadata_csum enabled.");
774 return -ENOTTY;
775 }
776
777 err = mnt_want_write_file(filp);
778 if (err)
779 return err;
780 if (get_user(generation, (int __user *) arg)) {
781 err = -EFAULT;
782 goto setversion_out;
783 }
784
785 inode_lock(inode);
786 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
787 if (IS_ERR(handle)) {
788 err = PTR_ERR(handle);
789 goto unlock_out;
790 }
791 err = ext4_reserve_inode_write(handle, inode, &iloc);
792 if (err == 0) {
793 inode->i_ctime = current_time(inode);
794 inode->i_generation = generation;
795 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
796 }
797 ext4_journal_stop(handle);
798
799 unlock_out:
800 inode_unlock(inode);
801 setversion_out:
802 mnt_drop_write_file(filp);
803 return err;
804 }
805 case EXT4_IOC_GROUP_EXTEND: {
806 ext4_fsblk_t n_blocks_count;
807 int err, err2=0;
808
809 err = ext4_resize_begin(sb);
810 if (err)
811 return err;
812
813 if (get_user(n_blocks_count, (__u32 __user *)arg)) {
814 err = -EFAULT;
815 goto group_extend_out;
816 }
817
818 if (ext4_has_feature_bigalloc(sb)) {
819 ext4_msg(sb, KERN_ERR,
820 "Online resizing not supported with bigalloc");
821 err = -EOPNOTSUPP;
822 goto group_extend_out;
823 }
824
825 err = mnt_want_write_file(filp);
826 if (err)
827 goto group_extend_out;
828
829 err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count);
830 if (EXT4_SB(sb)->s_journal) {
831 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
832 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
833 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
834 }
835 if (err == 0)
836 err = err2;
837 mnt_drop_write_file(filp);
838 group_extend_out:
839 ext4_resize_end(sb);
840 return err;
841 }
842
843 case EXT4_IOC_MOVE_EXT: {
844 struct move_extent me;
845 struct fd donor;
846 int err;
847
848 if (!(filp->f_mode & FMODE_READ) ||
849 !(filp->f_mode & FMODE_WRITE))
850 return -EBADF;
851
852 if (copy_from_user(&me,
853 (struct move_extent __user *)arg, sizeof(me)))
854 return -EFAULT;
855 me.moved_len = 0;
856
857 donor = fdget(me.donor_fd);
858 if (!donor.file)
859 return -EBADF;
860
861 if (!(donor.file->f_mode & FMODE_WRITE)) {
862 err = -EBADF;
863 goto mext_out;
864 }
865
866 if (ext4_has_feature_bigalloc(sb)) {
867 ext4_msg(sb, KERN_ERR,
868 "Online defrag not supported with bigalloc");
869 err = -EOPNOTSUPP;
870 goto mext_out;
871 } else if (IS_DAX(inode)) {
872 ext4_msg(sb, KERN_ERR,
873 "Online defrag not supported with DAX");
874 err = -EOPNOTSUPP;
875 goto mext_out;
876 }
877
878 err = mnt_want_write_file(filp);
879 if (err)
880 goto mext_out;
881
882 err = ext4_move_extents(filp, donor.file, me.orig_start,
883 me.donor_start, me.len, &me.moved_len);
884 mnt_drop_write_file(filp);
885
886 if (copy_to_user((struct move_extent __user *)arg,
887 &me, sizeof(me)))
888 err = -EFAULT;
889 mext_out:
890 fdput(donor);
891 return err;
892 }
893
894 case EXT4_IOC_GROUP_ADD: {
895 struct ext4_new_group_data input;
896
897 if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,
898 sizeof(input)))
899 return -EFAULT;
900
901 return ext4_ioctl_group_add(filp, &input);
902 }
903
904 case EXT4_IOC_MIGRATE:
905 {
906 int err;
907 if (!inode_owner_or_capable(inode))
908 return -EACCES;
909
910 err = mnt_want_write_file(filp);
911 if (err)
912 return err;
913 /*
914 * inode_mutex prevent write and truncate on the file.
915 * Read still goes through. We take i_data_sem in
916 * ext4_ext_swap_inode_data before we switch the
917 * inode format to prevent read.
918 */
919 inode_lock((inode));
920 err = ext4_ext_migrate(inode);
921 inode_unlock((inode));
922 mnt_drop_write_file(filp);
923 return err;
924 }
925
926 case EXT4_IOC_ALLOC_DA_BLKS:
927 {
928 int err;
929 if (!inode_owner_or_capable(inode))
930 return -EACCES;
931
932 err = mnt_want_write_file(filp);
933 if (err)
934 return err;
935 err = ext4_alloc_da_blocks(inode);
936 mnt_drop_write_file(filp);
937 return err;
938 }
939
940 case EXT4_IOC_SWAP_BOOT:
941 {
942 int err;
943 if (!(filp->f_mode & FMODE_WRITE))
944 return -EBADF;
945 err = mnt_want_write_file(filp);
946 if (err)
947 return err;
948 err = swap_inode_boot_loader(sb, inode);
949 mnt_drop_write_file(filp);
950 return err;
951 }
952
953 case EXT4_IOC_RESIZE_FS: {
954 ext4_fsblk_t n_blocks_count;
955 int err = 0, err2 = 0;
956 ext4_group_t o_group = EXT4_SB(sb)->s_groups_count;
957
958 if (copy_from_user(&n_blocks_count, (__u64 __user *)arg,
959 sizeof(__u64))) {
960 return -EFAULT;
961 }
962
963 err = ext4_resize_begin(sb);
964 if (err)
965 return err;
966
967 err = mnt_want_write_file(filp);
968 if (err)
969 goto resizefs_out;
970
971 err = ext4_resize_fs(sb, n_blocks_count);
972 if (EXT4_SB(sb)->s_journal) {
973 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
974 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
975 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
976 }
977 if (err == 0)
978 err = err2;
979 mnt_drop_write_file(filp);
980 if (!err && (o_group < EXT4_SB(sb)->s_groups_count) &&
981 ext4_has_group_desc_csum(sb) &&
982 test_opt(sb, INIT_INODE_TABLE))
983 err = ext4_register_li_request(sb, o_group);
984
985 resizefs_out:
986 ext4_resize_end(sb);
987 return err;
988 }
989
990 case FITRIM:
991 {
992 struct request_queue *q = bdev_get_queue(sb->s_bdev);
993 struct fstrim_range range;
994 int ret = 0;
995
996 if (!capable(CAP_SYS_ADMIN))
997 return -EPERM;
998
999 if (!blk_queue_discard(q))
1000 return -EOPNOTSUPP;
1001
1002 /*
1003 * We haven't replayed the journal, so we cannot use our
1004 * block-bitmap-guided storage zapping commands.
1005 */
1006 if (test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb))
1007 return -EROFS;
1008
1009 if (copy_from_user(&range, (struct fstrim_range __user *)arg,
1010 sizeof(range)))
1011 return -EFAULT;
1012
1013 range.minlen = max((unsigned int)range.minlen,
1014 q->limits.discard_granularity);
1015 ret = ext4_trim_fs(sb, &range);
1016 if (ret < 0)
1017 return ret;
1018
1019 if (copy_to_user((struct fstrim_range __user *)arg, &range,
1020 sizeof(range)))
1021 return -EFAULT;
1022
1023 return 0;
1024 }
1025 case EXT4_IOC_PRECACHE_EXTENTS:
1026 return ext4_ext_precache(inode);
1027
1028 case EXT4_IOC_SET_ENCRYPTION_POLICY:
1029 if (!ext4_has_feature_encrypt(sb))
1030 return -EOPNOTSUPP;
1031 return fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
1032
1033 case EXT4_IOC_GET_ENCRYPTION_PWSALT: {
1034 #ifdef CONFIG_EXT4_FS_ENCRYPTION
1035 int err, err2;
1036 struct ext4_sb_info *sbi = EXT4_SB(sb);
1037 handle_t *handle;
1038
1039 if (!ext4_has_feature_encrypt(sb))
1040 return -EOPNOTSUPP;
1041 if (uuid_is_zero(sbi->s_es->s_encrypt_pw_salt)) {
1042 err = mnt_want_write_file(filp);
1043 if (err)
1044 return err;
1045 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
1046 if (IS_ERR(handle)) {
1047 err = PTR_ERR(handle);
1048 goto pwsalt_err_exit;
1049 }
1050 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
1051 if (err)
1052 goto pwsalt_err_journal;
1053 generate_random_uuid(sbi->s_es->s_encrypt_pw_salt);
1054 err = ext4_handle_dirty_metadata(handle, NULL,
1055 sbi->s_sbh);
1056 pwsalt_err_journal:
1057 err2 = ext4_journal_stop(handle);
1058 if (err2 && !err)
1059 err = err2;
1060 pwsalt_err_exit:
1061 mnt_drop_write_file(filp);
1062 if (err)
1063 return err;
1064 }
1065 if (copy_to_user((void __user *) arg,
1066 sbi->s_es->s_encrypt_pw_salt, 16))
1067 return -EFAULT;
1068 return 0;
1069 #else
1070 return -EOPNOTSUPP;
1071 #endif
1072 }
1073 case EXT4_IOC_GET_ENCRYPTION_POLICY:
1074 return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
1075
1076 case EXT4_IOC_FSGETXATTR:
1077 {
1078 struct fsxattr fa;
1079
1080 memset(&fa, 0, sizeof(struct fsxattr));
1081 fa.fsx_xflags = ext4_iflags_to_xflags(ei->i_flags & EXT4_FL_USER_VISIBLE);
1082
1083 if (ext4_has_feature_project(inode->i_sb)) {
1084 fa.fsx_projid = (__u32)from_kprojid(&init_user_ns,
1085 EXT4_I(inode)->i_projid);
1086 }
1087
1088 if (copy_to_user((struct fsxattr __user *)arg,
1089 &fa, sizeof(fa)))
1090 return -EFAULT;
1091 return 0;
1092 }
1093 case EXT4_IOC_FSSETXATTR:
1094 {
1095 struct fsxattr fa;
1096 int err;
1097
1098 if (copy_from_user(&fa, (struct fsxattr __user *)arg,
1099 sizeof(fa)))
1100 return -EFAULT;
1101
1102 /* Make sure caller has proper permission */
1103 if (!inode_owner_or_capable(inode))
1104 return -EACCES;
1105
1106 if (fa.fsx_xflags & ~EXT4_SUPPORTED_FS_XFLAGS)
1107 return -EOPNOTSUPP;
1108
1109 flags = ext4_xflags_to_iflags(fa.fsx_xflags);
1110 if (ext4_mask_flags(inode->i_mode, flags) != flags)
1111 return -EOPNOTSUPP;
1112
1113 err = mnt_want_write_file(filp);
1114 if (err)
1115 return err;
1116
1117 inode_lock(inode);
1118 err = ext4_ioctl_check_project(inode, &fa);
1119 if (err)
1120 goto out;
1121 flags = (ei->i_flags & ~EXT4_FL_XFLAG_VISIBLE) |
1122 (flags & EXT4_FL_XFLAG_VISIBLE);
1123 err = ext4_ioctl_setflags(inode, flags);
1124 if (err)
1125 goto out;
1126 err = ext4_ioctl_setproject(filp, fa.fsx_projid);
1127 out:
1128 inode_unlock(inode);
1129 mnt_drop_write_file(filp);
1130 return err;
1131 }
1132 case EXT4_IOC_SHUTDOWN:
1133 return ext4_shutdown(sb, arg);
1134 default:
1135 return -ENOTTY;
1136 }
1137 }
1138
1139 #ifdef CONFIG_COMPAT
1140 long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1141 {
1142 /* These are just misnamed, they actually get/put from/to user an int */
1143 switch (cmd) {
1144 case EXT4_IOC32_GETFLAGS:
1145 cmd = EXT4_IOC_GETFLAGS;
1146 break;
1147 case EXT4_IOC32_SETFLAGS:
1148 cmd = EXT4_IOC_SETFLAGS;
1149 break;
1150 case EXT4_IOC32_GETVERSION:
1151 cmd = EXT4_IOC_GETVERSION;
1152 break;
1153 case EXT4_IOC32_SETVERSION:
1154 cmd = EXT4_IOC_SETVERSION;
1155 break;
1156 case EXT4_IOC32_GROUP_EXTEND:
1157 cmd = EXT4_IOC_GROUP_EXTEND;
1158 break;
1159 case EXT4_IOC32_GETVERSION_OLD:
1160 cmd = EXT4_IOC_GETVERSION_OLD;
1161 break;
1162 case EXT4_IOC32_SETVERSION_OLD:
1163 cmd = EXT4_IOC_SETVERSION_OLD;
1164 break;
1165 case EXT4_IOC32_GETRSVSZ:
1166 cmd = EXT4_IOC_GETRSVSZ;
1167 break;
1168 case EXT4_IOC32_SETRSVSZ:
1169 cmd = EXT4_IOC_SETRSVSZ;
1170 break;
1171 case EXT4_IOC32_GROUP_ADD: {
1172 struct compat_ext4_new_group_input __user *uinput;
1173 struct ext4_new_group_data input;
1174 int err;
1175
1176 uinput = compat_ptr(arg);
1177 err = get_user(input.group, &uinput->group);
1178 err |= get_user(input.block_bitmap, &uinput->block_bitmap);
1179 err |= get_user(input.inode_bitmap, &uinput->inode_bitmap);
1180 err |= get_user(input.inode_table, &uinput->inode_table);
1181 err |= get_user(input.blocks_count, &uinput->blocks_count);
1182 err |= get_user(input.reserved_blocks,
1183 &uinput->reserved_blocks);
1184 if (err)
1185 return -EFAULT;
1186 return ext4_ioctl_group_add(file, &input);
1187 }
1188 case EXT4_IOC_MOVE_EXT:
1189 case EXT4_IOC_RESIZE_FS:
1190 case EXT4_IOC_PRECACHE_EXTENTS:
1191 case EXT4_IOC_SET_ENCRYPTION_POLICY:
1192 case EXT4_IOC_GET_ENCRYPTION_PWSALT:
1193 case EXT4_IOC_GET_ENCRYPTION_POLICY:
1194 case EXT4_IOC_SHUTDOWN:
1195 case FS_IOC_GETFSMAP:
1196 break;
1197 default:
1198 return -ENOIOCTLCMD;
1199 }
1200 return ext4_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
1201 }
1202 #endif
Linux with added FPC-III support