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