1 /* 2 * linux/fs/ioctl.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7 #include <linux/syscalls.h> 8 #include <linux/mm.h> 9 #include <linux/smp_lock.h> 10 #include <linux/capability.h> 11 #include <linux/file.h> 12 #include <linux/fs.h> 13 #include <linux/security.h> 14 #include <linux/module.h> 15 #include <linux/uaccess.h> 16 #include <linux/writeback.h> 17 #include <linux/buffer_head.h> 18 #include <linux/falloc.h> 19 20 #include <asm/ioctls.h> 21 22 /* So that the fiemap access checks can't overflow on 32 bit machines. */ 23 #define FIEMAP_MAX_EXTENTS (UINT_MAX / sizeof(struct fiemap_extent)) 24 25 /** 26 * vfs_ioctl - call filesystem specific ioctl methods 27 * @filp: open file to invoke ioctl method on 28 * @cmd: ioctl command to execute 29 * @arg: command-specific argument for ioctl 30 * 31 * Invokes filesystem specific ->unlocked_ioctl, if one exists; otherwise 32 * invokes filesystem specific ->ioctl method. If neither method exists, 33 * returns -ENOTTY. 34 * 35 * Returns 0 on success, -errno on error. 36 */ 37 static long vfs_ioctl(struct file *filp, unsigned int cmd, 38 unsigned long arg) 39 { 40 int error = -ENOTTY; 41 42 if (!filp->f_op) 43 goto out; 44 45 if (filp->f_op->unlocked_ioctl) { 46 error = filp->f_op->unlocked_ioctl(filp, cmd, arg); 47 if (error == -ENOIOCTLCMD) 48 error = -EINVAL; 49 goto out; 50 } else if (filp->f_op->ioctl) { 51 lock_kernel(); 52 error = filp->f_op->ioctl(filp->f_path.dentry->d_inode, 53 filp, cmd, arg); 54 unlock_kernel(); 55 } 56 57 out: 58 return error; 59 } 60 61 static int ioctl_fibmap(struct file *filp, int __user *p) 62 { 63 struct address_space *mapping = filp->f_mapping; 64 int res, block; 65 66 /* do we support this mess? */ 67 if (!mapping->a_ops->bmap) 68 return -EINVAL; 69 if (!capable(CAP_SYS_RAWIO)) 70 return -EPERM; 71 res = get_user(block, p); 72 if (res) 73 return res; 74 res = mapping->a_ops->bmap(mapping, block); 75 return put_user(res, p); 76 } 77 78 /** 79 * fiemap_fill_next_extent - Fiemap helper function 80 * @fieinfo: Fiemap context passed into ->fiemap 81 * @logical: Extent logical start offset, in bytes 82 * @phys: Extent physical start offset, in bytes 83 * @len: Extent length, in bytes 84 * @flags: FIEMAP_EXTENT flags that describe this extent 85 * 86 * Called from file system ->fiemap callback. Will populate extent 87 * info as passed in via arguments and copy to user memory. On 88 * success, extent count on fieinfo is incremented. 89 * 90 * Returns 0 on success, -errno on error, 1 if this was the last 91 * extent that will fit in user array. 92 */ 93 #define SET_UNKNOWN_FLAGS (FIEMAP_EXTENT_DELALLOC) 94 #define SET_NO_UNMOUNTED_IO_FLAGS (FIEMAP_EXTENT_DATA_ENCRYPTED) 95 #define SET_NOT_ALIGNED_FLAGS (FIEMAP_EXTENT_DATA_TAIL|FIEMAP_EXTENT_DATA_INLINE) 96 int fiemap_fill_next_extent(struct fiemap_extent_info *fieinfo, u64 logical, 97 u64 phys, u64 len, u32 flags) 98 { 99 struct fiemap_extent extent; 100 struct fiemap_extent *dest = fieinfo->fi_extents_start; 101 102 /* only count the extents */ 103 if (fieinfo->fi_extents_max == 0) { 104 fieinfo->fi_extents_mapped++; 105 return (flags & FIEMAP_EXTENT_LAST) ? 1 : 0; 106 } 107 108 if (fieinfo->fi_extents_mapped >= fieinfo->fi_extents_max) 109 return 1; 110 111 if (flags & SET_UNKNOWN_FLAGS) 112 flags |= FIEMAP_EXTENT_UNKNOWN; 113 if (flags & SET_NO_UNMOUNTED_IO_FLAGS) 114 flags |= FIEMAP_EXTENT_ENCODED; 115 if (flags & SET_NOT_ALIGNED_FLAGS) 116 flags |= FIEMAP_EXTENT_NOT_ALIGNED; 117 118 memset(&extent, 0, sizeof(extent)); 119 extent.fe_logical = logical; 120 extent.fe_physical = phys; 121 extent.fe_length = len; 122 extent.fe_flags = flags; 123 124 dest += fieinfo->fi_extents_mapped; 125 if (copy_to_user(dest, &extent, sizeof(extent))) 126 return -EFAULT; 127 128 fieinfo->fi_extents_mapped++; 129 if (fieinfo->fi_extents_mapped == fieinfo->fi_extents_max) 130 return 1; 131 return (flags & FIEMAP_EXTENT_LAST) ? 1 : 0; 132 } 133 EXPORT_SYMBOL(fiemap_fill_next_extent); 134 135 /** 136 * fiemap_check_flags - check validity of requested flags for fiemap 137 * @fieinfo: Fiemap context passed into ->fiemap 138 * @fs_flags: Set of fiemap flags that the file system understands 139 * 140 * Called from file system ->fiemap callback. This will compute the 141 * intersection of valid fiemap flags and those that the fs supports. That 142 * value is then compared against the user supplied flags. In case of bad user 143 * flags, the invalid values will be written into the fieinfo structure, and 144 * -EBADR is returned, which tells ioctl_fiemap() to return those values to 145 * userspace. For this reason, a return code of -EBADR should be preserved. 146 * 147 * Returns 0 on success, -EBADR on bad flags. 148 */ 149 int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags) 150 { 151 u32 incompat_flags; 152 153 incompat_flags = fieinfo->fi_flags & ~(FIEMAP_FLAGS_COMPAT & fs_flags); 154 if (incompat_flags) { 155 fieinfo->fi_flags = incompat_flags; 156 return -EBADR; 157 } 158 return 0; 159 } 160 EXPORT_SYMBOL(fiemap_check_flags); 161 162 static int fiemap_check_ranges(struct super_block *sb, 163 u64 start, u64 len, u64 *new_len) 164 { 165 u64 maxbytes = (u64) sb->s_maxbytes; 166 167 *new_len = len; 168 169 if (len == 0) 170 return -EINVAL; 171 172 if (start > maxbytes) 173 return -EFBIG; 174 175 /* 176 * Shrink request scope to what the fs can actually handle. 177 */ 178 if (len > maxbytes || (maxbytes - len) < start) 179 *new_len = maxbytes - start; 180 181 return 0; 182 } 183 184 static int ioctl_fiemap(struct file *filp, unsigned long arg) 185 { 186 struct fiemap fiemap; 187 struct fiemap_extent_info fieinfo = { 0, }; 188 struct inode *inode = filp->f_path.dentry->d_inode; 189 struct super_block *sb = inode->i_sb; 190 u64 len; 191 int error; 192 193 if (!inode->i_op->fiemap) 194 return -EOPNOTSUPP; 195 196 if (copy_from_user(&fiemap, (struct fiemap __user *)arg, 197 sizeof(struct fiemap))) 198 return -EFAULT; 199 200 if (fiemap.fm_extent_count > FIEMAP_MAX_EXTENTS) 201 return -EINVAL; 202 203 error = fiemap_check_ranges(sb, fiemap.fm_start, fiemap.fm_length, 204 &len); 205 if (error) 206 return error; 207 208 fieinfo.fi_flags = fiemap.fm_flags; 209 fieinfo.fi_extents_max = fiemap.fm_extent_count; 210 fieinfo.fi_extents_start = (struct fiemap_extent *)(arg + sizeof(fiemap)); 211 212 if (fiemap.fm_extent_count != 0 && 213 !access_ok(VERIFY_WRITE, fieinfo.fi_extents_start, 214 fieinfo.fi_extents_max * sizeof(struct fiemap_extent))) 215 return -EFAULT; 216 217 if (fieinfo.fi_flags & FIEMAP_FLAG_SYNC) 218 filemap_write_and_wait(inode->i_mapping); 219 220 error = inode->i_op->fiemap(inode, &fieinfo, fiemap.fm_start, len); 221 fiemap.fm_flags = fieinfo.fi_flags; 222 fiemap.fm_mapped_extents = fieinfo.fi_extents_mapped; 223 if (copy_to_user((char *)arg, &fiemap, sizeof(fiemap))) 224 error = -EFAULT; 225 226 return error; 227 } 228 229 #ifdef CONFIG_BLOCK 230 231 static inline sector_t logical_to_blk(struct inode *inode, loff_t offset) 232 { 233 return (offset >> inode->i_blkbits); 234 } 235 236 static inline loff_t blk_to_logical(struct inode *inode, sector_t blk) 237 { 238 return (blk << inode->i_blkbits); 239 } 240 241 /** 242 * __generic_block_fiemap - FIEMAP for block based inodes (no locking) 243 * @inode: the inode to map 244 * @fieinfo: the fiemap info struct that will be passed back to userspace 245 * @start: where to start mapping in the inode 246 * @len: how much space to map 247 * @get_block: the fs's get_block function 248 * 249 * This does FIEMAP for block based inodes. Basically it will just loop 250 * through get_block until we hit the number of extents we want to map, or we 251 * go past the end of the file and hit a hole. 252 * 253 * If it is possible to have data blocks beyond a hole past @inode->i_size, then 254 * please do not use this function, it will stop at the first unmapped block 255 * beyond i_size. 256 * 257 * If you use this function directly, you need to do your own locking. Use 258 * generic_block_fiemap if you want the locking done for you. 259 */ 260 261 int __generic_block_fiemap(struct inode *inode, 262 struct fiemap_extent_info *fieinfo, loff_t start, 263 loff_t len, get_block_t *get_block) 264 { 265 struct buffer_head map_bh; 266 sector_t start_blk, last_blk; 267 loff_t isize = i_size_read(inode); 268 u64 logical = 0, phys = 0, size = 0; 269 u32 flags = FIEMAP_EXTENT_MERGED; 270 bool past_eof = false, whole_file = false; 271 int ret = 0; 272 273 ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC); 274 if (ret) 275 return ret; 276 277 /* 278 * Either the i_mutex or other appropriate locking needs to be held 279 * since we expect isize to not change at all through the duration of 280 * this call. 281 */ 282 if (len >= isize) { 283 whole_file = true; 284 len = isize; 285 } 286 287 start_blk = logical_to_blk(inode, start); 288 last_blk = logical_to_blk(inode, start + len - 1); 289 290 do { 291 /* 292 * we set b_size to the total size we want so it will map as 293 * many contiguous blocks as possible at once 294 */ 295 memset(&map_bh, 0, sizeof(struct buffer_head)); 296 map_bh.b_size = len; 297 298 ret = get_block(inode, start_blk, &map_bh, 0); 299 if (ret) 300 break; 301 302 /* HOLE */ 303 if (!buffer_mapped(&map_bh)) { 304 start_blk++; 305 306 /* 307 * We want to handle the case where there is an 308 * allocated block at the front of the file, and then 309 * nothing but holes up to the end of the file properly, 310 * to make sure that extent at the front gets properly 311 * marked with FIEMAP_EXTENT_LAST 312 */ 313 if (!past_eof && 314 blk_to_logical(inode, start_blk) >= isize) 315 past_eof = 1; 316 317 /* 318 * First hole after going past the EOF, this is our 319 * last extent 320 */ 321 if (past_eof && size) { 322 flags = FIEMAP_EXTENT_MERGED|FIEMAP_EXTENT_LAST; 323 ret = fiemap_fill_next_extent(fieinfo, logical, 324 phys, size, 325 flags); 326 } else if (size) { 327 ret = fiemap_fill_next_extent(fieinfo, logical, 328 phys, size, flags); 329 size = 0; 330 } 331 332 /* if we have holes up to/past EOF then we're done */ 333 if (start_blk > last_blk || past_eof || ret) 334 break; 335 } else { 336 /* 337 * We have gone over the length of what we wanted to 338 * map, and it wasn't the entire file, so add the extent 339 * we got last time and exit. 340 * 341 * This is for the case where say we want to map all the 342 * way up to the second to the last block in a file, but 343 * the last block is a hole, making the second to last 344 * block FIEMAP_EXTENT_LAST. In this case we want to 345 * see if there is a hole after the second to last block 346 * so we can mark it properly. If we found data after 347 * we exceeded the length we were requesting, then we 348 * are good to go, just add the extent to the fieinfo 349 * and break 350 */ 351 if (start_blk > last_blk && !whole_file) { 352 ret = fiemap_fill_next_extent(fieinfo, logical, 353 phys, size, 354 flags); 355 break; 356 } 357 358 /* 359 * if size != 0 then we know we already have an extent 360 * to add, so add it. 361 */ 362 if (size) { 363 ret = fiemap_fill_next_extent(fieinfo, logical, 364 phys, size, 365 flags); 366 if (ret) 367 break; 368 } 369 370 logical = blk_to_logical(inode, start_blk); 371 phys = blk_to_logical(inode, map_bh.b_blocknr); 372 size = map_bh.b_size; 373 flags = FIEMAP_EXTENT_MERGED; 374 375 start_blk += logical_to_blk(inode, size); 376 377 /* 378 * If we are past the EOF, then we need to make sure as 379 * soon as we find a hole that the last extent we found 380 * is marked with FIEMAP_EXTENT_LAST 381 */ 382 if (!past_eof && logical + size >= isize) 383 past_eof = true; 384 } 385 cond_resched(); 386 } while (1); 387 388 /* If ret is 1 then we just hit the end of the extent array */ 389 if (ret == 1) 390 ret = 0; 391 392 return ret; 393 } 394 EXPORT_SYMBOL(__generic_block_fiemap); 395 396 /** 397 * generic_block_fiemap - FIEMAP for block based inodes 398 * @inode: The inode to map 399 * @fieinfo: The mapping information 400 * @start: The initial block to map 401 * @len: The length of the extect to attempt to map 402 * @get_block: The block mapping function for the fs 403 * 404 * Calls __generic_block_fiemap to map the inode, after taking 405 * the inode's mutex lock. 406 */ 407 408 int generic_block_fiemap(struct inode *inode, 409 struct fiemap_extent_info *fieinfo, u64 start, 410 u64 len, get_block_t *get_block) 411 { 412 int ret; 413 mutex_lock(&inode->i_mutex); 414 ret = __generic_block_fiemap(inode, fieinfo, start, len, get_block); 415 mutex_unlock(&inode->i_mutex); 416 return ret; 417 } 418 EXPORT_SYMBOL(generic_block_fiemap); 419 420 #endif /* CONFIG_BLOCK */ 421 422 /* 423 * This provides compatibility with legacy XFS pre-allocation ioctls 424 * which predate the fallocate syscall. 425 * 426 * Only the l_start, l_len and l_whence fields of the 'struct space_resv' 427 * are used here, rest are ignored. 428 */ 429 int ioctl_preallocate(struct file *filp, void __user *argp) 430 { 431 struct inode *inode = filp->f_path.dentry->d_inode; 432 struct space_resv sr; 433 434 if (copy_from_user(&sr, argp, sizeof(sr))) 435 return -EFAULT; 436 437 switch (sr.l_whence) { 438 case SEEK_SET: 439 break; 440 case SEEK_CUR: 441 sr.l_start += filp->f_pos; 442 break; 443 case SEEK_END: 444 sr.l_start += i_size_read(inode); 445 break; 446 default: 447 return -EINVAL; 448 } 449 450 return do_fallocate(filp, FALLOC_FL_KEEP_SIZE, sr.l_start, sr.l_len); 451 } 452 453 static int file_ioctl(struct file *filp, unsigned int cmd, 454 unsigned long arg) 455 { 456 struct inode *inode = filp->f_path.dentry->d_inode; 457 int __user *p = (int __user *)arg; 458 459 switch (cmd) { 460 case FIBMAP: 461 return ioctl_fibmap(filp, p); 462 case FIONREAD: 463 return put_user(i_size_read(inode) - filp->f_pos, p); 464 case FS_IOC_RESVSP: 465 case FS_IOC_RESVSP64: 466 return ioctl_preallocate(filp, p); 467 } 468 469 return vfs_ioctl(filp, cmd, arg); 470 } 471 472 static int ioctl_fionbio(struct file *filp, int __user *argp) 473 { 474 unsigned int flag; 475 int on, error; 476 477 error = get_user(on, argp); 478 if (error) 479 return error; 480 flag = O_NONBLOCK; 481 #ifdef __sparc__ 482 /* SunOS compatibility item. */ 483 if (O_NONBLOCK != O_NDELAY) 484 flag |= O_NDELAY; 485 #endif 486 spin_lock(&filp->f_lock); 487 if (on) 488 filp->f_flags |= flag; 489 else 490 filp->f_flags &= ~flag; 491 spin_unlock(&filp->f_lock); 492 return error; 493 } 494 495 static int ioctl_fioasync(unsigned int fd, struct file *filp, 496 int __user *argp) 497 { 498 unsigned int flag; 499 int on, error; 500 501 error = get_user(on, argp); 502 if (error) 503 return error; 504 flag = on ? FASYNC : 0; 505 506 /* Did FASYNC state change ? */ 507 if ((flag ^ filp->f_flags) & FASYNC) { 508 if (filp->f_op && filp->f_op->fasync) 509 /* fasync() adjusts filp->f_flags */ 510 error = filp->f_op->fasync(fd, filp, on); 511 else 512 error = -ENOTTY; 513 } 514 return error < 0 ? error : 0; 515 } 516 517 static int ioctl_fsfreeze(struct file *filp) 518 { 519 struct super_block *sb = filp->f_path.dentry->d_inode->i_sb; 520 521 if (!capable(CAP_SYS_ADMIN)) 522 return -EPERM; 523 524 /* If filesystem doesn't support freeze feature, return. */ 525 if (sb->s_op->freeze_fs == NULL) 526 return -EOPNOTSUPP; 527 528 /* Freeze */ 529 return freeze_super(sb); 530 } 531 532 static int ioctl_fsthaw(struct file *filp) 533 { 534 struct super_block *sb = filp->f_path.dentry->d_inode->i_sb; 535 536 if (!capable(CAP_SYS_ADMIN)) 537 return -EPERM; 538 539 /* Thaw */ 540 return thaw_super(sb); 541 } 542 543 /* 544 * When you add any new common ioctls to the switches above and below 545 * please update compat_sys_ioctl() too. 546 * 547 * do_vfs_ioctl() is not for drivers and not intended to be EXPORT_SYMBOL()'d. 548 * It's just a simple helper for sys_ioctl and compat_sys_ioctl. 549 */ 550 int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd, 551 unsigned long arg) 552 { 553 int error = 0; 554 int __user *argp = (int __user *)arg; 555 556 switch (cmd) { 557 case FIOCLEX: 558 set_close_on_exec(fd, 1); 559 break; 560 561 case FIONCLEX: 562 set_close_on_exec(fd, 0); 563 break; 564 565 case FIONBIO: 566 error = ioctl_fionbio(filp, argp); 567 break; 568 569 case FIOASYNC: 570 error = ioctl_fioasync(fd, filp, argp); 571 break; 572 573 case FIOQSIZE: 574 if (S_ISDIR(filp->f_path.dentry->d_inode->i_mode) || 575 S_ISREG(filp->f_path.dentry->d_inode->i_mode) || 576 S_ISLNK(filp->f_path.dentry->d_inode->i_mode)) { 577 loff_t res = 578 inode_get_bytes(filp->f_path.dentry->d_inode); 579 error = copy_to_user((loff_t __user *)arg, &res, 580 sizeof(res)) ? -EFAULT : 0; 581 } else 582 error = -ENOTTY; 583 break; 584 585 case FIFREEZE: 586 error = ioctl_fsfreeze(filp); 587 break; 588 589 case FITHAW: 590 error = ioctl_fsthaw(filp); 591 break; 592 593 case FS_IOC_FIEMAP: 594 return ioctl_fiemap(filp, arg); 595 596 case FIGETBSZ: 597 { 598 struct inode *inode = filp->f_path.dentry->d_inode; 599 int __user *p = (int __user *)arg; 600 return put_user(inode->i_sb->s_blocksize, p); 601 } 602 603 default: 604 if (S_ISREG(filp->f_path.dentry->d_inode->i_mode)) 605 error = file_ioctl(filp, cmd, arg); 606 else 607 error = vfs_ioctl(filp, cmd, arg); 608 break; 609 } 610 return error; 611 } 612 613 SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, unsigned long, arg) 614 { 615 struct file *filp; 616 int error = -EBADF; 617 int fput_needed; 618 619 filp = fget_light(fd, &fput_needed); 620 if (!filp) 621 goto out; 622 623 error = security_file_ioctl(filp, cmd, arg); 624 if (error) 625 goto out_fput; 626 627 error = do_vfs_ioctl(filp, fd, cmd, arg); 628 out_fput: 629 fput_light(filp, fput_needed); 630 out: 631 return error; 632 } 633