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