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