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