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 "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 = 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 #ifdef CONFIG_EXT4_FS_ENCRYPTION 195 static int uuid_is_zero(__u8 u[16]) 196 { 197 int i; 198 199 for (i = 0; i < 16; i++) 200 if (u[i]) 201 return 0; 202 return 1; 203 } 204 #endif 205 206 static int ext4_ioctl_setflags(struct inode *inode, 207 unsigned int flags) 208 { 209 struct ext4_inode_info *ei = EXT4_I(inode); 210 handle_t *handle = NULL; 211 int err = -EPERM, migrate = 0; 212 struct ext4_iloc iloc; 213 unsigned int oldflags, mask, i; 214 unsigned int jflag; 215 216 /* Is it quota file? Do not allow user to mess with it */ 217 if (IS_NOQUOTA(inode)) 218 goto flags_out; 219 220 oldflags = ei->i_flags; 221 222 /* The JOURNAL_DATA flag is modifiable only by root */ 223 jflag = flags & EXT4_JOURNAL_DATA_FL; 224 225 /* 226 * The IMMUTABLE and APPEND_ONLY flags can only be changed by 227 * the relevant capability. 228 * 229 * This test looks nicer. Thanks to Pauline Middelink 230 */ 231 if ((flags ^ oldflags) & (EXT4_APPEND_FL | EXT4_IMMUTABLE_FL)) { 232 if (!capable(CAP_LINUX_IMMUTABLE)) 233 goto flags_out; 234 } 235 236 /* 237 * The JOURNAL_DATA flag can only be changed by 238 * the relevant capability. 239 */ 240 if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) { 241 if (!capable(CAP_SYS_RESOURCE)) 242 goto flags_out; 243 } 244 if ((flags ^ oldflags) & EXT4_EXTENTS_FL) 245 migrate = 1; 246 247 if (flags & EXT4_EOFBLOCKS_FL) { 248 /* we don't support adding EOFBLOCKS flag */ 249 if (!(oldflags & EXT4_EOFBLOCKS_FL)) { 250 err = -EOPNOTSUPP; 251 goto flags_out; 252 } 253 } else if (oldflags & EXT4_EOFBLOCKS_FL) { 254 err = ext4_truncate(inode); 255 if (err) 256 goto flags_out; 257 } 258 259 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 260 if (IS_ERR(handle)) { 261 err = PTR_ERR(handle); 262 goto flags_out; 263 } 264 if (IS_SYNC(inode)) 265 ext4_handle_sync(handle); 266 err = ext4_reserve_inode_write(handle, inode, &iloc); 267 if (err) 268 goto flags_err; 269 270 for (i = 0, mask = 1; i < 32; i++, mask <<= 1) { 271 if (!(mask & EXT4_FL_USER_MODIFIABLE)) 272 continue; 273 /* These flags get special treatment later */ 274 if (mask == EXT4_JOURNAL_DATA_FL || mask == EXT4_EXTENTS_FL) 275 continue; 276 if (mask & flags) 277 ext4_set_inode_flag(inode, i); 278 else 279 ext4_clear_inode_flag(inode, i); 280 } 281 282 ext4_set_inode_flags(inode); 283 inode->i_ctime = current_time(inode); 284 285 err = ext4_mark_iloc_dirty(handle, inode, &iloc); 286 flags_err: 287 ext4_journal_stop(handle); 288 if (err) 289 goto flags_out; 290 291 if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) 292 err = ext4_change_inode_journal_flag(inode, jflag); 293 if (err) 294 goto flags_out; 295 if (migrate) { 296 if (flags & EXT4_EXTENTS_FL) 297 err = ext4_ext_migrate(inode); 298 else 299 err = ext4_ind_migrate(inode); 300 } 301 302 flags_out: 303 return err; 304 } 305 306 #ifdef CONFIG_QUOTA 307 static int ext4_ioctl_setproject(struct file *filp, __u32 projid) 308 { 309 struct inode *inode = file_inode(filp); 310 struct super_block *sb = inode->i_sb; 311 struct ext4_inode_info *ei = EXT4_I(inode); 312 int err, rc; 313 handle_t *handle; 314 kprojid_t kprojid; 315 struct ext4_iloc iloc; 316 struct ext4_inode *raw_inode; 317 struct dquot *transfer_to[MAXQUOTAS] = { }; 318 319 if (!ext4_has_feature_project(sb)) { 320 if (projid != EXT4_DEF_PROJID) 321 return -EOPNOTSUPP; 322 else 323 return 0; 324 } 325 326 if (EXT4_INODE_SIZE(sb) <= EXT4_GOOD_OLD_INODE_SIZE) 327 return -EOPNOTSUPP; 328 329 kprojid = make_kprojid(&init_user_ns, (projid_t)projid); 330 331 if (projid_eq(kprojid, EXT4_I(inode)->i_projid)) 332 return 0; 333 334 err = mnt_want_write_file(filp); 335 if (err) 336 return err; 337 338 err = -EPERM; 339 inode_lock(inode); 340 /* Is it quota file? Do not allow user to mess with it */ 341 if (IS_NOQUOTA(inode)) 342 goto out_unlock; 343 344 err = ext4_get_inode_loc(inode, &iloc); 345 if (err) 346 goto out_unlock; 347 348 raw_inode = ext4_raw_inode(&iloc); 349 if (!EXT4_FITS_IN_INODE(raw_inode, ei, i_projid)) { 350 err = -EOVERFLOW; 351 brelse(iloc.bh); 352 goto out_unlock; 353 } 354 brelse(iloc.bh); 355 356 dquot_initialize(inode); 357 358 handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 359 EXT4_QUOTA_INIT_BLOCKS(sb) + 360 EXT4_QUOTA_DEL_BLOCKS(sb) + 3); 361 if (IS_ERR(handle)) { 362 err = PTR_ERR(handle); 363 goto out_unlock; 364 } 365 366 err = ext4_reserve_inode_write(handle, inode, &iloc); 367 if (err) 368 goto out_stop; 369 370 transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid)); 371 if (!IS_ERR(transfer_to[PRJQUOTA])) { 372 err = __dquot_transfer(inode, transfer_to); 373 dqput(transfer_to[PRJQUOTA]); 374 if (err) 375 goto out_dirty; 376 } 377 378 EXT4_I(inode)->i_projid = kprojid; 379 inode->i_ctime = current_time(inode); 380 out_dirty: 381 rc = ext4_mark_iloc_dirty(handle, inode, &iloc); 382 if (!err) 383 err = rc; 384 out_stop: 385 ext4_journal_stop(handle); 386 out_unlock: 387 inode_unlock(inode); 388 mnt_drop_write_file(filp); 389 return err; 390 } 391 #else 392 static int ext4_ioctl_setproject(struct file *filp, __u32 projid) 393 { 394 if (projid != EXT4_DEF_PROJID) 395 return -EOPNOTSUPP; 396 return 0; 397 } 398 #endif 399 400 /* Transfer internal flags to xflags */ 401 static inline __u32 ext4_iflags_to_xflags(unsigned long iflags) 402 { 403 __u32 xflags = 0; 404 405 if (iflags & EXT4_SYNC_FL) 406 xflags |= FS_XFLAG_SYNC; 407 if (iflags & EXT4_IMMUTABLE_FL) 408 xflags |= FS_XFLAG_IMMUTABLE; 409 if (iflags & EXT4_APPEND_FL) 410 xflags |= FS_XFLAG_APPEND; 411 if (iflags & EXT4_NODUMP_FL) 412 xflags |= FS_XFLAG_NODUMP; 413 if (iflags & EXT4_NOATIME_FL) 414 xflags |= FS_XFLAG_NOATIME; 415 if (iflags & EXT4_PROJINHERIT_FL) 416 xflags |= FS_XFLAG_PROJINHERIT; 417 return xflags; 418 } 419 420 #define EXT4_SUPPORTED_FS_XFLAGS (FS_XFLAG_SYNC | FS_XFLAG_IMMUTABLE | \ 421 FS_XFLAG_APPEND | FS_XFLAG_NODUMP | \ 422 FS_XFLAG_NOATIME | FS_XFLAG_PROJINHERIT) 423 424 /* Transfer xflags flags to internal */ 425 static inline unsigned long ext4_xflags_to_iflags(__u32 xflags) 426 { 427 unsigned long iflags = 0; 428 429 if (xflags & FS_XFLAG_SYNC) 430 iflags |= EXT4_SYNC_FL; 431 if (xflags & FS_XFLAG_IMMUTABLE) 432 iflags |= EXT4_IMMUTABLE_FL; 433 if (xflags & FS_XFLAG_APPEND) 434 iflags |= EXT4_APPEND_FL; 435 if (xflags & FS_XFLAG_NODUMP) 436 iflags |= EXT4_NODUMP_FL; 437 if (xflags & FS_XFLAG_NOATIME) 438 iflags |= EXT4_NOATIME_FL; 439 if (xflags & FS_XFLAG_PROJINHERIT) 440 iflags |= EXT4_PROJINHERIT_FL; 441 442 return iflags; 443 } 444 445 long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 446 { 447 struct inode *inode = file_inode(filp); 448 struct super_block *sb = inode->i_sb; 449 struct ext4_inode_info *ei = EXT4_I(inode); 450 unsigned int flags; 451 452 ext4_debug("cmd = %u, arg = %lu\n", cmd, arg); 453 454 switch (cmd) { 455 case EXT4_IOC_GETFLAGS: 456 ext4_get_inode_flags(ei); 457 flags = ei->i_flags & EXT4_FL_USER_VISIBLE; 458 return put_user(flags, (int __user *) arg); 459 case EXT4_IOC_SETFLAGS: { 460 int err; 461 462 if (!inode_owner_or_capable(inode)) 463 return -EACCES; 464 465 if (get_user(flags, (int __user *) arg)) 466 return -EFAULT; 467 468 if (flags & ~EXT4_FL_USER_VISIBLE) 469 return -EOPNOTSUPP; 470 /* 471 * chattr(1) grabs flags via GETFLAGS, modifies the result and 472 * passes that to SETFLAGS. So we cannot easily make SETFLAGS 473 * more restrictive than just silently masking off visible but 474 * not settable flags as we always did. 475 */ 476 flags &= EXT4_FL_USER_MODIFIABLE; 477 if (ext4_mask_flags(inode->i_mode, flags) != flags) 478 return -EOPNOTSUPP; 479 480 err = mnt_want_write_file(filp); 481 if (err) 482 return err; 483 484 inode_lock(inode); 485 err = ext4_ioctl_setflags(inode, flags); 486 inode_unlock(inode); 487 mnt_drop_write_file(filp); 488 return err; 489 } 490 case EXT4_IOC_GETVERSION: 491 case EXT4_IOC_GETVERSION_OLD: 492 return put_user(inode->i_generation, (int __user *) arg); 493 case EXT4_IOC_SETVERSION: 494 case EXT4_IOC_SETVERSION_OLD: { 495 handle_t *handle; 496 struct ext4_iloc iloc; 497 __u32 generation; 498 int err; 499 500 if (!inode_owner_or_capable(inode)) 501 return -EPERM; 502 503 if (ext4_has_metadata_csum(inode->i_sb)) { 504 ext4_warning(sb, "Setting inode version is not " 505 "supported with metadata_csum enabled."); 506 return -ENOTTY; 507 } 508 509 err = mnt_want_write_file(filp); 510 if (err) 511 return err; 512 if (get_user(generation, (int __user *) arg)) { 513 err = -EFAULT; 514 goto setversion_out; 515 } 516 517 inode_lock(inode); 518 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 519 if (IS_ERR(handle)) { 520 err = PTR_ERR(handle); 521 goto unlock_out; 522 } 523 err = ext4_reserve_inode_write(handle, inode, &iloc); 524 if (err == 0) { 525 inode->i_ctime = current_time(inode); 526 inode->i_generation = generation; 527 err = ext4_mark_iloc_dirty(handle, inode, &iloc); 528 } 529 ext4_journal_stop(handle); 530 531 unlock_out: 532 inode_unlock(inode); 533 setversion_out: 534 mnt_drop_write_file(filp); 535 return err; 536 } 537 case EXT4_IOC_GROUP_EXTEND: { 538 ext4_fsblk_t n_blocks_count; 539 int err, err2=0; 540 541 err = ext4_resize_begin(sb); 542 if (err) 543 return err; 544 545 if (get_user(n_blocks_count, (__u32 __user *)arg)) { 546 err = -EFAULT; 547 goto group_extend_out; 548 } 549 550 if (ext4_has_feature_bigalloc(sb)) { 551 ext4_msg(sb, KERN_ERR, 552 "Online resizing not supported with bigalloc"); 553 err = -EOPNOTSUPP; 554 goto group_extend_out; 555 } 556 557 err = mnt_want_write_file(filp); 558 if (err) 559 goto group_extend_out; 560 561 err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count); 562 if (EXT4_SB(sb)->s_journal) { 563 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 564 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal); 565 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 566 } 567 if (err == 0) 568 err = err2; 569 mnt_drop_write_file(filp); 570 group_extend_out: 571 ext4_resize_end(sb); 572 return err; 573 } 574 575 case EXT4_IOC_MOVE_EXT: { 576 struct move_extent me; 577 struct fd donor; 578 int err; 579 580 if (!(filp->f_mode & FMODE_READ) || 581 !(filp->f_mode & FMODE_WRITE)) 582 return -EBADF; 583 584 if (copy_from_user(&me, 585 (struct move_extent __user *)arg, sizeof(me))) 586 return -EFAULT; 587 me.moved_len = 0; 588 589 donor = fdget(me.donor_fd); 590 if (!donor.file) 591 return -EBADF; 592 593 if (!(donor.file->f_mode & FMODE_WRITE)) { 594 err = -EBADF; 595 goto mext_out; 596 } 597 598 if (ext4_has_feature_bigalloc(sb)) { 599 ext4_msg(sb, KERN_ERR, 600 "Online defrag not supported with bigalloc"); 601 err = -EOPNOTSUPP; 602 goto mext_out; 603 } else if (IS_DAX(inode)) { 604 ext4_msg(sb, KERN_ERR, 605 "Online defrag not supported with DAX"); 606 err = -EOPNOTSUPP; 607 goto mext_out; 608 } 609 610 err = mnt_want_write_file(filp); 611 if (err) 612 goto mext_out; 613 614 err = ext4_move_extents(filp, donor.file, me.orig_start, 615 me.donor_start, me.len, &me.moved_len); 616 mnt_drop_write_file(filp); 617 618 if (copy_to_user((struct move_extent __user *)arg, 619 &me, sizeof(me))) 620 err = -EFAULT; 621 mext_out: 622 fdput(donor); 623 return err; 624 } 625 626 case EXT4_IOC_GROUP_ADD: { 627 struct ext4_new_group_data input; 628 int err, err2=0; 629 630 err = ext4_resize_begin(sb); 631 if (err) 632 return err; 633 634 if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg, 635 sizeof(input))) { 636 err = -EFAULT; 637 goto group_add_out; 638 } 639 640 if (ext4_has_feature_bigalloc(sb)) { 641 ext4_msg(sb, KERN_ERR, 642 "Online resizing not supported with bigalloc"); 643 err = -EOPNOTSUPP; 644 goto group_add_out; 645 } 646 647 err = mnt_want_write_file(filp); 648 if (err) 649 goto group_add_out; 650 651 err = ext4_group_add(sb, &input); 652 if (EXT4_SB(sb)->s_journal) { 653 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 654 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal); 655 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 656 } 657 if (err == 0) 658 err = err2; 659 mnt_drop_write_file(filp); 660 if (!err && ext4_has_group_desc_csum(sb) && 661 test_opt(sb, INIT_INODE_TABLE)) 662 err = ext4_register_li_request(sb, input.group); 663 group_add_out: 664 ext4_resize_end(sb); 665 return err; 666 } 667 668 case EXT4_IOC_MIGRATE: 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 /* 678 * inode_mutex prevent write and truncate on the file. 679 * Read still goes through. We take i_data_sem in 680 * ext4_ext_swap_inode_data before we switch the 681 * inode format to prevent read. 682 */ 683 inode_lock((inode)); 684 err = ext4_ext_migrate(inode); 685 inode_unlock((inode)); 686 mnt_drop_write_file(filp); 687 return err; 688 } 689 690 case EXT4_IOC_ALLOC_DA_BLKS: 691 { 692 int err; 693 if (!inode_owner_or_capable(inode)) 694 return -EACCES; 695 696 err = mnt_want_write_file(filp); 697 if (err) 698 return err; 699 err = ext4_alloc_da_blocks(inode); 700 mnt_drop_write_file(filp); 701 return err; 702 } 703 704 case EXT4_IOC_SWAP_BOOT: 705 { 706 int err; 707 if (!(filp->f_mode & FMODE_WRITE)) 708 return -EBADF; 709 err = mnt_want_write_file(filp); 710 if (err) 711 return err; 712 err = swap_inode_boot_loader(sb, inode); 713 mnt_drop_write_file(filp); 714 return err; 715 } 716 717 case EXT4_IOC_RESIZE_FS: { 718 ext4_fsblk_t n_blocks_count; 719 int err = 0, err2 = 0; 720 ext4_group_t o_group = EXT4_SB(sb)->s_groups_count; 721 722 if (ext4_has_feature_bigalloc(sb)) { 723 ext4_msg(sb, KERN_ERR, 724 "Online resizing not (yet) supported with bigalloc"); 725 return -EOPNOTSUPP; 726 } 727 728 if (copy_from_user(&n_blocks_count, (__u64 __user *)arg, 729 sizeof(__u64))) { 730 return -EFAULT; 731 } 732 733 err = ext4_resize_begin(sb); 734 if (err) 735 return err; 736 737 err = mnt_want_write_file(filp); 738 if (err) 739 goto resizefs_out; 740 741 err = ext4_resize_fs(sb, 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 if (!err && (o_group > EXT4_SB(sb)->s_groups_count) && 751 ext4_has_group_desc_csum(sb) && 752 test_opt(sb, INIT_INODE_TABLE)) 753 err = ext4_register_li_request(sb, o_group); 754 755 resizefs_out: 756 ext4_resize_end(sb); 757 return err; 758 } 759 760 case FITRIM: 761 { 762 struct request_queue *q = bdev_get_queue(sb->s_bdev); 763 struct fstrim_range range; 764 int ret = 0; 765 766 if (!capable(CAP_SYS_ADMIN)) 767 return -EPERM; 768 769 if (!blk_queue_discard(q)) 770 return -EOPNOTSUPP; 771 772 if (copy_from_user(&range, (struct fstrim_range __user *)arg, 773 sizeof(range))) 774 return -EFAULT; 775 776 range.minlen = max((unsigned int)range.minlen, 777 q->limits.discard_granularity); 778 ret = ext4_trim_fs(sb, &range); 779 if (ret < 0) 780 return ret; 781 782 if (copy_to_user((struct fstrim_range __user *)arg, &range, 783 sizeof(range))) 784 return -EFAULT; 785 786 return 0; 787 } 788 case EXT4_IOC_PRECACHE_EXTENTS: 789 return ext4_ext_precache(inode); 790 791 case EXT4_IOC_SET_ENCRYPTION_POLICY: 792 if (!ext4_has_feature_encrypt(sb)) 793 return -EOPNOTSUPP; 794 return fscrypt_ioctl_set_policy(filp, (const void __user *)arg); 795 796 case EXT4_IOC_GET_ENCRYPTION_PWSALT: { 797 #ifdef CONFIG_EXT4_FS_ENCRYPTION 798 int err, err2; 799 struct ext4_sb_info *sbi = EXT4_SB(sb); 800 handle_t *handle; 801 802 if (!ext4_has_feature_encrypt(sb)) 803 return -EOPNOTSUPP; 804 if (uuid_is_zero(sbi->s_es->s_encrypt_pw_salt)) { 805 err = mnt_want_write_file(filp); 806 if (err) 807 return err; 808 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1); 809 if (IS_ERR(handle)) { 810 err = PTR_ERR(handle); 811 goto pwsalt_err_exit; 812 } 813 err = ext4_journal_get_write_access(handle, sbi->s_sbh); 814 if (err) 815 goto pwsalt_err_journal; 816 generate_random_uuid(sbi->s_es->s_encrypt_pw_salt); 817 err = ext4_handle_dirty_metadata(handle, NULL, 818 sbi->s_sbh); 819 pwsalt_err_journal: 820 err2 = ext4_journal_stop(handle); 821 if (err2 && !err) 822 err = err2; 823 pwsalt_err_exit: 824 mnt_drop_write_file(filp); 825 if (err) 826 return err; 827 } 828 if (copy_to_user((void __user *) arg, 829 sbi->s_es->s_encrypt_pw_salt, 16)) 830 return -EFAULT; 831 return 0; 832 #else 833 return -EOPNOTSUPP; 834 #endif 835 } 836 case EXT4_IOC_GET_ENCRYPTION_POLICY: 837 return fscrypt_ioctl_get_policy(filp, (void __user *)arg); 838 839 case EXT4_IOC_FSGETXATTR: 840 { 841 struct fsxattr fa; 842 843 memset(&fa, 0, sizeof(struct fsxattr)); 844 ext4_get_inode_flags(ei); 845 fa.fsx_xflags = ext4_iflags_to_xflags(ei->i_flags & EXT4_FL_USER_VISIBLE); 846 847 if (ext4_has_feature_project(inode->i_sb)) { 848 fa.fsx_projid = (__u32)from_kprojid(&init_user_ns, 849 EXT4_I(inode)->i_projid); 850 } 851 852 if (copy_to_user((struct fsxattr __user *)arg, 853 &fa, sizeof(fa))) 854 return -EFAULT; 855 return 0; 856 } 857 case EXT4_IOC_FSSETXATTR: 858 { 859 struct fsxattr fa; 860 int err; 861 862 if (copy_from_user(&fa, (struct fsxattr __user *)arg, 863 sizeof(fa))) 864 return -EFAULT; 865 866 /* Make sure caller has proper permission */ 867 if (!inode_owner_or_capable(inode)) 868 return -EACCES; 869 870 if (fa.fsx_xflags & ~EXT4_SUPPORTED_FS_XFLAGS) 871 return -EOPNOTSUPP; 872 873 flags = ext4_xflags_to_iflags(fa.fsx_xflags); 874 if (ext4_mask_flags(inode->i_mode, flags) != flags) 875 return -EOPNOTSUPP; 876 877 err = mnt_want_write_file(filp); 878 if (err) 879 return err; 880 881 inode_lock(inode); 882 flags = (ei->i_flags & ~EXT4_FL_XFLAG_VISIBLE) | 883 (flags & EXT4_FL_XFLAG_VISIBLE); 884 err = ext4_ioctl_setflags(inode, flags); 885 inode_unlock(inode); 886 mnt_drop_write_file(filp); 887 if (err) 888 return err; 889 890 err = ext4_ioctl_setproject(filp, fa.fsx_projid); 891 if (err) 892 return err; 893 894 return 0; 895 } 896 default: 897 return -ENOTTY; 898 } 899 } 900 901 #ifdef CONFIG_COMPAT 902 long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 903 { 904 /* These are just misnamed, they actually get/put from/to user an int */ 905 switch (cmd) { 906 case EXT4_IOC32_GETFLAGS: 907 cmd = EXT4_IOC_GETFLAGS; 908 break; 909 case EXT4_IOC32_SETFLAGS: 910 cmd = EXT4_IOC_SETFLAGS; 911 break; 912 case EXT4_IOC32_GETVERSION: 913 cmd = EXT4_IOC_GETVERSION; 914 break; 915 case EXT4_IOC32_SETVERSION: 916 cmd = EXT4_IOC_SETVERSION; 917 break; 918 case EXT4_IOC32_GROUP_EXTEND: 919 cmd = EXT4_IOC_GROUP_EXTEND; 920 break; 921 case EXT4_IOC32_GETVERSION_OLD: 922 cmd = EXT4_IOC_GETVERSION_OLD; 923 break; 924 case EXT4_IOC32_SETVERSION_OLD: 925 cmd = EXT4_IOC_SETVERSION_OLD; 926 break; 927 case EXT4_IOC32_GETRSVSZ: 928 cmd = EXT4_IOC_GETRSVSZ; 929 break; 930 case EXT4_IOC32_SETRSVSZ: 931 cmd = EXT4_IOC_SETRSVSZ; 932 break; 933 case EXT4_IOC32_GROUP_ADD: { 934 struct compat_ext4_new_group_input __user *uinput; 935 struct ext4_new_group_input input; 936 mm_segment_t old_fs; 937 int err; 938 939 uinput = compat_ptr(arg); 940 err = get_user(input.group, &uinput->group); 941 err |= get_user(input.block_bitmap, &uinput->block_bitmap); 942 err |= get_user(input.inode_bitmap, &uinput->inode_bitmap); 943 err |= get_user(input.inode_table, &uinput->inode_table); 944 err |= get_user(input.blocks_count, &uinput->blocks_count); 945 err |= get_user(input.reserved_blocks, 946 &uinput->reserved_blocks); 947 if (err) 948 return -EFAULT; 949 old_fs = get_fs(); 950 set_fs(KERNEL_DS); 951 err = ext4_ioctl(file, EXT4_IOC_GROUP_ADD, 952 (unsigned long) &input); 953 set_fs(old_fs); 954 return err; 955 } 956 case EXT4_IOC_MOVE_EXT: 957 case EXT4_IOC_RESIZE_FS: 958 case EXT4_IOC_PRECACHE_EXTENTS: 959 case EXT4_IOC_SET_ENCRYPTION_POLICY: 960 case EXT4_IOC_GET_ENCRYPTION_PWSALT: 961 case EXT4_IOC_GET_ENCRYPTION_POLICY: 962 break; 963 default: 964 return -ENOIOCTLCMD; 965 } 966 return ext4_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); 967 } 968 #endif 969