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/jbd2.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 <asm/uaccess.h> 18 #include "ext4_jbd2.h" 19 #include "ext4.h" 20 21 #define MAX_32_NUM ((((unsigned long long) 1) << 32) - 1) 22 23 /** 24 * Swap memory between @a and @b for @len bytes. 25 * 26 * @a: pointer to first memory area 27 * @b: pointer to second memory area 28 * @len: number of bytes to swap 29 * 30 */ 31 static void memswap(void *a, void *b, size_t len) 32 { 33 unsigned char *ap, *bp; 34 unsigned char tmp; 35 36 ap = (unsigned char *)a; 37 bp = (unsigned char *)b; 38 while (len-- > 0) { 39 tmp = *ap; 40 *ap = *bp; 41 *bp = tmp; 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 memswap(&inode1->i_flags, &inode2->i_flags, sizeof(inode1->i_flags)); 68 memswap(&inode1->i_version, &inode2->i_version, 69 sizeof(inode1->i_version)); 70 memswap(&inode1->i_blocks, &inode2->i_blocks, 71 sizeof(inode1->i_blocks)); 72 memswap(&inode1->i_bytes, &inode2->i_bytes, sizeof(inode1->i_bytes)); 73 memswap(&inode1->i_atime, &inode2->i_atime, sizeof(inode1->i_atime)); 74 memswap(&inode1->i_mtime, &inode2->i_mtime, sizeof(inode1->i_mtime)); 75 76 memswap(ei1->i_data, ei2->i_data, sizeof(ei1->i_data)); 77 memswap(&ei1->i_flags, &ei2->i_flags, sizeof(ei1->i_flags)); 78 memswap(&ei1->i_disksize, &ei2->i_disksize, sizeof(ei1->i_disksize)); 79 ext4_es_remove_extent(inode1, 0, EXT_MAX_BLOCKS); 80 ext4_es_remove_extent(inode2, 0, EXT_MAX_BLOCKS); 81 ext4_es_lru_del(inode1); 82 ext4_es_lru_del(inode2); 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 /** 90 * Swap the information from the given @inode and the inode 91 * EXT4_BOOT_LOADER_INO. It will basically swap i_data and all other 92 * important fields of the inodes. 93 * 94 * @sb: the super block of the filesystem 95 * @inode: the inode to swap with EXT4_BOOT_LOADER_INO 96 * 97 */ 98 static long swap_inode_boot_loader(struct super_block *sb, 99 struct inode *inode) 100 { 101 handle_t *handle; 102 int err; 103 struct inode *inode_bl; 104 struct ext4_inode_info *ei_bl; 105 struct ext4_sb_info *sbi = EXT4_SB(sb); 106 107 if (inode->i_nlink != 1 || !S_ISREG(inode->i_mode)) { 108 err = -EINVAL; 109 goto swap_boot_out; 110 } 111 112 if (!inode_owner_or_capable(inode) || !capable(CAP_SYS_ADMIN)) { 113 err = -EPERM; 114 goto swap_boot_out; 115 } 116 117 inode_bl = ext4_iget(sb, EXT4_BOOT_LOADER_INO); 118 if (IS_ERR(inode_bl)) { 119 err = PTR_ERR(inode_bl); 120 goto swap_boot_out; 121 } 122 ei_bl = EXT4_I(inode_bl); 123 124 filemap_flush(inode->i_mapping); 125 filemap_flush(inode_bl->i_mapping); 126 127 /* Protect orig inodes against a truncate and make sure, 128 * that only 1 swap_inode_boot_loader is running. */ 129 lock_two_nondirectories(inode, inode_bl); 130 131 truncate_inode_pages(&inode->i_data, 0); 132 truncate_inode_pages(&inode_bl->i_data, 0); 133 134 /* Wait for all existing dio workers */ 135 ext4_inode_block_unlocked_dio(inode); 136 ext4_inode_block_unlocked_dio(inode_bl); 137 inode_dio_wait(inode); 138 inode_dio_wait(inode_bl); 139 140 handle = ext4_journal_start(inode_bl, EXT4_HT_MOVE_EXTENTS, 2); 141 if (IS_ERR(handle)) { 142 err = -EINVAL; 143 goto swap_boot_out; 144 } 145 146 /* Protect extent tree against block allocations via delalloc */ 147 ext4_double_down_write_data_sem(inode, inode_bl); 148 149 if (inode_bl->i_nlink == 0) { 150 /* this inode has never been used as a BOOT_LOADER */ 151 set_nlink(inode_bl, 1); 152 i_uid_write(inode_bl, 0); 153 i_gid_write(inode_bl, 0); 154 inode_bl->i_flags = 0; 155 ei_bl->i_flags = 0; 156 inode_bl->i_version = 1; 157 i_size_write(inode_bl, 0); 158 inode_bl->i_mode = S_IFREG; 159 if (EXT4_HAS_INCOMPAT_FEATURE(sb, 160 EXT4_FEATURE_INCOMPAT_EXTENTS)) { 161 ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS); 162 ext4_ext_tree_init(handle, inode_bl); 163 } else 164 memset(ei_bl->i_data, 0, sizeof(ei_bl->i_data)); 165 } 166 167 swap_inode_data(inode, inode_bl); 168 169 inode->i_ctime = inode_bl->i_ctime = ext4_current_time(inode); 170 171 spin_lock(&sbi->s_next_gen_lock); 172 inode->i_generation = sbi->s_next_generation++; 173 inode_bl->i_generation = sbi->s_next_generation++; 174 spin_unlock(&sbi->s_next_gen_lock); 175 176 ext4_discard_preallocations(inode); 177 178 err = ext4_mark_inode_dirty(handle, inode); 179 if (err < 0) { 180 ext4_warning(inode->i_sb, 181 "couldn't mark inode #%lu dirty (err %d)", 182 inode->i_ino, err); 183 /* Revert all changes: */ 184 swap_inode_data(inode, inode_bl); 185 } else { 186 err = ext4_mark_inode_dirty(handle, inode_bl); 187 if (err < 0) { 188 ext4_warning(inode_bl->i_sb, 189 "couldn't mark inode #%lu dirty (err %d)", 190 inode_bl->i_ino, err); 191 /* Revert all changes: */ 192 swap_inode_data(inode, inode_bl); 193 ext4_mark_inode_dirty(handle, inode); 194 } 195 } 196 197 ext4_journal_stop(handle); 198 199 ext4_double_up_write_data_sem(inode, inode_bl); 200 201 ext4_inode_resume_unlocked_dio(inode); 202 ext4_inode_resume_unlocked_dio(inode_bl); 203 204 unlock_two_nondirectories(inode, inode_bl); 205 206 iput(inode_bl); 207 208 swap_boot_out: 209 return err; 210 } 211 212 long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 213 { 214 struct inode *inode = file_inode(filp); 215 struct super_block *sb = inode->i_sb; 216 struct ext4_inode_info *ei = EXT4_I(inode); 217 unsigned int flags; 218 219 ext4_debug("cmd = %u, arg = %lu\n", cmd, arg); 220 221 switch (cmd) { 222 case EXT4_IOC_GETFLAGS: 223 ext4_get_inode_flags(ei); 224 flags = ei->i_flags & EXT4_FL_USER_VISIBLE; 225 return put_user(flags, (int __user *) arg); 226 case EXT4_IOC_SETFLAGS: { 227 handle_t *handle = NULL; 228 int err, migrate = 0; 229 struct ext4_iloc iloc; 230 unsigned int oldflags, mask, i; 231 unsigned int jflag; 232 233 if (!inode_owner_or_capable(inode)) 234 return -EACCES; 235 236 if (get_user(flags, (int __user *) arg)) 237 return -EFAULT; 238 239 err = mnt_want_write_file(filp); 240 if (err) 241 return err; 242 243 flags = ext4_mask_flags(inode->i_mode, flags); 244 245 err = -EPERM; 246 mutex_lock(&inode->i_mutex); 247 /* Is it quota file? Do not allow user to mess with it */ 248 if (IS_NOQUOTA(inode)) 249 goto flags_out; 250 251 oldflags = ei->i_flags; 252 253 /* The JOURNAL_DATA flag is modifiable only by root */ 254 jflag = flags & EXT4_JOURNAL_DATA_FL; 255 256 /* 257 * The IMMUTABLE and APPEND_ONLY flags can only be changed by 258 * the relevant capability. 259 * 260 * This test looks nicer. Thanks to Pauline Middelink 261 */ 262 if ((flags ^ oldflags) & (EXT4_APPEND_FL | EXT4_IMMUTABLE_FL)) { 263 if (!capable(CAP_LINUX_IMMUTABLE)) 264 goto flags_out; 265 } 266 267 /* 268 * The JOURNAL_DATA flag can only be changed by 269 * the relevant capability. 270 */ 271 if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) { 272 if (!capable(CAP_SYS_RESOURCE)) 273 goto flags_out; 274 } 275 if ((flags ^ oldflags) & EXT4_EXTENTS_FL) 276 migrate = 1; 277 278 if (flags & EXT4_EOFBLOCKS_FL) { 279 /* we don't support adding EOFBLOCKS flag */ 280 if (!(oldflags & EXT4_EOFBLOCKS_FL)) { 281 err = -EOPNOTSUPP; 282 goto flags_out; 283 } 284 } else if (oldflags & EXT4_EOFBLOCKS_FL) 285 ext4_truncate(inode); 286 287 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 288 if (IS_ERR(handle)) { 289 err = PTR_ERR(handle); 290 goto flags_out; 291 } 292 if (IS_SYNC(inode)) 293 ext4_handle_sync(handle); 294 err = ext4_reserve_inode_write(handle, inode, &iloc); 295 if (err) 296 goto flags_err; 297 298 for (i = 0, mask = 1; i < 32; i++, mask <<= 1) { 299 if (!(mask & EXT4_FL_USER_MODIFIABLE)) 300 continue; 301 if (mask & flags) 302 ext4_set_inode_flag(inode, i); 303 else 304 ext4_clear_inode_flag(inode, i); 305 } 306 307 ext4_set_inode_flags(inode); 308 inode->i_ctime = ext4_current_time(inode); 309 310 err = ext4_mark_iloc_dirty(handle, inode, &iloc); 311 flags_err: 312 ext4_journal_stop(handle); 313 if (err) 314 goto flags_out; 315 316 if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) 317 err = ext4_change_inode_journal_flag(inode, jflag); 318 if (err) 319 goto flags_out; 320 if (migrate) { 321 if (flags & EXT4_EXTENTS_FL) 322 err = ext4_ext_migrate(inode); 323 else 324 err = ext4_ind_migrate(inode); 325 } 326 327 flags_out: 328 mutex_unlock(&inode->i_mutex); 329 mnt_drop_write_file(filp); 330 return err; 331 } 332 case EXT4_IOC_GETVERSION: 333 case EXT4_IOC_GETVERSION_OLD: 334 return put_user(inode->i_generation, (int __user *) arg); 335 case EXT4_IOC_SETVERSION: 336 case EXT4_IOC_SETVERSION_OLD: { 337 handle_t *handle; 338 struct ext4_iloc iloc; 339 __u32 generation; 340 int err; 341 342 if (!inode_owner_or_capable(inode)) 343 return -EPERM; 344 345 if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb, 346 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) { 347 ext4_warning(sb, "Setting inode version is not " 348 "supported with metadata_csum enabled."); 349 return -ENOTTY; 350 } 351 352 err = mnt_want_write_file(filp); 353 if (err) 354 return err; 355 if (get_user(generation, (int __user *) arg)) { 356 err = -EFAULT; 357 goto setversion_out; 358 } 359 360 mutex_lock(&inode->i_mutex); 361 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 362 if (IS_ERR(handle)) { 363 err = PTR_ERR(handle); 364 goto unlock_out; 365 } 366 err = ext4_reserve_inode_write(handle, inode, &iloc); 367 if (err == 0) { 368 inode->i_ctime = ext4_current_time(inode); 369 inode->i_generation = generation; 370 err = ext4_mark_iloc_dirty(handle, inode, &iloc); 371 } 372 ext4_journal_stop(handle); 373 374 unlock_out: 375 mutex_unlock(&inode->i_mutex); 376 setversion_out: 377 mnt_drop_write_file(filp); 378 return err; 379 } 380 case EXT4_IOC_GROUP_EXTEND: { 381 ext4_fsblk_t n_blocks_count; 382 int err, err2=0; 383 384 err = ext4_resize_begin(sb); 385 if (err) 386 return err; 387 388 if (get_user(n_blocks_count, (__u32 __user *)arg)) { 389 err = -EFAULT; 390 goto group_extend_out; 391 } 392 393 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 394 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { 395 ext4_msg(sb, KERN_ERR, 396 "Online resizing not supported with bigalloc"); 397 err = -EOPNOTSUPP; 398 goto group_extend_out; 399 } 400 401 err = mnt_want_write_file(filp); 402 if (err) 403 goto group_extend_out; 404 405 err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count); 406 if (EXT4_SB(sb)->s_journal) { 407 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 408 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal); 409 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 410 } 411 if (err == 0) 412 err = err2; 413 mnt_drop_write_file(filp); 414 group_extend_out: 415 ext4_resize_end(sb); 416 return err; 417 } 418 419 case EXT4_IOC_MOVE_EXT: { 420 struct move_extent me; 421 struct fd donor; 422 int err; 423 424 if (!(filp->f_mode & FMODE_READ) || 425 !(filp->f_mode & FMODE_WRITE)) 426 return -EBADF; 427 428 if (copy_from_user(&me, 429 (struct move_extent __user *)arg, sizeof(me))) 430 return -EFAULT; 431 me.moved_len = 0; 432 433 donor = fdget(me.donor_fd); 434 if (!donor.file) 435 return -EBADF; 436 437 if (!(donor.file->f_mode & FMODE_WRITE)) { 438 err = -EBADF; 439 goto mext_out; 440 } 441 442 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 443 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { 444 ext4_msg(sb, KERN_ERR, 445 "Online defrag not supported with bigalloc"); 446 err = -EOPNOTSUPP; 447 goto mext_out; 448 } 449 450 err = mnt_want_write_file(filp); 451 if (err) 452 goto mext_out; 453 454 err = ext4_move_extents(filp, donor.file, me.orig_start, 455 me.donor_start, me.len, &me.moved_len); 456 mnt_drop_write_file(filp); 457 458 if (copy_to_user((struct move_extent __user *)arg, 459 &me, sizeof(me))) 460 err = -EFAULT; 461 mext_out: 462 fdput(donor); 463 return err; 464 } 465 466 case EXT4_IOC_GROUP_ADD: { 467 struct ext4_new_group_data input; 468 int err, err2=0; 469 470 err = ext4_resize_begin(sb); 471 if (err) 472 return err; 473 474 if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg, 475 sizeof(input))) { 476 err = -EFAULT; 477 goto group_add_out; 478 } 479 480 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 481 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { 482 ext4_msg(sb, KERN_ERR, 483 "Online resizing not supported with bigalloc"); 484 err = -EOPNOTSUPP; 485 goto group_add_out; 486 } 487 488 err = mnt_want_write_file(filp); 489 if (err) 490 goto group_add_out; 491 492 err = ext4_group_add(sb, &input); 493 if (EXT4_SB(sb)->s_journal) { 494 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 495 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal); 496 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 497 } 498 if (err == 0) 499 err = err2; 500 mnt_drop_write_file(filp); 501 if (!err && ext4_has_group_desc_csum(sb) && 502 test_opt(sb, INIT_INODE_TABLE)) 503 err = ext4_register_li_request(sb, input.group); 504 group_add_out: 505 ext4_resize_end(sb); 506 return err; 507 } 508 509 case EXT4_IOC_MIGRATE: 510 { 511 int err; 512 if (!inode_owner_or_capable(inode)) 513 return -EACCES; 514 515 err = mnt_want_write_file(filp); 516 if (err) 517 return err; 518 /* 519 * inode_mutex prevent write and truncate on the file. 520 * Read still goes through. We take i_data_sem in 521 * ext4_ext_swap_inode_data before we switch the 522 * inode format to prevent read. 523 */ 524 mutex_lock(&(inode->i_mutex)); 525 err = ext4_ext_migrate(inode); 526 mutex_unlock(&(inode->i_mutex)); 527 mnt_drop_write_file(filp); 528 return err; 529 } 530 531 case EXT4_IOC_ALLOC_DA_BLKS: 532 { 533 int err; 534 if (!inode_owner_or_capable(inode)) 535 return -EACCES; 536 537 err = mnt_want_write_file(filp); 538 if (err) 539 return err; 540 err = ext4_alloc_da_blocks(inode); 541 mnt_drop_write_file(filp); 542 return err; 543 } 544 545 case EXT4_IOC_SWAP_BOOT: 546 if (!(filp->f_mode & FMODE_WRITE)) 547 return -EBADF; 548 return swap_inode_boot_loader(sb, inode); 549 550 case EXT4_IOC_RESIZE_FS: { 551 ext4_fsblk_t n_blocks_count; 552 int err = 0, err2 = 0; 553 ext4_group_t o_group = EXT4_SB(sb)->s_groups_count; 554 555 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 556 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { 557 ext4_msg(sb, KERN_ERR, 558 "Online resizing not (yet) supported with bigalloc"); 559 return -EOPNOTSUPP; 560 } 561 562 if (copy_from_user(&n_blocks_count, (__u64 __user *)arg, 563 sizeof(__u64))) { 564 return -EFAULT; 565 } 566 567 err = ext4_resize_begin(sb); 568 if (err) 569 return err; 570 571 err = mnt_want_write_file(filp); 572 if (err) 573 goto resizefs_out; 574 575 err = ext4_resize_fs(sb, n_blocks_count); 576 if (EXT4_SB(sb)->s_journal) { 577 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 578 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal); 579 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 580 } 581 if (err == 0) 582 err = err2; 583 mnt_drop_write_file(filp); 584 if (!err && (o_group > EXT4_SB(sb)->s_groups_count) && 585 ext4_has_group_desc_csum(sb) && 586 test_opt(sb, INIT_INODE_TABLE)) 587 err = ext4_register_li_request(sb, o_group); 588 589 resizefs_out: 590 ext4_resize_end(sb); 591 return err; 592 } 593 594 case FITRIM: 595 { 596 struct request_queue *q = bdev_get_queue(sb->s_bdev); 597 struct fstrim_range range; 598 int ret = 0; 599 600 if (!capable(CAP_SYS_ADMIN)) 601 return -EPERM; 602 603 if (!blk_queue_discard(q)) 604 return -EOPNOTSUPP; 605 606 if (copy_from_user(&range, (struct fstrim_range __user *)arg, 607 sizeof(range))) 608 return -EFAULT; 609 610 range.minlen = max((unsigned int)range.minlen, 611 q->limits.discard_granularity); 612 ret = ext4_trim_fs(sb, &range); 613 if (ret < 0) 614 return ret; 615 616 if (copy_to_user((struct fstrim_range __user *)arg, &range, 617 sizeof(range))) 618 return -EFAULT; 619 620 return 0; 621 } 622 case EXT4_IOC_PRECACHE_EXTENTS: 623 return ext4_ext_precache(inode); 624 625 default: 626 return -ENOTTY; 627 } 628 } 629 630 #ifdef CONFIG_COMPAT 631 long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 632 { 633 /* These are just misnamed, they actually get/put from/to user an int */ 634 switch (cmd) { 635 case EXT4_IOC32_GETFLAGS: 636 cmd = EXT4_IOC_GETFLAGS; 637 break; 638 case EXT4_IOC32_SETFLAGS: 639 cmd = EXT4_IOC_SETFLAGS; 640 break; 641 case EXT4_IOC32_GETVERSION: 642 cmd = EXT4_IOC_GETVERSION; 643 break; 644 case EXT4_IOC32_SETVERSION: 645 cmd = EXT4_IOC_SETVERSION; 646 break; 647 case EXT4_IOC32_GROUP_EXTEND: 648 cmd = EXT4_IOC_GROUP_EXTEND; 649 break; 650 case EXT4_IOC32_GETVERSION_OLD: 651 cmd = EXT4_IOC_GETVERSION_OLD; 652 break; 653 case EXT4_IOC32_SETVERSION_OLD: 654 cmd = EXT4_IOC_SETVERSION_OLD; 655 break; 656 case EXT4_IOC32_GETRSVSZ: 657 cmd = EXT4_IOC_GETRSVSZ; 658 break; 659 case EXT4_IOC32_SETRSVSZ: 660 cmd = EXT4_IOC_SETRSVSZ; 661 break; 662 case EXT4_IOC32_GROUP_ADD: { 663 struct compat_ext4_new_group_input __user *uinput; 664 struct ext4_new_group_input input; 665 mm_segment_t old_fs; 666 int err; 667 668 uinput = compat_ptr(arg); 669 err = get_user(input.group, &uinput->group); 670 err |= get_user(input.block_bitmap, &uinput->block_bitmap); 671 err |= get_user(input.inode_bitmap, &uinput->inode_bitmap); 672 err |= get_user(input.inode_table, &uinput->inode_table); 673 err |= get_user(input.blocks_count, &uinput->blocks_count); 674 err |= get_user(input.reserved_blocks, 675 &uinput->reserved_blocks); 676 if (err) 677 return -EFAULT; 678 old_fs = get_fs(); 679 set_fs(KERNEL_DS); 680 err = ext4_ioctl(file, EXT4_IOC_GROUP_ADD, 681 (unsigned long) &input); 682 set_fs(old_fs); 683 return err; 684 } 685 case EXT4_IOC_MOVE_EXT: 686 case FITRIM: 687 case EXT4_IOC_RESIZE_FS: 688 case EXT4_IOC_PRECACHE_EXTENTS: 689 break; 690 default: 691 return -ENOIOCTLCMD; 692 } 693 return ext4_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); 694 } 695 #endif 696