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 long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 24 { 25 struct inode *inode = filp->f_dentry->d_inode; 26 struct super_block *sb = inode->i_sb; 27 struct ext4_inode_info *ei = EXT4_I(inode); 28 unsigned int flags; 29 30 ext4_debug("cmd = %u, arg = %lu\n", cmd, arg); 31 32 switch (cmd) { 33 case EXT4_IOC_GETFLAGS: 34 ext4_get_inode_flags(ei); 35 flags = ei->i_flags & EXT4_FL_USER_VISIBLE; 36 return put_user(flags, (int __user *) arg); 37 case EXT4_IOC_SETFLAGS: { 38 handle_t *handle = NULL; 39 int err, migrate = 0; 40 struct ext4_iloc iloc; 41 unsigned int oldflags, mask, i; 42 unsigned int jflag; 43 44 if (!inode_owner_or_capable(inode)) 45 return -EACCES; 46 47 if (get_user(flags, (int __user *) arg)) 48 return -EFAULT; 49 50 err = mnt_want_write_file(filp); 51 if (err) 52 return err; 53 54 flags = ext4_mask_flags(inode->i_mode, flags); 55 56 err = -EPERM; 57 mutex_lock(&inode->i_mutex); 58 /* Is it quota file? Do not allow user to mess with it */ 59 if (IS_NOQUOTA(inode)) 60 goto flags_out; 61 62 oldflags = ei->i_flags; 63 64 /* The JOURNAL_DATA flag is modifiable only by root */ 65 jflag = flags & EXT4_JOURNAL_DATA_FL; 66 67 /* 68 * The IMMUTABLE and APPEND_ONLY flags can only be changed by 69 * the relevant capability. 70 * 71 * This test looks nicer. Thanks to Pauline Middelink 72 */ 73 if ((flags ^ oldflags) & (EXT4_APPEND_FL | EXT4_IMMUTABLE_FL)) { 74 if (!capable(CAP_LINUX_IMMUTABLE)) 75 goto flags_out; 76 } 77 78 /* 79 * The JOURNAL_DATA flag can only be changed by 80 * the relevant capability. 81 */ 82 if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) { 83 if (!capable(CAP_SYS_RESOURCE)) 84 goto flags_out; 85 } 86 if (oldflags & EXT4_EXTENTS_FL) { 87 /* We don't support clearning extent flags */ 88 if (!(flags & EXT4_EXTENTS_FL)) { 89 err = -EOPNOTSUPP; 90 goto flags_out; 91 } 92 } else if (flags & EXT4_EXTENTS_FL) { 93 /* migrate the file */ 94 migrate = 1; 95 flags &= ~EXT4_EXTENTS_FL; 96 } 97 98 if (flags & EXT4_EOFBLOCKS_FL) { 99 /* we don't support adding EOFBLOCKS flag */ 100 if (!(oldflags & EXT4_EOFBLOCKS_FL)) { 101 err = -EOPNOTSUPP; 102 goto flags_out; 103 } 104 } else if (oldflags & EXT4_EOFBLOCKS_FL) 105 ext4_truncate(inode); 106 107 handle = ext4_journal_start(inode, 1); 108 if (IS_ERR(handle)) { 109 err = PTR_ERR(handle); 110 goto flags_out; 111 } 112 if (IS_SYNC(inode)) 113 ext4_handle_sync(handle); 114 err = ext4_reserve_inode_write(handle, inode, &iloc); 115 if (err) 116 goto flags_err; 117 118 for (i = 0, mask = 1; i < 32; i++, mask <<= 1) { 119 if (!(mask & EXT4_FL_USER_MODIFIABLE)) 120 continue; 121 if (mask & flags) 122 ext4_set_inode_flag(inode, i); 123 else 124 ext4_clear_inode_flag(inode, i); 125 } 126 127 ext4_set_inode_flags(inode); 128 inode->i_ctime = ext4_current_time(inode); 129 130 err = ext4_mark_iloc_dirty(handle, inode, &iloc); 131 flags_err: 132 ext4_journal_stop(handle); 133 if (err) 134 goto flags_out; 135 136 if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) 137 err = ext4_change_inode_journal_flag(inode, jflag); 138 if (err) 139 goto flags_out; 140 if (migrate) 141 err = ext4_ext_migrate(inode); 142 flags_out: 143 mutex_unlock(&inode->i_mutex); 144 mnt_drop_write_file(filp); 145 return err; 146 } 147 case EXT4_IOC_GETVERSION: 148 case EXT4_IOC_GETVERSION_OLD: 149 return put_user(inode->i_generation, (int __user *) arg); 150 case EXT4_IOC_SETVERSION: 151 case EXT4_IOC_SETVERSION_OLD: { 152 handle_t *handle; 153 struct ext4_iloc iloc; 154 __u32 generation; 155 int err; 156 157 if (!inode_owner_or_capable(inode)) 158 return -EPERM; 159 160 if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb, 161 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) { 162 ext4_warning(sb, "Setting inode version is not " 163 "supported with metadata_csum enabled."); 164 return -ENOTTY; 165 } 166 167 err = mnt_want_write_file(filp); 168 if (err) 169 return err; 170 if (get_user(generation, (int __user *) arg)) { 171 err = -EFAULT; 172 goto setversion_out; 173 } 174 175 mutex_lock(&inode->i_mutex); 176 handle = ext4_journal_start(inode, 1); 177 if (IS_ERR(handle)) { 178 err = PTR_ERR(handle); 179 goto unlock_out; 180 } 181 err = ext4_reserve_inode_write(handle, inode, &iloc); 182 if (err == 0) { 183 inode->i_ctime = ext4_current_time(inode); 184 inode->i_generation = generation; 185 err = ext4_mark_iloc_dirty(handle, inode, &iloc); 186 } 187 ext4_journal_stop(handle); 188 189 unlock_out: 190 mutex_unlock(&inode->i_mutex); 191 setversion_out: 192 mnt_drop_write_file(filp); 193 return err; 194 } 195 case EXT4_IOC_GROUP_EXTEND: { 196 ext4_fsblk_t n_blocks_count; 197 int err, err2=0; 198 199 err = ext4_resize_begin(sb); 200 if (err) 201 return err; 202 203 if (get_user(n_blocks_count, (__u32 __user *)arg)) { 204 err = -EFAULT; 205 goto group_extend_out; 206 } 207 208 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 209 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { 210 ext4_msg(sb, KERN_ERR, 211 "Online resizing not supported with bigalloc"); 212 err = -EOPNOTSUPP; 213 goto group_extend_out; 214 } 215 216 err = mnt_want_write_file(filp); 217 if (err) 218 goto group_extend_out; 219 220 err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count); 221 if (EXT4_SB(sb)->s_journal) { 222 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 223 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal); 224 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 225 } 226 if (err == 0) 227 err = err2; 228 mnt_drop_write_file(filp); 229 group_extend_out: 230 ext4_resize_end(sb); 231 return err; 232 } 233 234 case EXT4_IOC_MOVE_EXT: { 235 struct move_extent me; 236 struct file *donor_filp; 237 int err; 238 239 if (!(filp->f_mode & FMODE_READ) || 240 !(filp->f_mode & FMODE_WRITE)) 241 return -EBADF; 242 243 if (copy_from_user(&me, 244 (struct move_extent __user *)arg, sizeof(me))) 245 return -EFAULT; 246 me.moved_len = 0; 247 248 donor_filp = fget(me.donor_fd); 249 if (!donor_filp) 250 return -EBADF; 251 252 if (!(donor_filp->f_mode & FMODE_WRITE)) { 253 err = -EBADF; 254 goto mext_out; 255 } 256 257 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 258 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { 259 ext4_msg(sb, KERN_ERR, 260 "Online defrag not supported with bigalloc"); 261 return -EOPNOTSUPP; 262 } 263 264 err = mnt_want_write_file(filp); 265 if (err) 266 goto mext_out; 267 268 err = ext4_move_extents(filp, donor_filp, me.orig_start, 269 me.donor_start, me.len, &me.moved_len); 270 mnt_drop_write_file(filp); 271 mnt_drop_write(filp->f_path.mnt); 272 273 if (copy_to_user((struct move_extent __user *)arg, 274 &me, sizeof(me))) 275 err = -EFAULT; 276 mext_out: 277 fput(donor_filp); 278 return err; 279 } 280 281 case EXT4_IOC_GROUP_ADD: { 282 struct ext4_new_group_data input; 283 int err, err2=0; 284 285 err = ext4_resize_begin(sb); 286 if (err) 287 return err; 288 289 if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg, 290 sizeof(input))) { 291 err = -EFAULT; 292 goto group_add_out; 293 } 294 295 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 296 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { 297 ext4_msg(sb, KERN_ERR, 298 "Online resizing not supported with bigalloc"); 299 err = -EOPNOTSUPP; 300 goto group_add_out; 301 } 302 303 err = mnt_want_write_file(filp); 304 if (err) 305 goto group_add_out; 306 307 err = ext4_group_add(sb, &input); 308 if (EXT4_SB(sb)->s_journal) { 309 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 310 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal); 311 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 312 } 313 if (err == 0) 314 err = err2; 315 mnt_drop_write_file(filp); 316 group_add_out: 317 ext4_resize_end(sb); 318 return err; 319 } 320 321 case EXT4_IOC_MIGRATE: 322 { 323 int err; 324 if (!inode_owner_or_capable(inode)) 325 return -EACCES; 326 327 err = mnt_want_write_file(filp); 328 if (err) 329 return err; 330 /* 331 * inode_mutex prevent write and truncate on the file. 332 * Read still goes through. We take i_data_sem in 333 * ext4_ext_swap_inode_data before we switch the 334 * inode format to prevent read. 335 */ 336 mutex_lock(&(inode->i_mutex)); 337 err = ext4_ext_migrate(inode); 338 mutex_unlock(&(inode->i_mutex)); 339 mnt_drop_write_file(filp); 340 return err; 341 } 342 343 case EXT4_IOC_ALLOC_DA_BLKS: 344 { 345 int err; 346 if (!inode_owner_or_capable(inode)) 347 return -EACCES; 348 349 err = mnt_want_write_file(filp); 350 if (err) 351 return err; 352 err = ext4_alloc_da_blocks(inode); 353 mnt_drop_write_file(filp); 354 return err; 355 } 356 357 case EXT4_IOC_RESIZE_FS: { 358 ext4_fsblk_t n_blocks_count; 359 struct super_block *sb = inode->i_sb; 360 int err = 0, err2 = 0; 361 362 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 363 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { 364 ext4_msg(sb, KERN_ERR, 365 "Online resizing not (yet) supported with bigalloc"); 366 return -EOPNOTSUPP; 367 } 368 369 if (EXT4_HAS_INCOMPAT_FEATURE(sb, 370 EXT4_FEATURE_INCOMPAT_META_BG)) { 371 ext4_msg(sb, KERN_ERR, 372 "Online resizing not (yet) supported with meta_bg"); 373 return -EOPNOTSUPP; 374 } 375 376 if (copy_from_user(&n_blocks_count, (__u64 __user *)arg, 377 sizeof(__u64))) { 378 return -EFAULT; 379 } 380 381 if (n_blocks_count > MAX_32_NUM && 382 !EXT4_HAS_INCOMPAT_FEATURE(sb, 383 EXT4_FEATURE_INCOMPAT_64BIT)) { 384 ext4_msg(sb, KERN_ERR, 385 "File system only supports 32-bit block numbers"); 386 return -EOPNOTSUPP; 387 } 388 389 err = ext4_resize_begin(sb); 390 if (err) 391 return err; 392 393 err = mnt_want_write(filp->f_path.mnt); 394 if (err) 395 goto resizefs_out; 396 397 err = ext4_resize_fs(sb, n_blocks_count); 398 if (EXT4_SB(sb)->s_journal) { 399 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal); 400 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal); 401 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal); 402 } 403 if (err == 0) 404 err = err2; 405 mnt_drop_write(filp->f_path.mnt); 406 resizefs_out: 407 ext4_resize_end(sb); 408 return err; 409 } 410 411 case FITRIM: 412 { 413 struct request_queue *q = bdev_get_queue(sb->s_bdev); 414 struct fstrim_range range; 415 int ret = 0; 416 417 if (!capable(CAP_SYS_ADMIN)) 418 return -EPERM; 419 420 if (!blk_queue_discard(q)) 421 return -EOPNOTSUPP; 422 423 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 424 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { 425 ext4_msg(sb, KERN_ERR, 426 "FITRIM not supported with bigalloc"); 427 return -EOPNOTSUPP; 428 } 429 430 if (copy_from_user(&range, (struct fstrim_range __user *)arg, 431 sizeof(range))) 432 return -EFAULT; 433 434 range.minlen = max((unsigned int)range.minlen, 435 q->limits.discard_granularity); 436 ret = ext4_trim_fs(sb, &range); 437 if (ret < 0) 438 return ret; 439 440 if (copy_to_user((struct fstrim_range __user *)arg, &range, 441 sizeof(range))) 442 return -EFAULT; 443 444 return 0; 445 } 446 447 default: 448 return -ENOTTY; 449 } 450 } 451 452 #ifdef CONFIG_COMPAT 453 long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 454 { 455 /* These are just misnamed, they actually get/put from/to user an int */ 456 switch (cmd) { 457 case EXT4_IOC32_GETFLAGS: 458 cmd = EXT4_IOC_GETFLAGS; 459 break; 460 case EXT4_IOC32_SETFLAGS: 461 cmd = EXT4_IOC_SETFLAGS; 462 break; 463 case EXT4_IOC32_GETVERSION: 464 cmd = EXT4_IOC_GETVERSION; 465 break; 466 case EXT4_IOC32_SETVERSION: 467 cmd = EXT4_IOC_SETVERSION; 468 break; 469 case EXT4_IOC32_GROUP_EXTEND: 470 cmd = EXT4_IOC_GROUP_EXTEND; 471 break; 472 case EXT4_IOC32_GETVERSION_OLD: 473 cmd = EXT4_IOC_GETVERSION_OLD; 474 break; 475 case EXT4_IOC32_SETVERSION_OLD: 476 cmd = EXT4_IOC_SETVERSION_OLD; 477 break; 478 case EXT4_IOC32_GETRSVSZ: 479 cmd = EXT4_IOC_GETRSVSZ; 480 break; 481 case EXT4_IOC32_SETRSVSZ: 482 cmd = EXT4_IOC_SETRSVSZ; 483 break; 484 case EXT4_IOC32_GROUP_ADD: { 485 struct compat_ext4_new_group_input __user *uinput; 486 struct ext4_new_group_input input; 487 mm_segment_t old_fs; 488 int err; 489 490 uinput = compat_ptr(arg); 491 err = get_user(input.group, &uinput->group); 492 err |= get_user(input.block_bitmap, &uinput->block_bitmap); 493 err |= get_user(input.inode_bitmap, &uinput->inode_bitmap); 494 err |= get_user(input.inode_table, &uinput->inode_table); 495 err |= get_user(input.blocks_count, &uinput->blocks_count); 496 err |= get_user(input.reserved_blocks, 497 &uinput->reserved_blocks); 498 if (err) 499 return -EFAULT; 500 old_fs = get_fs(); 501 set_fs(KERNEL_DS); 502 err = ext4_ioctl(file, EXT4_IOC_GROUP_ADD, 503 (unsigned long) &input); 504 set_fs(old_fs); 505 return err; 506 } 507 case EXT4_IOC_MOVE_EXT: 508 case FITRIM: 509 case EXT4_IOC_RESIZE_FS: 510 break; 511 default: 512 return -ENOIOCTLCMD; 513 } 514 return ext4_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); 515 } 516 #endif 517