fs/ioctl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/ioctl.c
   4  *
   5  *  Copyright (C) 1991, 1992  Linus Torvalds
   6  */
   7
   8 #include <linux/syscalls.h>
   9 #include <linux/mm.h>
  10 #include <linux/capability.h>
  11 #include <linux/compat.h>
  12 #include <linux/file.h>
  13 #include <linux/fs.h>
  14 #include <linux/security.h>
  15 #include <linux/export.h>
  16 #include <linux/uaccess.h>
  17 #include <linux/writeback.h>
  18 #include <linux/buffer_head.h>
  19 #include <linux/falloc.h>
  20 #include <linux/sched/signal.h>
  21
  22 #include "internal.h"
  23
  24 #include <asm/ioctls.h>
  25
  26 /* So that the fiemap access checks can't overflow on 32 bit machines. */
  27 #define FIEMAP_MAX_EXTENTS      (UINT_MAX / sizeof(struct fiemap_extent))
  28
  29 /**
  30  * vfs_ioctl - call filesystem specific ioctl methods
  31  * @filp:       open file to invoke ioctl method on
  32  * @cmd:        ioctl command to execute
  33  * @arg:        command-specific argument for ioctl
  34  *
  35  * Invokes filesystem specific ->unlocked_ioctl, if one exists; otherwise
  36  * returns -ENOTTY.
  37  *
  38  * Returns 0 on success, -errno on error.
  39  */
  40 long vfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
  41 {
  42         int error = -ENOTTY;
  43
  44         if (!filp->f_op->unlocked_ioctl)
  45                 goto out;
  46
  47         error = filp->f_op->unlocked_ioctl(filp, cmd, arg);
  48         if (error == -ENOIOCTLCMD)
  49                 error = -ENOTTY;
  50  out:
  51         return error;
  52 }
  53 EXPORT_SYMBOL(vfs_ioctl);
  54
  55 static int ioctl_fibmap(struct file *filp, int __user *p)
  56 {
  57         struct inode *inode = file_inode(filp);
  58         struct super_block *sb = inode->i_sb;
  59         int error, ur_block;
  60         sector_t block;
  61
  62         if (!capable(CAP_SYS_RAWIO))
  63                 return -EPERM;
  64
  65         error = get_user(ur_block, p);
  66         if (error)
  67                 return error;
  68
  69         if (ur_block < 0)
  70                 return -EINVAL;
  71
  72         block = ur_block;
  73         error = bmap(inode, &block);
  74
  75         if (block > INT_MAX) {
  76                 error = -ERANGE;
  77                 pr_warn_ratelimited("[%s/%d] FS: %s File: %pD4 would truncate fibmap result\n",
  78                                     current->comm, task_pid_nr(current),
  79                                     sb->s_id, filp);
  80         }
  81
  82         if (error)
  83                 ur_block = 0;
  84         else
  85                 ur_block = block;
  86
  87         if (put_user(ur_block, p))
  88                 error = -EFAULT;
  89
  90         return error;
  91 }
  92
  93 /**
  94  * fiemap_fill_next_extent - Fiemap helper function
  95  * @fieinfo:    Fiemap context passed into ->fiemap
  96  * @logical:    Extent logical start offset, in bytes
  97  * @phys:       Extent physical start offset, in bytes
  98  * @len:        Extent length, in bytes
  99  * @flags:      FIEMAP_EXTENT flags that describe this extent
 100  *
 101  * Called from file system ->fiemap callback. Will populate extent
 102  * info as passed in via arguments and copy to user memory. On
 103  * success, extent count on fieinfo is incremented.
 104  *
 105  * Returns 0 on success, -errno on error, 1 if this was the last
 106  * extent that will fit in user array.
 107  */
 108 #define SET_UNKNOWN_FLAGS       (FIEMAP_EXTENT_DELALLOC)
 109 #define SET_NO_UNMOUNTED_IO_FLAGS       (FIEMAP_EXTENT_DATA_ENCRYPTED)
 110 #define SET_NOT_ALIGNED_FLAGS   (FIEMAP_EXTENT_DATA_TAIL|FIEMAP_EXTENT_DATA_INLINE)
 111 int fiemap_fill_next_extent(struct fiemap_extent_info *fieinfo, u64 logical,
 112                             u64 phys, u64 len, u32 flags)
 113 {
 114         struct fiemap_extent extent;
 115         struct fiemap_extent __user *dest = fieinfo->fi_extents_start;
 116
 117         /* only count the extents */
 118         if (fieinfo->fi_extents_max == 0) {
 119                 fieinfo->fi_extents_mapped++;
 120                 return (flags & FIEMAP_EXTENT_LAST) ? 1 : 0;
 121         }
 122
 123         if (fieinfo->fi_extents_mapped >= fieinfo->fi_extents_max)
 124                 return 1;
 125
 126         if (flags & SET_UNKNOWN_FLAGS)
 127                 flags |= FIEMAP_EXTENT_UNKNOWN;
 128         if (flags & SET_NO_UNMOUNTED_IO_FLAGS)
 129                 flags |= FIEMAP_EXTENT_ENCODED;
 130         if (flags & SET_NOT_ALIGNED_FLAGS)
 131                 flags |= FIEMAP_EXTENT_NOT_ALIGNED;
 132
 133         memset(&extent, 0, sizeof(extent));
 134         extent.fe_logical = logical;
 135         extent.fe_physical = phys;
 136         extent.fe_length = len;
 137         extent.fe_flags = flags;
 138
 139         dest += fieinfo->fi_extents_mapped;
 140         if (copy_to_user(dest, &extent, sizeof(extent)))
 141                 return -EFAULT;
 142
 143         fieinfo->fi_extents_mapped++;
 144         if (fieinfo->fi_extents_mapped == fieinfo->fi_extents_max)
 145                 return 1;
 146         return (flags & FIEMAP_EXTENT_LAST) ? 1 : 0;
 147 }
 148 EXPORT_SYMBOL(fiemap_fill_next_extent);
 149
 150 /**
 151  * fiemap_check_flags - check validity of requested flags for fiemap
 152  * @fieinfo:    Fiemap context passed into ->fiemap
 153  * @fs_flags:   Set of fiemap flags that the file system understands
 154  *
 155  * Called from file system ->fiemap callback. This will compute the
 156  * intersection of valid fiemap flags and those that the fs supports. That
 157  * value is then compared against the user supplied flags. In case of bad user
 158  * flags, the invalid values will be written into the fieinfo structure, and
 159  * -EBADR is returned, which tells ioctl_fiemap() to return those values to
 160  * userspace. For this reason, a return code of -EBADR should be preserved.
 161  *
 162  * Returns 0 on success, -EBADR on bad flags.
 163  */
 164 int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags)
 165 {
 166         u32 incompat_flags;
 167
 168         incompat_flags = fieinfo->fi_flags & ~(FIEMAP_FLAGS_COMPAT & fs_flags);
 169         if (incompat_flags) {
 170                 fieinfo->fi_flags = incompat_flags;
 171                 return -EBADR;
 172         }
 173         return 0;
 174 }
 175 EXPORT_SYMBOL(fiemap_check_flags);
 176
 177 static int fiemap_check_ranges(struct super_block *sb,
 178                                u64 start, u64 len, u64 *new_len)
 179 {
 180         u64 maxbytes = (u64) sb->s_maxbytes;
 181
 182         *new_len = len;
 183
 184         if (len == 0)
 185                 return -EINVAL;
 186
 187         if (start > maxbytes)
 188                 return -EFBIG;
 189
 190         /*
 191          * Shrink request scope to what the fs can actually handle.
 192          */
 193         if (len > maxbytes || (maxbytes - len) < start)
 194                 *new_len = maxbytes - start;
 195
 196         return 0;
 197 }
 198
 199 static int ioctl_fiemap(struct file *filp, struct fiemap __user *ufiemap)
 200 {
 201         struct fiemap fiemap;
 202         struct fiemap_extent_info fieinfo = { 0, };
 203         struct inode *inode = file_inode(filp);
 204         struct super_block *sb = inode->i_sb;
 205         u64 len;
 206         int error;
 207
 208         if (!inode->i_op->fiemap)
 209                 return -EOPNOTSUPP;
 210
 211         if (copy_from_user(&fiemap, ufiemap, sizeof(fiemap)))
 212                 return -EFAULT;
 213
 214         if (fiemap.fm_extent_count > FIEMAP_MAX_EXTENTS)
 215                 return -EINVAL;
 216
 217         error = fiemap_check_ranges(sb, fiemap.fm_start, fiemap.fm_length,
 218                                     &len);
 219         if (error)
 220                 return error;
 221
 222         fieinfo.fi_flags = fiemap.fm_flags;
 223         fieinfo.fi_extents_max = fiemap.fm_extent_count;
 224         fieinfo.fi_extents_start = ufiemap->fm_extents;
 225
 226         if (fiemap.fm_extent_count != 0 &&
 227             !access_ok(fieinfo.fi_extents_start,
 228                        fieinfo.fi_extents_max * sizeof(struct fiemap_extent)))
 229                 return -EFAULT;
 230
 231         if (fieinfo.fi_flags & FIEMAP_FLAG_SYNC)
 232                 filemap_write_and_wait(inode->i_mapping);
 233
 234         error = inode->i_op->fiemap(inode, &fieinfo, fiemap.fm_start, len);
 235         fiemap.fm_flags = fieinfo.fi_flags;
 236         fiemap.fm_mapped_extents = fieinfo.fi_extents_mapped;
 237         if (copy_to_user(ufiemap, &fiemap, sizeof(fiemap)))
 238                 error = -EFAULT;
 239
 240         return error;
 241 }
 242
 243 static long ioctl_file_clone(struct file *dst_file, unsigned long srcfd,
 244                              u64 off, u64 olen, u64 destoff)
 245 {
 246         struct fd src_file = fdget(srcfd);
 247         loff_t cloned;
 248         int ret;
 249
 250         if (!src_file.file)
 251                 return -EBADF;
 252         ret = -EXDEV;
 253         if (src_file.file->f_path.mnt != dst_file->f_path.mnt)
 254                 goto fdput;
 255         cloned = vfs_clone_file_range(src_file.file, off, dst_file, destoff,
 256                                       olen, 0);
 257         if (cloned < 0)
 258                 ret = cloned;
 259         else if (olen && cloned != olen)
 260                 ret = -EINVAL;
 261         else
 262                 ret = 0;
 263 fdput:
 264         fdput(src_file);
 265         return ret;
 266 }
 267
 268 static long ioctl_file_clone_range(struct file *file,
 269                                    struct file_clone_range __user *argp)
 270 {
 271         struct file_clone_range args;
 272
 273         if (copy_from_user(&args, argp, sizeof(args)))
 274                 return -EFAULT;
 275         return ioctl_file_clone(file, args.src_fd, args.src_offset,
 276                                 args.src_length, args.dest_offset);
 277 }
 278
 279 #ifdef CONFIG_BLOCK
 280
 281 static inline sector_t logical_to_blk(struct inode *inode, loff_t offset)
 282 {
 283         return (offset >> inode->i_blkbits);
 284 }
 285
 286 static inline loff_t blk_to_logical(struct inode *inode, sector_t blk)
 287 {
 288         return (blk << inode->i_blkbits);
 289 }
 290
 291 /**
 292  * __generic_block_fiemap - FIEMAP for block based inodes (no locking)
 293  * @inode: the inode to map
 294  * @fieinfo: the fiemap info struct that will be passed back to userspace
 295  * @start: where to start mapping in the inode
 296  * @len: how much space to map
 297  * @get_block: the fs's get_block function
 298  *
 299  * This does FIEMAP for block based inodes.  Basically it will just loop
 300  * through get_block until we hit the number of extents we want to map, or we
 301  * go past the end of the file and hit a hole.
 302  *
 303  * If it is possible to have data blocks beyond a hole past @inode->i_size, then
 304  * please do not use this function, it will stop at the first unmapped block
 305  * beyond i_size.
 306  *
 307  * If you use this function directly, you need to do your own locking. Use
 308  * generic_block_fiemap if you want the locking done for you.
 309  */
 310 static int __generic_block_fiemap(struct inode *inode,
 311                            struct fiemap_extent_info *fieinfo, loff_t start,
 312                            loff_t len, get_block_t *get_block)
 313 {
 314         struct buffer_head map_bh;
 315         sector_t start_blk, last_blk;
 316         loff_t isize = i_size_read(inode);
 317         u64 logical = 0, phys = 0, size = 0;
 318         u32 flags = FIEMAP_EXTENT_MERGED;
 319         bool past_eof = false, whole_file = false;
 320         int ret = 0;
 321
 322         ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
 323         if (ret)
 324                 return ret;
 325
 326         /*
 327          * Either the i_mutex or other appropriate locking needs to be held
 328          * since we expect isize to not change at all through the duration of
 329          * this call.
 330          */
 331         if (len >= isize) {
 332                 whole_file = true;
 333                 len = isize;
 334         }
 335
 336         /*
 337          * Some filesystems can't deal with being asked to map less than
 338          * blocksize, so make sure our len is at least block length.
 339          */
 340         if (logical_to_blk(inode, len) == 0)
 341                 len = blk_to_logical(inode, 1);
 342
 343         start_blk = logical_to_blk(inode, start);
 344         last_blk = logical_to_blk(inode, start + len - 1);
 345
 346         do {
 347                 /*
 348                  * we set b_size to the total size we want so it will map as
 349                  * many contiguous blocks as possible at once
 350                  */
 351                 memset(&map_bh, 0, sizeof(struct buffer_head));
 352                 map_bh.b_size = len;
 353
 354                 ret = get_block(inode, start_blk, &map_bh, 0);
 355                 if (ret)
 356                         break;
 357
 358                 /* HOLE */
 359                 if (!buffer_mapped(&map_bh)) {
 360                         start_blk++;
 361
 362                         /*
 363                          * We want to handle the case where there is an
 364                          * allocated block at the front of the file, and then
 365                          * nothing but holes up to the end of the file properly,
 366                          * to make sure that extent at the front gets properly
 367                          * marked with FIEMAP_EXTENT_LAST
 368                          */
 369                         if (!past_eof &&
 370                             blk_to_logical(inode, start_blk) >= isize)
 371                                 past_eof = 1;
 372
 373                         /*
 374                          * First hole after going past the EOF, this is our
 375                          * last extent
 376                          */
 377                         if (past_eof && size) {
 378                                 flags = FIEMAP_EXTENT_MERGED|FIEMAP_EXTENT_LAST;
 379                                 ret = fiemap_fill_next_extent(fieinfo, logical,
 380                                                               phys, size,
 381                                                               flags);
 382                         } else if (size) {
 383                                 ret = fiemap_fill_next_extent(fieinfo, logical,
 384                                                               phys, size, flags);
 385                                 size = 0;
 386                         }
 387
 388                         /* if we have holes up to/past EOF then we're done */
 389                         if (start_blk > last_blk || past_eof || ret)
 390                                 break;
 391                 } else {
 392                         /*
 393                          * We have gone over the length of what we wanted to
 394                          * map, and it wasn't the entire file, so add the extent
 395                          * we got last time and exit.
 396                          *
 397                          * This is for the case where say we want to map all the
 398                          * way up to the second to the last block in a file, but
 399                          * the last block is a hole, making the second to last
 400                          * block FIEMAP_EXTENT_LAST.  In this case we want to
 401                          * see if there is a hole after the second to last block
 402                          * so we can mark it properly.  If we found data after
 403                          * we exceeded the length we were requesting, then we
 404                          * are good to go, just add the extent to the fieinfo
 405                          * and break
 406                          */
 407                         if (start_blk > last_blk && !whole_file) {
 408                                 ret = fiemap_fill_next_extent(fieinfo, logical,
 409                                                               phys, size,
 410                                                               flags);
 411                                 break;
 412                         }
 413
 414                         /*
 415                          * if size != 0 then we know we already have an extent
 416                          * to add, so add it.
 417                          */
 418                         if (size) {
 419                                 ret = fiemap_fill_next_extent(fieinfo, logical,
 420                                                               phys, size,
 421                                                               flags);
 422                                 if (ret)
 423                                         break;
 424                         }
 425
 426                         logical = blk_to_logical(inode, start_blk);
 427                         phys = blk_to_logical(inode, map_bh.b_blocknr);
 428                         size = map_bh.b_size;
 429                         flags = FIEMAP_EXTENT_MERGED;
 430
 431                         start_blk += logical_to_blk(inode, size);
 432
 433                         /*
 434                          * If we are past the EOF, then we need to make sure as
 435                          * soon as we find a hole that the last extent we found
 436                          * is marked with FIEMAP_EXTENT_LAST
 437                          */
 438                         if (!past_eof && logical + size >= isize)
 439                                 past_eof = true;
 440                 }
 441                 cond_resched();
 442                 if (fatal_signal_pending(current)) {
 443                         ret = -EINTR;
 444                         break;
 445                 }
 446
 447         } while (1);
 448
 449         /* If ret is 1 then we just hit the end of the extent array */
 450         if (ret == 1)
 451                 ret = 0;
 452
 453         return ret;
 454 }
 455
 456 /**
 457  * generic_block_fiemap - FIEMAP for block based inodes
 458  * @inode: The inode to map
 459  * @fieinfo: The mapping information
 460  * @start: The initial block to map
 461  * @len: The length of the extect to attempt to map
 462  * @get_block: The block mapping function for the fs
 463  *
 464  * Calls __generic_block_fiemap to map the inode, after taking
 465  * the inode's mutex lock.
 466  */
 467
 468 int generic_block_fiemap(struct inode *inode,
 469                          struct fiemap_extent_info *fieinfo, u64 start,
 470                          u64 len, get_block_t *get_block)
 471 {
 472         int ret;
 473         inode_lock(inode);
 474         ret = __generic_block_fiemap(inode, fieinfo, start, len, get_block);
 475         inode_unlock(inode);
 476         return ret;
 477 }
 478 EXPORT_SYMBOL(generic_block_fiemap);
 479
 480 #endif  /*  CONFIG_BLOCK  */
 481
 482 /*
 483  * This provides compatibility with legacy XFS pre-allocation ioctls
 484  * which predate the fallocate syscall.
 485  *
 486  * Only the l_start, l_len and l_whence fields of the 'struct space_resv'
 487  * are used here, rest are ignored.
 488  */
 489 static int ioctl_preallocate(struct file *filp, int mode, void __user *argp)
 490 {
 491         struct inode *inode = file_inode(filp);
 492         struct space_resv sr;
 493
 494         if (copy_from_user(&sr, argp, sizeof(sr)))
 495                 return -EFAULT;
 496
 497         switch (sr.l_whence) {
 498         case SEEK_SET:
 499                 break;
 500         case SEEK_CUR:
 501                 sr.l_start += filp->f_pos;
 502                 break;
 503         case SEEK_END:
 504                 sr.l_start += i_size_read(inode);
 505                 break;
 506         default:
 507                 return -EINVAL;
 508         }
 509
 510         return vfs_fallocate(filp, mode | FALLOC_FL_KEEP_SIZE, sr.l_start,
 511                         sr.l_len);
 512 }
 513
 514 /* on ia32 l_start is on a 32-bit boundary */
 515 #if defined CONFIG_COMPAT && defined(CONFIG_X86_64)
 516 /* just account for different alignment */
 517 static int compat_ioctl_preallocate(struct file *file, int mode,
 518                                     struct space_resv_32 __user *argp)
 519 {
 520         struct inode *inode = file_inode(file);
 521         struct space_resv_32 sr;
 522
 523         if (copy_from_user(&sr, argp, sizeof(sr)))
 524                 return -EFAULT;
 525
 526         switch (sr.l_whence) {
 527         case SEEK_SET:
 528                 break;
 529         case SEEK_CUR:
 530                 sr.l_start += file->f_pos;
 531                 break;
 532         case SEEK_END:
 533                 sr.l_start += i_size_read(inode);
 534                 break;
 535         default:
 536                 return -EINVAL;
 537         }
 538
 539         return vfs_fallocate(file, mode | FALLOC_FL_KEEP_SIZE, sr.l_start, sr.l_len);
 540 }
 541 #endif
 542
 543 static int file_ioctl(struct file *filp, unsigned int cmd, int __user *p)
 544 {
 545         switch (cmd) {
 546         case FIBMAP:
 547                 return ioctl_fibmap(filp, p);
 548         case FS_IOC_RESVSP:
 549         case FS_IOC_RESVSP64:
 550                 return ioctl_preallocate(filp, 0, p);
 551         case FS_IOC_UNRESVSP:
 552         case FS_IOC_UNRESVSP64:
 553                 return ioctl_preallocate(filp, FALLOC_FL_PUNCH_HOLE, p);
 554         case FS_IOC_ZERO_RANGE:
 555                 return ioctl_preallocate(filp, FALLOC_FL_ZERO_RANGE, p);
 556         }
 557
 558         return -ENOIOCTLCMD;
 559 }
 560
 561 static int ioctl_fionbio(struct file *filp, int __user *argp)
 562 {
 563         unsigned int flag;
 564         int on, error;
 565
 566         error = get_user(on, argp);
 567         if (error)
 568                 return error;
 569         flag = O_NONBLOCK;
 570 #ifdef __sparc__
 571         /* SunOS compatibility item. */
 572         if (O_NONBLOCK != O_NDELAY)
 573                 flag |= O_NDELAY;
 574 #endif
 575         spin_lock(&filp->f_lock);
 576         if (on)
 577                 filp->f_flags |= flag;
 578         else
 579                 filp->f_flags &= ~flag;
 580         spin_unlock(&filp->f_lock);
 581         return error;
 582 }
 583
 584 static int ioctl_fioasync(unsigned int fd, struct file *filp,
 585                           int __user *argp)
 586 {
 587         unsigned int flag;
 588         int on, error;
 589
 590         error = get_user(on, argp);
 591         if (error)
 592                 return error;
 593         flag = on ? FASYNC : 0;
 594
 595         /* Did FASYNC state change ? */
 596         if ((flag ^ filp->f_flags) & FASYNC) {
 597                 if (filp->f_op->fasync)
 598                         /* fasync() adjusts filp->f_flags */
 599                         error = filp->f_op->fasync(fd, filp, on);
 600                 else
 601                         error = -ENOTTY;
 602         }
 603         return error < 0 ? error : 0;
 604 }
 605
 606 static int ioctl_fsfreeze(struct file *filp)
 607 {
 608         struct super_block *sb = file_inode(filp)->i_sb;
 609
 610         if (!ns_capable(sb->s_user_ns, CAP_SYS_ADMIN))
 611                 return -EPERM;
 612
 613         /* If filesystem doesn't support freeze feature, return. */
 614         if (sb->s_op->freeze_fs == NULL && sb->s_op->freeze_super == NULL)
 615                 return -EOPNOTSUPP;
 616
 617         /* Freeze */
 618         if (sb->s_op->freeze_super)
 619                 return sb->s_op->freeze_super(sb);
 620         return freeze_super(sb);
 621 }
 622
 623 static int ioctl_fsthaw(struct file *filp)
 624 {
 625         struct super_block *sb = file_inode(filp)->i_sb;
 626
 627         if (!ns_capable(sb->s_user_ns, CAP_SYS_ADMIN))
 628                 return -EPERM;
 629
 630         /* Thaw */
 631         if (sb->s_op->thaw_super)
 632                 return sb->s_op->thaw_super(sb);
 633         return thaw_super(sb);
 634 }
 635
 636 static int ioctl_file_dedupe_range(struct file *file,
 637                                    struct file_dedupe_range __user *argp)
 638 {
 639         struct file_dedupe_range *same = NULL;
 640         int ret;
 641         unsigned long size;
 642         u16 count;
 643
 644         if (get_user(count, &argp->dest_count)) {
 645                 ret = -EFAULT;
 646                 goto out;
 647         }
 648
 649         size = offsetof(struct file_dedupe_range __user, info[count]);
 650         if (size > PAGE_SIZE) {
 651                 ret = -ENOMEM;
 652                 goto out;
 653         }
 654
 655         same = memdup_user(argp, size);
 656         if (IS_ERR(same)) {
 657                 ret = PTR_ERR(same);
 658                 same = NULL;
 659                 goto out;
 660         }
 661
 662         same->dest_count = count;
 663         ret = vfs_dedupe_file_range(file, same);
 664         if (ret)
 665                 goto out;
 666
 667         ret = copy_to_user(argp, same, size);
 668         if (ret)
 669                 ret = -EFAULT;
 670
 671 out:
 672         kfree(same);
 673         return ret;
 674 }
 675
 676 /*
 677  * do_vfs_ioctl() is not for drivers and not intended to be EXPORT_SYMBOL()'d.
 678  * It's just a simple helper for sys_ioctl and compat_sys_ioctl.
 679  *
 680  * When you add any new common ioctls to the switches above and below,
 681  * please ensure they have compatible arguments in compat mode.
 682  */
 683 static int do_vfs_ioctl(struct file *filp, unsigned int fd,
 684                         unsigned int cmd, unsigned long arg)
 685 {
 686         void __user *argp = (void __user *)arg;
 687         struct inode *inode = file_inode(filp);
 688
 689         switch (cmd) {
 690         case FIOCLEX:
 691                 set_close_on_exec(fd, 1);
 692                 return 0;
 693
 694         case FIONCLEX:
 695                 set_close_on_exec(fd, 0);
 696                 return 0;
 697
 698         case FIONBIO:
 699                 return ioctl_fionbio(filp, argp);
 700
 701         case FIOASYNC:
 702                 return ioctl_fioasync(fd, filp, argp);
 703
 704         case FIOQSIZE:
 705                 if (S_ISDIR(inode->i_mode) || S_ISREG(inode->i_mode) ||
 706                     S_ISLNK(inode->i_mode)) {
 707                         loff_t res = inode_get_bytes(inode);
 708                         return copy_to_user(argp, &res, sizeof(res)) ?
 709                                             -EFAULT : 0;
 710                 }
 711
 712                 return -ENOTTY;
 713
 714         case FIFREEZE:
 715                 return ioctl_fsfreeze(filp);
 716
 717         case FITHAW:
 718                 return ioctl_fsthaw(filp);
 719
 720         case FS_IOC_FIEMAP:
 721                 return ioctl_fiemap(filp, argp);
 722
 723         case FIGETBSZ:
 724                 /* anon_bdev filesystems may not have a block size */
 725                 if (!inode->i_sb->s_blocksize)
 726                         return -EINVAL;
 727
 728                 return put_user(inode->i_sb->s_blocksize, (int __user *)argp);
 729
 730         case FICLONE:
 731                 return ioctl_file_clone(filp, arg, 0, 0, 0);
 732
 733         case FICLONERANGE:
 734                 return ioctl_file_clone_range(filp, argp);
 735
 736         case FIDEDUPERANGE:
 737                 return ioctl_file_dedupe_range(filp, argp);
 738
 739         case FIONREAD:
 740                 if (!S_ISREG(inode->i_mode))
 741                         return vfs_ioctl(filp, cmd, arg);
 742
 743                 return put_user(i_size_read(inode) - filp->f_pos,
 744                                 (int __user *)argp);
 745
 746         default:
 747                 if (S_ISREG(inode->i_mode))
 748                         return file_ioctl(filp, cmd, argp);
 749                 break;
 750         }
 751
 752         return -ENOIOCTLCMD;
 753 }
 754
 755 int ksys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
 756 {
 757         struct fd f = fdget(fd);
 758         int error;
 759
 760         if (!f.file)
 761                 return -EBADF;
 762
 763         error = security_file_ioctl(f.file, cmd, arg);
 764         if (error)
 765                 goto out;
 766
 767         error = do_vfs_ioctl(f.file, fd, cmd, arg);
 768         if (error == -ENOIOCTLCMD)
 769                 error = vfs_ioctl(f.file, cmd, arg);
 770
 771 out:
 772         fdput(f);
 773         return error;
 774 }
 775
 776 SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
 777 {
 778         return ksys_ioctl(fd, cmd, arg);
 779 }
 780
 781 #ifdef CONFIG_COMPAT
 782 /**
 783  * compat_ptr_ioctl - generic implementation of .compat_ioctl file operation
 784  *
 785  * This is not normally called as a function, but instead set in struct
 786  * file_operations as
 787  *
 788  *     .compat_ioctl = compat_ptr_ioctl,
 789  *
 790  * On most architectures, the compat_ptr_ioctl() just passes all arguments
 791  * to the corresponding ->ioctl handler. The exception is arch/s390, where
 792  * compat_ptr() clears the top bit of a 32-bit pointer value, so user space
 793  * pointers to the second 2GB alias the first 2GB, as is the case for
 794  * native 32-bit s390 user space.
 795  *
 796  * The compat_ptr_ioctl() function must therefore be used only with ioctl
 797  * functions that either ignore the argument or pass a pointer to a
 798  * compatible data type.
 799  *
 800  * If any ioctl command handled by fops->unlocked_ioctl passes a plain
 801  * integer instead of a pointer, or any of the passed data types
 802  * is incompatible between 32-bit and 64-bit architectures, a proper
 803  * handler is required instead of compat_ptr_ioctl.
 804  */
 805 long compat_ptr_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 806 {
 807         if (!file->f_op->unlocked_ioctl)
 808                 return -ENOIOCTLCMD;
 809
 810         return file->f_op->unlocked_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
 811 }
 812 EXPORT_SYMBOL(compat_ptr_ioctl);
 813
 814 COMPAT_SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd,
 815                        compat_ulong_t, arg)
 816 {
 817         struct fd f = fdget(fd);
 818         int error;
 819
 820         if (!f.file)
 821                 return -EBADF;
 822
 823         /* RED-PEN how should LSM module know it's handling 32bit? */
 824         error = security_file_ioctl(f.file, cmd, arg);
 825         if (error)
 826                 goto out;
 827
 828         switch (cmd) {
 829         /* FICLONE takes an int argument, so don't use compat_ptr() */
 830         case FICLONE:
 831                 error = ioctl_file_clone(f.file, arg, 0, 0, 0);
 832                 break;
 833
 834 #if defined(CONFIG_X86_64)
 835         /* these get messy on amd64 due to alignment differences */
 836         case FS_IOC_RESVSP_32:
 837         case FS_IOC_RESVSP64_32:
 838                 error = compat_ioctl_preallocate(f.file, 0, compat_ptr(arg));
 839                 break;
 840         case FS_IOC_UNRESVSP_32:
 841         case FS_IOC_UNRESVSP64_32:
 842                 error = compat_ioctl_preallocate(f.file, FALLOC_FL_PUNCH_HOLE,
 843                                 compat_ptr(arg));
 844                 break;
 845         case FS_IOC_ZERO_RANGE_32:
 846                 error = compat_ioctl_preallocate(f.file, FALLOC_FL_ZERO_RANGE,
 847                                 compat_ptr(arg));
 848                 break;
 849 #endif
 850
 851         /*
 852          * everything else in do_vfs_ioctl() takes either a compatible
 853          * pointer argument or no argument -- call it with a modified
 854          * argument.
 855          */
 856         default:
 857                 error = do_vfs_ioctl(f.file, fd, cmd,
 858                                      (unsigned long)compat_ptr(arg));
 859                 if (error != -ENOIOCTLCMD)
 860                         break;
 861
 862                 if (f.file->f_op->compat_ioctl)
 863                         error = f.file->f_op->compat_ioctl(f.file, cmd, arg);
 864                 if (error == -ENOIOCTLCMD)
 865                         error = -ENOTTY;
 866                 break;
 867         }
 868
 869  out:
 870         fdput(f);
 871
 872         return error;
 873 }
 874 #endif