fs/xfs/xfs_ioctl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_log_format.h"
  11 #include "xfs_trans_resv.h"
  12 #include "xfs_mount.h"
  13 #include "xfs_inode.h"
  14 #include "xfs_ioctl.h"
  15 #include "xfs_alloc.h"
  16 #include "xfs_rtalloc.h"
  17 #include "xfs_itable.h"
  18 #include "xfs_error.h"
  19 #include "xfs_attr.h"
  20 #include "xfs_bmap.h"
  21 #include "xfs_bmap_util.h"
  22 #include "xfs_fsops.h"
  23 #include "xfs_discard.h"
  24 #include "xfs_quota.h"
  25 #include "xfs_export.h"
  26 #include "xfs_trace.h"
  27 #include "xfs_icache.h"
  28 #include "xfs_symlink.h"
  29 #include "xfs_trans.h"
  30 #include "xfs_acl.h"
  31 #include "xfs_btree.h"
  32 #include <linux/fsmap.h>
  33 #include "xfs_fsmap.h"
  34 #include "scrub/xfs_scrub.h"
  35 #include "xfs_sb.h"
  36
  37 #include <linux/capability.h>
  38 #include <linux/cred.h>
  39 #include <linux/dcache.h>
  40 #include <linux/mount.h>
  41 #include <linux/namei.h>
  42 #include <linux/pagemap.h>
  43 #include <linux/slab.h>
  44 #include <linux/exportfs.h>
  45
  46 /*
  47  * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
  48  * a file or fs handle.
  49  *
  50  * XFS_IOC_PATH_TO_FSHANDLE
  51  *    returns fs handle for a mount point or path within that mount point
  52  * XFS_IOC_FD_TO_HANDLE
  53  *    returns full handle for a FD opened in user space
  54  * XFS_IOC_PATH_TO_HANDLE
  55  *    returns full handle for a path
  56  */
  57 int
  58 xfs_find_handle(
  59         unsigned int            cmd,
  60         xfs_fsop_handlereq_t    *hreq)
  61 {
  62         int                     hsize;
  63         xfs_handle_t            handle;
  64         struct inode            *inode;
  65         struct fd               f = {NULL};
  66         struct path             path;
  67         int                     error;
  68         struct xfs_inode        *ip;
  69
  70         if (cmd == XFS_IOC_FD_TO_HANDLE) {
  71                 f = fdget(hreq->fd);
  72                 if (!f.file)
  73                         return -EBADF;
  74                 inode = file_inode(f.file);
  75         } else {
  76                 error = user_lpath((const char __user *)hreq->path, &path);
  77                 if (error)
  78                         return error;
  79                 inode = d_inode(path.dentry);
  80         }
  81         ip = XFS_I(inode);
  82
  83         /*
  84          * We can only generate handles for inodes residing on a XFS filesystem,
  85          * and only for regular files, directories or symbolic links.
  86          */
  87         error = -EINVAL;
  88         if (inode->i_sb->s_magic != XFS_SB_MAGIC)
  89                 goto out_put;
  90
  91         error = -EBADF;
  92         if (!S_ISREG(inode->i_mode) &&
  93             !S_ISDIR(inode->i_mode) &&
  94             !S_ISLNK(inode->i_mode))
  95                 goto out_put;
  96
  97
  98         memcpy(&handle.ha_fsid, ip->i_mount->m_fixedfsid, sizeof(xfs_fsid_t));
  99
 100         if (cmd == XFS_IOC_PATH_TO_FSHANDLE) {
 101                 /*
 102                  * This handle only contains an fsid, zero the rest.
 103                  */
 104                 memset(&handle.ha_fid, 0, sizeof(handle.ha_fid));
 105                 hsize = sizeof(xfs_fsid_t);
 106         } else {
 107                 handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
 108                                         sizeof(handle.ha_fid.fid_len);
 109                 handle.ha_fid.fid_pad = 0;
 110                 handle.ha_fid.fid_gen = inode->i_generation;
 111                 handle.ha_fid.fid_ino = ip->i_ino;
 112                 hsize = sizeof(xfs_handle_t);
 113         }
 114
 115         error = -EFAULT;
 116         if (copy_to_user(hreq->ohandle, &handle, hsize) ||
 117             copy_to_user(hreq->ohandlen, &hsize, sizeof(__s32)))
 118                 goto out_put;
 119
 120         error = 0;
 121
 122  out_put:
 123         if (cmd == XFS_IOC_FD_TO_HANDLE)
 124                 fdput(f);
 125         else
 126                 path_put(&path);
 127         return error;
 128 }
 129
 130 /*
 131  * No need to do permission checks on the various pathname components
 132  * as the handle operations are privileged.
 133  */
 134 STATIC int
 135 xfs_handle_acceptable(
 136         void                    *context,
 137         struct dentry           *dentry)
 138 {
 139         return 1;
 140 }
 141
 142 /*
 143  * Convert userspace handle data into a dentry.
 144  */
 145 struct dentry *
 146 xfs_handle_to_dentry(
 147         struct file             *parfilp,
 148         void __user             *uhandle,
 149         u32                     hlen)
 150 {
 151         xfs_handle_t            handle;
 152         struct xfs_fid64        fid;
 153
 154         /*
 155          * Only allow handle opens under a directory.
 156          */
 157         if (!S_ISDIR(file_inode(parfilp)->i_mode))
 158                 return ERR_PTR(-ENOTDIR);
 159
 160         if (hlen != sizeof(xfs_handle_t))
 161                 return ERR_PTR(-EINVAL);
 162         if (copy_from_user(&handle, uhandle, hlen))
 163                 return ERR_PTR(-EFAULT);
 164         if (handle.ha_fid.fid_len !=
 165             sizeof(handle.ha_fid) - sizeof(handle.ha_fid.fid_len))
 166                 return ERR_PTR(-EINVAL);
 167
 168         memset(&fid, 0, sizeof(struct fid));
 169         fid.ino = handle.ha_fid.fid_ino;
 170         fid.gen = handle.ha_fid.fid_gen;
 171
 172         return exportfs_decode_fh(parfilp->f_path.mnt, (struct fid *)&fid, 3,
 173                         FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG,
 174                         xfs_handle_acceptable, NULL);
 175 }
 176
 177 STATIC struct dentry *
 178 xfs_handlereq_to_dentry(
 179         struct file             *parfilp,
 180         xfs_fsop_handlereq_t    *hreq)
 181 {
 182         return xfs_handle_to_dentry(parfilp, hreq->ihandle, hreq->ihandlen);
 183 }
 184
 185 int
 186 xfs_open_by_handle(
 187         struct file             *parfilp,
 188         xfs_fsop_handlereq_t    *hreq)
 189 {
 190         const struct cred       *cred = current_cred();
 191         int                     error;
 192         int                     fd;
 193         int                     permflag;
 194         struct file             *filp;
 195         struct inode            *inode;
 196         struct dentry           *dentry;
 197         fmode_t                 fmode;
 198         struct path             path;
 199
 200         if (!capable(CAP_SYS_ADMIN))
 201                 return -EPERM;
 202
 203         dentry = xfs_handlereq_to_dentry(parfilp, hreq);
 204         if (IS_ERR(dentry))
 205                 return PTR_ERR(dentry);
 206         inode = d_inode(dentry);
 207
 208         /* Restrict xfs_open_by_handle to directories & regular files. */
 209         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
 210                 error = -EPERM;
 211                 goto out_dput;
 212         }
 213
 214 #if BITS_PER_LONG != 32
 215         hreq->oflags |= O_LARGEFILE;
 216 #endif
 217
 218         permflag = hreq->oflags;
 219         fmode = OPEN_FMODE(permflag);
 220         if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
 221             (fmode & FMODE_WRITE) && IS_APPEND(inode)) {
 222                 error = -EPERM;
 223                 goto out_dput;
 224         }
 225
 226         if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
 227                 error = -EPERM;
 228                 goto out_dput;
 229         }
 230
 231         /* Can't write directories. */
 232         if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {
 233                 error = -EISDIR;
 234                 goto out_dput;
 235         }
 236
 237         fd = get_unused_fd_flags(0);
 238         if (fd < 0) {
 239                 error = fd;
 240                 goto out_dput;
 241         }
 242
 243         path.mnt = parfilp->f_path.mnt;
 244         path.dentry = dentry;
 245         filp = dentry_open(&path, hreq->oflags, cred);
 246         dput(dentry);
 247         if (IS_ERR(filp)) {
 248                 put_unused_fd(fd);
 249                 return PTR_ERR(filp);
 250         }
 251
 252         if (S_ISREG(inode->i_mode)) {
 253                 filp->f_flags |= O_NOATIME;
 254                 filp->f_mode |= FMODE_NOCMTIME;
 255         }
 256
 257         fd_install(fd, filp);
 258         return fd;
 259
 260  out_dput:
 261         dput(dentry);
 262         return error;
 263 }
 264
 265 int
 266 xfs_readlink_by_handle(
 267         struct file             *parfilp,
 268         xfs_fsop_handlereq_t    *hreq)
 269 {
 270         struct dentry           *dentry;
 271         __u32                   olen;
 272         int                     error;
 273
 274         if (!capable(CAP_SYS_ADMIN))
 275                 return -EPERM;
 276
 277         dentry = xfs_handlereq_to_dentry(parfilp, hreq);
 278         if (IS_ERR(dentry))
 279                 return PTR_ERR(dentry);
 280
 281         /* Restrict this handle operation to symlinks only. */
 282         if (!d_is_symlink(dentry)) {
 283                 error = -EINVAL;
 284                 goto out_dput;
 285         }
 286
 287         if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {
 288                 error = -EFAULT;
 289                 goto out_dput;
 290         }
 291
 292         error = vfs_readlink(dentry, hreq->ohandle, olen);
 293
 294  out_dput:
 295         dput(dentry);
 296         return error;
 297 }
 298
 299 int
 300 xfs_set_dmattrs(
 301         xfs_inode_t     *ip,
 302         uint            evmask,
 303         uint16_t        state)
 304 {
 305         xfs_mount_t     *mp = ip->i_mount;
 306         xfs_trans_t     *tp;
 307         int             error;
 308
 309         if (!capable(CAP_SYS_ADMIN))
 310                 return -EPERM;
 311
 312         if (XFS_FORCED_SHUTDOWN(mp))
 313                 return -EIO;
 314
 315         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
 316         if (error)
 317                 return error;
 318
 319         xfs_ilock(ip, XFS_ILOCK_EXCL);
 320         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 321
 322         ip->i_d.di_dmevmask = evmask;
 323         ip->i_d.di_dmstate  = state;
 324
 325         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 326         error = xfs_trans_commit(tp);
 327
 328         return error;
 329 }
 330
 331 STATIC int
 332 xfs_fssetdm_by_handle(
 333         struct file             *parfilp,
 334         void                    __user *arg)
 335 {
 336         int                     error;
 337         struct fsdmidata        fsd;
 338         xfs_fsop_setdm_handlereq_t dmhreq;
 339         struct dentry           *dentry;
 340
 341         if (!capable(CAP_MKNOD))
 342                 return -EPERM;
 343         if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
 344                 return -EFAULT;
 345
 346         error = mnt_want_write_file(parfilp);
 347         if (error)
 348                 return error;
 349
 350         dentry = xfs_handlereq_to_dentry(parfilp, &dmhreq.hreq);
 351         if (IS_ERR(dentry)) {
 352                 mnt_drop_write_file(parfilp);
 353                 return PTR_ERR(dentry);
 354         }
 355
 356         if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {
 357                 error = -EPERM;
 358                 goto out;
 359         }
 360
 361         if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
 362                 error = -EFAULT;
 363                 goto out;
 364         }
 365
 366         error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,
 367                                  fsd.fsd_dmstate);
 368
 369  out:
 370         mnt_drop_write_file(parfilp);
 371         dput(dentry);
 372         return error;
 373 }
 374
 375 STATIC int
 376 xfs_attrlist_by_handle(
 377         struct file             *parfilp,
 378         void                    __user *arg)
 379 {
 380         int                     error = -ENOMEM;
 381         attrlist_cursor_kern_t  *cursor;
 382         struct xfs_fsop_attrlist_handlereq __user       *p = arg;
 383         xfs_fsop_attrlist_handlereq_t al_hreq;
 384         struct dentry           *dentry;
 385         char                    *kbuf;
 386
 387         if (!capable(CAP_SYS_ADMIN))
 388                 return -EPERM;
 389         if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
 390                 return -EFAULT;
 391         if (al_hreq.buflen < sizeof(struct attrlist) ||
 392             al_hreq.buflen > XFS_XATTR_LIST_MAX)
 393                 return -EINVAL;
 394
 395         /*
 396          * Reject flags, only allow namespaces.
 397          */
 398         if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
 399                 return -EINVAL;
 400
 401         dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);
 402         if (IS_ERR(dentry))
 403                 return PTR_ERR(dentry);
 404
 405         kbuf = kmem_zalloc_large(al_hreq.buflen, KM_SLEEP);
 406         if (!kbuf)
 407                 goto out_dput;
 408
 409         cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
 410         error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,
 411                                         al_hreq.flags, cursor);
 412         if (error)
 413                 goto out_kfree;
 414
 415         if (copy_to_user(&p->pos, cursor, sizeof(attrlist_cursor_kern_t))) {
 416                 error = -EFAULT;
 417                 goto out_kfree;
 418         }
 419
 420         if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
 421                 error = -EFAULT;
 422
 423 out_kfree:
 424         kmem_free(kbuf);
 425 out_dput:
 426         dput(dentry);
 427         return error;
 428 }
 429
 430 int
 431 xfs_attrmulti_attr_get(
 432         struct inode            *inode,
 433         unsigned char           *name,
 434         unsigned char           __user *ubuf,
 435         uint32_t                *len,
 436         uint32_t                flags)
 437 {
 438         unsigned char           *kbuf;
 439         int                     error = -EFAULT;
 440
 441         if (*len > XFS_XATTR_SIZE_MAX)
 442                 return -EINVAL;
 443         kbuf = kmem_zalloc_large(*len, KM_SLEEP);
 444         if (!kbuf)
 445                 return -ENOMEM;
 446
 447         error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
 448         if (error)
 449                 goto out_kfree;
 450
 451         if (copy_to_user(ubuf, kbuf, *len))
 452                 error = -EFAULT;
 453
 454 out_kfree:
 455         kmem_free(kbuf);
 456         return error;
 457 }
 458
 459 int
 460 xfs_attrmulti_attr_set(
 461         struct inode            *inode,
 462         unsigned char           *name,
 463         const unsigned char     __user *ubuf,
 464         uint32_t                len,
 465         uint32_t                flags)
 466 {
 467         unsigned char           *kbuf;
 468         int                     error;
 469
 470         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 471                 return -EPERM;
 472         if (len > XFS_XATTR_SIZE_MAX)
 473                 return -EINVAL;
 474
 475         kbuf = memdup_user(ubuf, len);
 476         if (IS_ERR(kbuf))
 477                 return PTR_ERR(kbuf);
 478
 479         error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
 480         if (!error)
 481                 xfs_forget_acl(inode, name, flags);
 482         kfree(kbuf);
 483         return error;
 484 }
 485
 486 int
 487 xfs_attrmulti_attr_remove(
 488         struct inode            *inode,
 489         unsigned char           *name,
 490         uint32_t                flags)
 491 {
 492         int                     error;
 493
 494         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 495                 return -EPERM;
 496         error = xfs_attr_remove(XFS_I(inode), name, flags);
 497         if (!error)
 498                 xfs_forget_acl(inode, name, flags);
 499         return error;
 500 }
 501
 502 STATIC int
 503 xfs_attrmulti_by_handle(
 504         struct file             *parfilp,
 505         void                    __user *arg)
 506 {
 507         int                     error;
 508         xfs_attr_multiop_t      *ops;
 509         xfs_fsop_attrmulti_handlereq_t am_hreq;
 510         struct dentry           *dentry;
 511         unsigned int            i, size;
 512         unsigned char           *attr_name;
 513
 514         if (!capable(CAP_SYS_ADMIN))
 515                 return -EPERM;
 516         if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
 517                 return -EFAULT;
 518
 519         /* overflow check */
 520         if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
 521                 return -E2BIG;
 522
 523         dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);
 524         if (IS_ERR(dentry))
 525                 return PTR_ERR(dentry);
 526
 527         error = -E2BIG;
 528         size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
 529         if (!size || size > 16 * PAGE_SIZE)
 530                 goto out_dput;
 531
 532         ops = memdup_user(am_hreq.ops, size);
 533         if (IS_ERR(ops)) {
 534                 error = PTR_ERR(ops);
 535                 goto out_dput;
 536         }
 537
 538         error = -ENOMEM;
 539         attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
 540         if (!attr_name)
 541                 goto out_kfree_ops;
 542
 543         error = 0;
 544         for (i = 0; i < am_hreq.opcount; i++) {
 545                 ops[i].am_error = strncpy_from_user((char *)attr_name,
 546                                 ops[i].am_attrname, MAXNAMELEN);
 547                 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
 548                         error = -ERANGE;
 549                 if (ops[i].am_error < 0)
 550                         break;
 551
 552                 switch (ops[i].am_opcode) {
 553                 case ATTR_OP_GET:
 554                         ops[i].am_error = xfs_attrmulti_attr_get(
 555                                         d_inode(dentry), attr_name,
 556                                         ops[i].am_attrvalue, &ops[i].am_length,
 557                                         ops[i].am_flags);
 558                         break;
 559                 case ATTR_OP_SET:
 560                         ops[i].am_error = mnt_want_write_file(parfilp);
 561                         if (ops[i].am_error)
 562                                 break;
 563                         ops[i].am_error = xfs_attrmulti_attr_set(
 564                                         d_inode(dentry), attr_name,
 565                                         ops[i].am_attrvalue, ops[i].am_length,
 566                                         ops[i].am_flags);
 567                         mnt_drop_write_file(parfilp);
 568                         break;
 569                 case ATTR_OP_REMOVE:
 570                         ops[i].am_error = mnt_want_write_file(parfilp);
 571                         if (ops[i].am_error)
 572                                 break;
 573                         ops[i].am_error = xfs_attrmulti_attr_remove(
 574                                         d_inode(dentry), attr_name,
 575                                         ops[i].am_flags);
 576                         mnt_drop_write_file(parfilp);
 577                         break;
 578                 default:
 579                         ops[i].am_error = -EINVAL;
 580                 }
 581         }
 582
 583         if (copy_to_user(am_hreq.ops, ops, size))
 584                 error = -EFAULT;
 585
 586         kfree(attr_name);
 587  out_kfree_ops:
 588         kfree(ops);
 589  out_dput:
 590         dput(dentry);
 591         return error;
 592 }
 593
 594 int
 595 xfs_ioc_space(
 596         struct file             *filp,
 597         unsigned int            cmd,
 598         xfs_flock64_t           *bf)
 599 {
 600         struct inode            *inode = file_inode(filp);
 601         struct xfs_inode        *ip = XFS_I(inode);
 602         struct iattr            iattr;
 603         enum xfs_prealloc_flags flags = 0;
 604         uint                    iolock = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
 605         int                     error;
 606
 607         /*
 608          * Only allow the sys admin to reserve space unless
 609          * unwritten extents are enabled.
 610          */
 611         if (!xfs_sb_version_hasextflgbit(&ip->i_mount->m_sb) &&
 612             !capable(CAP_SYS_ADMIN))
 613                 return -EPERM;
 614
 615         if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
 616                 return -EPERM;
 617
 618         if (!(filp->f_mode & FMODE_WRITE))
 619                 return -EBADF;
 620
 621         if (!S_ISREG(inode->i_mode))
 622                 return -EINVAL;
 623
 624         if (filp->f_flags & O_DSYNC)
 625                 flags |= XFS_PREALLOC_SYNC;
 626         if (filp->f_mode & FMODE_NOCMTIME)
 627                 flags |= XFS_PREALLOC_INVISIBLE;
 628
 629         error = mnt_want_write_file(filp);
 630         if (error)
 631                 return error;
 632
 633         xfs_ilock(ip, iolock);
 634         error = xfs_break_layouts(inode, &iolock, BREAK_UNMAP);
 635         if (error)
 636                 goto out_unlock;
 637
 638         switch (bf->l_whence) {
 639         case 0: /*SEEK_SET*/
 640                 break;
 641         case 1: /*SEEK_CUR*/
 642                 bf->l_start += filp->f_pos;
 643                 break;
 644         case 2: /*SEEK_END*/
 645                 bf->l_start += XFS_ISIZE(ip);
 646                 break;
 647         default:
 648                 error = -EINVAL;
 649                 goto out_unlock;
 650         }
 651
 652         /*
 653          * length of <= 0 for resv/unresv/zero is invalid.  length for
 654          * alloc/free is ignored completely and we have no idea what userspace
 655          * might have set it to, so set it to zero to allow range
 656          * checks to pass.
 657          */
 658         switch (cmd) {
 659         case XFS_IOC_ZERO_RANGE:
 660         case XFS_IOC_RESVSP:
 661         case XFS_IOC_RESVSP64:
 662         case XFS_IOC_UNRESVSP:
 663         case XFS_IOC_UNRESVSP64:
 664                 if (bf->l_len <= 0) {
 665                         error = -EINVAL;
 666                         goto out_unlock;
 667                 }
 668                 break;
 669         default:
 670                 bf->l_len = 0;
 671                 break;
 672         }
 673
 674         if (bf->l_start < 0 ||
 675             bf->l_start > inode->i_sb->s_maxbytes ||
 676             bf->l_start + bf->l_len < 0 ||
 677             bf->l_start + bf->l_len >= inode->i_sb->s_maxbytes) {
 678                 error = -EINVAL;
 679                 goto out_unlock;
 680         }
 681
 682         switch (cmd) {
 683         case XFS_IOC_ZERO_RANGE:
 684                 flags |= XFS_PREALLOC_SET;
 685                 error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
 686                 break;
 687         case XFS_IOC_RESVSP:
 688         case XFS_IOC_RESVSP64:
 689                 flags |= XFS_PREALLOC_SET;
 690                 error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
 691                                                 XFS_BMAPI_PREALLOC);
 692                 break;
 693         case XFS_IOC_UNRESVSP:
 694         case XFS_IOC_UNRESVSP64:
 695                 error = xfs_free_file_space(ip, bf->l_start, bf->l_len);
 696                 break;
 697         case XFS_IOC_ALLOCSP:
 698         case XFS_IOC_ALLOCSP64:
 699         case XFS_IOC_FREESP:
 700         case XFS_IOC_FREESP64:
 701                 flags |= XFS_PREALLOC_CLEAR;
 702                 if (bf->l_start > XFS_ISIZE(ip)) {
 703                         error = xfs_alloc_file_space(ip, XFS_ISIZE(ip),
 704                                         bf->l_start - XFS_ISIZE(ip),
 705                                         XFS_BMAPI_PREALLOC);
 706                         if (error)
 707                                 goto out_unlock;
 708                 }
 709
 710                 iattr.ia_valid = ATTR_SIZE;
 711                 iattr.ia_size = bf->l_start;
 712
 713                 error = xfs_vn_setattr_size(file_dentry(filp), &iattr);
 714                 break;
 715         default:
 716                 ASSERT(0);
 717                 error = -EINVAL;
 718         }
 719
 720         if (error)
 721                 goto out_unlock;
 722
 723         error = xfs_update_prealloc_flags(ip, flags);
 724
 725 out_unlock:
 726         xfs_iunlock(ip, iolock);
 727         mnt_drop_write_file(filp);
 728         return error;
 729 }
 730
 731 STATIC int
 732 xfs_ioc_bulkstat(
 733         xfs_mount_t             *mp,
 734         unsigned int            cmd,
 735         void                    __user *arg)
 736 {
 737         xfs_fsop_bulkreq_t      bulkreq;
 738         int                     count;  /* # of records returned */
 739         xfs_ino_t               inlast; /* last inode number */
 740         int                     done;
 741         int                     error;
 742
 743         /* done = 1 if there are more stats to get and if bulkstat */
 744         /* should be called again (unused here, but used in dmapi) */
 745
 746         if (!capable(CAP_SYS_ADMIN))
 747                 return -EPERM;
 748
 749         if (XFS_FORCED_SHUTDOWN(mp))
 750                 return -EIO;
 751
 752         if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
 753                 return -EFAULT;
 754
 755         if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
 756                 return -EFAULT;
 757
 758         if ((count = bulkreq.icount) <= 0)
 759                 return -EINVAL;
 760
 761         if (bulkreq.ubuffer == NULL)
 762                 return -EINVAL;
 763
 764         if (cmd == XFS_IOC_FSINUMBERS)
 765                 error = xfs_inumbers(mp, &inlast, &count,
 766                                         bulkreq.ubuffer, xfs_inumbers_fmt);
 767         else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
 768                 error = xfs_bulkstat_one(mp, inlast, bulkreq.ubuffer,
 769                                         sizeof(xfs_bstat_t), NULL, &done);
 770         else    /* XFS_IOC_FSBULKSTAT */
 771                 error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
 772                                      sizeof(xfs_bstat_t), bulkreq.ubuffer,
 773                                      &done);
 774
 775         if (error)
 776                 return error;
 777
 778         if (bulkreq.ocount != NULL) {
 779                 if (copy_to_user(bulkreq.lastip, &inlast,
 780                                                 sizeof(xfs_ino_t)))
 781                         return -EFAULT;
 782
 783                 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
 784                         return -EFAULT;
 785         }
 786
 787         return 0;
 788 }
 789
 790 STATIC int
 791 xfs_ioc_fsgeometry_v1(
 792         xfs_mount_t             *mp,
 793         void                    __user *arg)
 794 {
 795         xfs_fsop_geom_t         fsgeo;
 796         int                     error;
 797
 798         error = xfs_fs_geometry(&mp->m_sb, &fsgeo, 3);
 799         if (error)
 800                 return error;
 801
 802         /*
 803          * Caller should have passed an argument of type
 804          * xfs_fsop_geom_v1_t.  This is a proper subset of the
 805          * xfs_fsop_geom_t that xfs_fs_geometry() fills in.
 806          */
 807         if (copy_to_user(arg, &fsgeo, sizeof(xfs_fsop_geom_v1_t)))
 808                 return -EFAULT;
 809         return 0;
 810 }
 811
 812 STATIC int
 813 xfs_ioc_fsgeometry(
 814         xfs_mount_t             *mp,
 815         void                    __user *arg)
 816 {
 817         xfs_fsop_geom_t         fsgeo;
 818         int                     error;
 819
 820         error = xfs_fs_geometry(&mp->m_sb, &fsgeo, 4);
 821         if (error)
 822                 return error;
 823
 824         if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
 825                 return -EFAULT;
 826         return 0;
 827 }
 828
 829 /*
 830  * Linux extended inode flags interface.
 831  */
 832
 833 STATIC unsigned int
 834 xfs_merge_ioc_xflags(
 835         unsigned int    flags,
 836         unsigned int    start)
 837 {
 838         unsigned int    xflags = start;
 839
 840         if (flags & FS_IMMUTABLE_FL)
 841                 xflags |= FS_XFLAG_IMMUTABLE;
 842         else
 843                 xflags &= ~FS_XFLAG_IMMUTABLE;
 844         if (flags & FS_APPEND_FL)
 845                 xflags |= FS_XFLAG_APPEND;
 846         else
 847                 xflags &= ~FS_XFLAG_APPEND;
 848         if (flags & FS_SYNC_FL)
 849                 xflags |= FS_XFLAG_SYNC;
 850         else
 851                 xflags &= ~FS_XFLAG_SYNC;
 852         if (flags & FS_NOATIME_FL)
 853                 xflags |= FS_XFLAG_NOATIME;
 854         else
 855                 xflags &= ~FS_XFLAG_NOATIME;
 856         if (flags & FS_NODUMP_FL)
 857                 xflags |= FS_XFLAG_NODUMP;
 858         else
 859                 xflags &= ~FS_XFLAG_NODUMP;
 860
 861         return xflags;
 862 }
 863
 864 STATIC unsigned int
 865 xfs_di2lxflags(
 866         uint16_t        di_flags)
 867 {
 868         unsigned int    flags = 0;
 869
 870         if (di_flags & XFS_DIFLAG_IMMUTABLE)
 871                 flags |= FS_IMMUTABLE_FL;
 872         if (di_flags & XFS_DIFLAG_APPEND)
 873                 flags |= FS_APPEND_FL;
 874         if (di_flags & XFS_DIFLAG_SYNC)
 875                 flags |= FS_SYNC_FL;
 876         if (di_flags & XFS_DIFLAG_NOATIME)
 877                 flags |= FS_NOATIME_FL;
 878         if (di_flags & XFS_DIFLAG_NODUMP)
 879                 flags |= FS_NODUMP_FL;
 880         return flags;
 881 }
 882
 883 STATIC int
 884 xfs_ioc_fsgetxattr(
 885         xfs_inode_t             *ip,
 886         int                     attr,
 887         void                    __user *arg)
 888 {
 889         struct fsxattr          fa;
 890
 891         memset(&fa, 0, sizeof(struct fsxattr));
 892
 893         xfs_ilock(ip, XFS_ILOCK_SHARED);
 894         fa.fsx_xflags = xfs_ip2xflags(ip);
 895         fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
 896         fa.fsx_cowextsize = ip->i_d.di_cowextsize <<
 897                         ip->i_mount->m_sb.sb_blocklog;
 898         fa.fsx_projid = xfs_get_projid(ip);
 899
 900         if (attr) {
 901                 if (ip->i_afp) {
 902                         if (ip->i_afp->if_flags & XFS_IFEXTENTS)
 903                                 fa.fsx_nextents = xfs_iext_count(ip->i_afp);
 904                         else
 905                                 fa.fsx_nextents = ip->i_d.di_anextents;
 906                 } else
 907                         fa.fsx_nextents = 0;
 908         } else {
 909                 if (ip->i_df.if_flags & XFS_IFEXTENTS)
 910                         fa.fsx_nextents = xfs_iext_count(&ip->i_df);
 911                 else
 912                         fa.fsx_nextents = ip->i_d.di_nextents;
 913         }
 914         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 915
 916         if (copy_to_user(arg, &fa, sizeof(fa)))
 917                 return -EFAULT;
 918         return 0;
 919 }
 920
 921 STATIC uint16_t
 922 xfs_flags2diflags(
 923         struct xfs_inode        *ip,
 924         unsigned int            xflags)
 925 {
 926         /* can't set PREALLOC this way, just preserve it */
 927         uint16_t                di_flags =
 928                 (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
 929
 930         if (xflags & FS_XFLAG_IMMUTABLE)
 931                 di_flags |= XFS_DIFLAG_IMMUTABLE;
 932         if (xflags & FS_XFLAG_APPEND)
 933                 di_flags |= XFS_DIFLAG_APPEND;
 934         if (xflags & FS_XFLAG_SYNC)
 935                 di_flags |= XFS_DIFLAG_SYNC;
 936         if (xflags & FS_XFLAG_NOATIME)
 937                 di_flags |= XFS_DIFLAG_NOATIME;
 938         if (xflags & FS_XFLAG_NODUMP)
 939                 di_flags |= XFS_DIFLAG_NODUMP;
 940         if (xflags & FS_XFLAG_NODEFRAG)
 941                 di_flags |= XFS_DIFLAG_NODEFRAG;
 942         if (xflags & FS_XFLAG_FILESTREAM)
 943                 di_flags |= XFS_DIFLAG_FILESTREAM;
 944         if (S_ISDIR(VFS_I(ip)->i_mode)) {
 945                 if (xflags & FS_XFLAG_RTINHERIT)
 946                         di_flags |= XFS_DIFLAG_RTINHERIT;
 947                 if (xflags & FS_XFLAG_NOSYMLINKS)
 948                         di_flags |= XFS_DIFLAG_NOSYMLINKS;
 949                 if (xflags & FS_XFLAG_EXTSZINHERIT)
 950                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
 951                 if (xflags & FS_XFLAG_PROJINHERIT)
 952                         di_flags |= XFS_DIFLAG_PROJINHERIT;
 953         } else if (S_ISREG(VFS_I(ip)->i_mode)) {
 954                 if (xflags & FS_XFLAG_REALTIME)
 955                         di_flags |= XFS_DIFLAG_REALTIME;
 956                 if (xflags & FS_XFLAG_EXTSIZE)
 957                         di_flags |= XFS_DIFLAG_EXTSIZE;
 958         }
 959
 960         return di_flags;
 961 }
 962
 963 STATIC uint64_t
 964 xfs_flags2diflags2(
 965         struct xfs_inode        *ip,
 966         unsigned int            xflags)
 967 {
 968         uint64_t                di_flags2 =
 969                 (ip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK);
 970
 971         if (xflags & FS_XFLAG_DAX)
 972                 di_flags2 |= XFS_DIFLAG2_DAX;
 973         if (xflags & FS_XFLAG_COWEXTSIZE)
 974                 di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
 975
 976         return di_flags2;
 977 }
 978
 979 STATIC void
 980 xfs_diflags_to_linux(
 981         struct xfs_inode        *ip)
 982 {
 983         struct inode            *inode = VFS_I(ip);
 984         unsigned int            xflags = xfs_ip2xflags(ip);
 985
 986         if (xflags & FS_XFLAG_IMMUTABLE)
 987                 inode->i_flags |= S_IMMUTABLE;
 988         else
 989                 inode->i_flags &= ~S_IMMUTABLE;
 990         if (xflags & FS_XFLAG_APPEND)
 991                 inode->i_flags |= S_APPEND;
 992         else
 993                 inode->i_flags &= ~S_APPEND;
 994         if (xflags & FS_XFLAG_SYNC)
 995                 inode->i_flags |= S_SYNC;
 996         else
 997                 inode->i_flags &= ~S_SYNC;
 998         if (xflags & FS_XFLAG_NOATIME)
 999                 inode->i_flags |= S_NOATIME;
1000         else
1001                 inode->i_flags &= ~S_NOATIME;
1002 #if 0   /* disabled until the flag switching races are sorted out */
1003         if (xflags & FS_XFLAG_DAX)
1004                 inode->i_flags |= S_DAX;
1005         else
1006                 inode->i_flags &= ~S_DAX;
1007 #endif
1008 }
1009
1010 static int
1011 xfs_ioctl_setattr_xflags(
1012         struct xfs_trans        *tp,
1013         struct xfs_inode        *ip,
1014         struct fsxattr          *fa)
1015 {
1016         struct xfs_mount        *mp = ip->i_mount;
1017         uint64_t                di_flags2;
1018
1019         /* Can't change realtime flag if any extents are allocated. */
1020         if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1021             XFS_IS_REALTIME_INODE(ip) != (fa->fsx_xflags & FS_XFLAG_REALTIME))
1022                 return -EINVAL;
1023
1024         /* If realtime flag is set then must have realtime device */
1025         if (fa->fsx_xflags & FS_XFLAG_REALTIME) {
1026                 if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
1027                     (ip->i_d.di_extsize % mp->m_sb.sb_rextsize))
1028                         return -EINVAL;
1029         }
1030
1031         /* Clear reflink if we are actually able to set the rt flag. */
1032         if ((fa->fsx_xflags & FS_XFLAG_REALTIME) && xfs_is_reflink_inode(ip))
1033                 ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
1034
1035         /* Don't allow us to set DAX mode for a reflinked file for now. */
1036         if ((fa->fsx_xflags & FS_XFLAG_DAX) && xfs_is_reflink_inode(ip))
1037                 return -EINVAL;
1038
1039         /*
1040          * Can't modify an immutable/append-only file unless
1041          * we have appropriate permission.
1042          */
1043         if (((ip->i_d.di_flags & (XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND)) ||
1044              (fa->fsx_xflags & (FS_XFLAG_IMMUTABLE | FS_XFLAG_APPEND))) &&
1045             !capable(CAP_LINUX_IMMUTABLE))
1046                 return -EPERM;
1047
1048         /* diflags2 only valid for v3 inodes. */
1049         di_flags2 = xfs_flags2diflags2(ip, fa->fsx_xflags);
1050         if (di_flags2 && ip->i_d.di_version < 3)
1051                 return -EINVAL;
1052
1053         ip->i_d.di_flags = xfs_flags2diflags(ip, fa->fsx_xflags);
1054         ip->i_d.di_flags2 = di_flags2;
1055
1056         xfs_diflags_to_linux(ip);
1057         xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1058         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1059         XFS_STATS_INC(mp, xs_ig_attrchg);
1060         return 0;
1061 }
1062
1063 /*
1064  * If we are changing DAX flags, we have to ensure the file is clean and any
1065  * cached objects in the address space are invalidated and removed. This
1066  * requires us to lock out other IO and page faults similar to a truncate
1067  * operation. The locks need to be held until the transaction has been committed
1068  * so that the cache invalidation is atomic with respect to the DAX flag
1069  * manipulation.
1070  */
1071 static int
1072 xfs_ioctl_setattr_dax_invalidate(
1073         struct xfs_inode        *ip,
1074         struct fsxattr          *fa,
1075         int                     *join_flags)
1076 {
1077         struct inode            *inode = VFS_I(ip);
1078         struct super_block      *sb = inode->i_sb;
1079         int                     error;
1080
1081         *join_flags = 0;
1082
1083         /*
1084          * It is only valid to set the DAX flag on regular files and
1085          * directories on filesystems where the block size is equal to the page
1086          * size. On directories it serves as an inherited hint so we don't
1087          * have to check the device for dax support or flush pagecache.
1088          */
1089         if (fa->fsx_xflags & FS_XFLAG_DAX) {
1090                 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
1091                         return -EINVAL;
1092                 if (S_ISREG(inode->i_mode) &&
1093                     !bdev_dax_supported(xfs_find_bdev_for_inode(VFS_I(ip)),
1094                                 sb->s_blocksize))
1095                         return -EINVAL;
1096         }
1097
1098         /* If the DAX state is not changing, we have nothing to do here. */
1099         if ((fa->fsx_xflags & FS_XFLAG_DAX) && IS_DAX(inode))
1100                 return 0;
1101         if (!(fa->fsx_xflags & FS_XFLAG_DAX) && !IS_DAX(inode))
1102                 return 0;
1103
1104         if (S_ISDIR(inode->i_mode))
1105                 return 0;
1106
1107         /* lock, flush and invalidate mapping in preparation for flag change */
1108         xfs_ilock(ip, XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL);
1109         error = filemap_write_and_wait(inode->i_mapping);
1110         if (error)
1111                 goto out_unlock;
1112         error = invalidate_inode_pages2(inode->i_mapping);
1113         if (error)
1114                 goto out_unlock;
1115
1116         *join_flags = XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL;
1117         return 0;
1118
1119 out_unlock:
1120         xfs_iunlock(ip, XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL);
1121         return error;
1122
1123 }
1124
1125 /*
1126  * Set up the transaction structure for the setattr operation, checking that we
1127  * have permission to do so. On success, return a clean transaction and the
1128  * inode locked exclusively ready for further operation specific checks. On
1129  * failure, return an error without modifying or locking the inode.
1130  *
1131  * The inode might already be IO locked on call. If this is the case, it is
1132  * indicated in @join_flags and we take full responsibility for ensuring they
1133  * are unlocked from now on. Hence if we have an error here, we still have to
1134  * unlock them. Otherwise, once they are joined to the transaction, they will
1135  * be unlocked on commit/cancel.
1136  */
1137 static struct xfs_trans *
1138 xfs_ioctl_setattr_get_trans(
1139         struct xfs_inode        *ip,
1140         int                     join_flags)
1141 {
1142         struct xfs_mount        *mp = ip->i_mount;
1143         struct xfs_trans        *tp;
1144         int                     error = -EROFS;
1145
1146         if (mp->m_flags & XFS_MOUNT_RDONLY)
1147                 goto out_unlock;
1148         error = -EIO;
1149         if (XFS_FORCED_SHUTDOWN(mp))
1150                 goto out_unlock;
1151
1152         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
1153         if (error)
1154                 return ERR_PTR(error);
1155
1156         xfs_ilock(ip, XFS_ILOCK_EXCL);
1157         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | join_flags);
1158         join_flags = 0;
1159
1160         /*
1161          * CAP_FOWNER overrides the following restrictions:
1162          *
1163          * The user ID of the calling process must be equal to the file owner
1164          * ID, except in cases where the CAP_FSETID capability is applicable.
1165          */
1166         if (!inode_owner_or_capable(VFS_I(ip))) {
1167                 error = -EPERM;
1168                 goto out_cancel;
1169         }
1170
1171         if (mp->m_flags & XFS_MOUNT_WSYNC)
1172                 xfs_trans_set_sync(tp);
1173
1174         return tp;
1175
1176 out_cancel:
1177         xfs_trans_cancel(tp);
1178 out_unlock:
1179         if (join_flags)
1180                 xfs_iunlock(ip, join_flags);
1181         return ERR_PTR(error);
1182 }
1183
1184 /*
1185  * extent size hint validation is somewhat cumbersome. Rules are:
1186  *
1187  * 1. extent size hint is only valid for directories and regular files
1188  * 2. FS_XFLAG_EXTSIZE is only valid for regular files
1189  * 3. FS_XFLAG_EXTSZINHERIT is only valid for directories.
1190  * 4. can only be changed on regular files if no extents are allocated
1191  * 5. can be changed on directories at any time
1192  * 6. extsize hint of 0 turns off hints, clears inode flags.
1193  * 7. Extent size must be a multiple of the appropriate block size.
1194  * 8. for non-realtime files, the extent size hint must be limited
1195  *    to half the AG size to avoid alignment extending the extent beyond the
1196  *    limits of the AG.
1197  *
1198  * Please keep this function in sync with xfs_scrub_inode_extsize.
1199  */
1200 static int
1201 xfs_ioctl_setattr_check_extsize(
1202         struct xfs_inode        *ip,
1203         struct fsxattr          *fa)
1204 {
1205         struct xfs_mount        *mp = ip->i_mount;
1206
1207         if ((fa->fsx_xflags & FS_XFLAG_EXTSIZE) && !S_ISREG(VFS_I(ip)->i_mode))
1208                 return -EINVAL;
1209
1210         if ((fa->fsx_xflags & FS_XFLAG_EXTSZINHERIT) &&
1211             !S_ISDIR(VFS_I(ip)->i_mode))
1212                 return -EINVAL;
1213
1214         if (S_ISREG(VFS_I(ip)->i_mode) && ip->i_d.di_nextents &&
1215             ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) != fa->fsx_extsize))
1216                 return -EINVAL;
1217
1218         if (fa->fsx_extsize != 0) {
1219                 xfs_extlen_t    size;
1220                 xfs_fsblock_t   extsize_fsb;
1221
1222                 extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
1223                 if (extsize_fsb > MAXEXTLEN)
1224                         return -EINVAL;
1225
1226                 if (XFS_IS_REALTIME_INODE(ip) ||
1227                     (fa->fsx_xflags & FS_XFLAG_REALTIME)) {
1228                         size = mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog;
1229                 } else {
1230                         size = mp->m_sb.sb_blocksize;
1231                         if (extsize_fsb > mp->m_sb.sb_agblocks / 2)
1232                                 return -EINVAL;
1233                 }
1234
1235                 if (fa->fsx_extsize % size)
1236                         return -EINVAL;
1237         } else
1238                 fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE | FS_XFLAG_EXTSZINHERIT);
1239
1240         return 0;
1241 }
1242
1243 /*
1244  * CoW extent size hint validation rules are:
1245  *
1246  * 1. CoW extent size hint can only be set if reflink is enabled on the fs.
1247  *    The inode does not have to have any shared blocks, but it must be a v3.
1248  * 2. FS_XFLAG_COWEXTSIZE is only valid for directories and regular files;
1249  *    for a directory, the hint is propagated to new files.
1250  * 3. Can be changed on files & directories at any time.
1251  * 4. CoW extsize hint of 0 turns off hints, clears inode flags.
1252  * 5. Extent size must be a multiple of the appropriate block size.
1253  * 6. The extent size hint must be limited to half the AG size to avoid
1254  *    alignment extending the extent beyond the limits of the AG.
1255  *
1256  * Please keep this function in sync with xfs_scrub_inode_cowextsize.
1257  */
1258 static int
1259 xfs_ioctl_setattr_check_cowextsize(
1260         struct xfs_inode        *ip,
1261         struct fsxattr          *fa)
1262 {
1263         struct xfs_mount        *mp = ip->i_mount;
1264
1265         if (!(fa->fsx_xflags & FS_XFLAG_COWEXTSIZE))
1266                 return 0;
1267
1268         if (!xfs_sb_version_hasreflink(&ip->i_mount->m_sb) ||
1269             ip->i_d.di_version != 3)
1270                 return -EINVAL;
1271
1272         if (!S_ISREG(VFS_I(ip)->i_mode) && !S_ISDIR(VFS_I(ip)->i_mode))
1273                 return -EINVAL;
1274
1275         if (fa->fsx_cowextsize != 0) {
1276                 xfs_extlen_t    size;
1277                 xfs_fsblock_t   cowextsize_fsb;
1278
1279                 cowextsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_cowextsize);
1280                 if (cowextsize_fsb > MAXEXTLEN)
1281                         return -EINVAL;
1282
1283                 size = mp->m_sb.sb_blocksize;
1284                 if (cowextsize_fsb > mp->m_sb.sb_agblocks / 2)
1285                         return -EINVAL;
1286
1287                 if (fa->fsx_cowextsize % size)
1288                         return -EINVAL;
1289         } else
1290                 fa->fsx_xflags &= ~FS_XFLAG_COWEXTSIZE;
1291
1292         return 0;
1293 }
1294
1295 static int
1296 xfs_ioctl_setattr_check_projid(
1297         struct xfs_inode        *ip,
1298         struct fsxattr          *fa)
1299 {
1300         /* Disallow 32bit project ids if projid32bit feature is not enabled. */
1301         if (fa->fsx_projid > (uint16_t)-1 &&
1302             !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
1303                 return -EINVAL;
1304
1305         /*
1306          * Project Quota ID state is only allowed to change from within the init
1307          * namespace. Enforce that restriction only if we are trying to change
1308          * the quota ID state. Everything else is allowed in user namespaces.
1309          */
1310         if (current_user_ns() == &init_user_ns)
1311                 return 0;
1312
1313         if (xfs_get_projid(ip) != fa->fsx_projid)
1314                 return -EINVAL;
1315         if ((fa->fsx_xflags & FS_XFLAG_PROJINHERIT) !=
1316             (ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT))
1317                 return -EINVAL;
1318
1319         return 0;
1320 }
1321
1322 STATIC int
1323 xfs_ioctl_setattr(
1324         xfs_inode_t             *ip,
1325         struct fsxattr          *fa)
1326 {
1327         struct xfs_mount        *mp = ip->i_mount;
1328         struct xfs_trans        *tp;
1329         struct xfs_dquot        *udqp = NULL;
1330         struct xfs_dquot        *pdqp = NULL;
1331         struct xfs_dquot        *olddquot = NULL;
1332         int                     code;
1333         int                     join_flags = 0;
1334
1335         trace_xfs_ioctl_setattr(ip);
1336
1337         code = xfs_ioctl_setattr_check_projid(ip, fa);
1338         if (code)
1339                 return code;
1340
1341         /*
1342          * If disk quotas is on, we make sure that the dquots do exist on disk,
1343          * before we start any other transactions. Trying to do this later
1344          * is messy. We don't care to take a readlock to look at the ids
1345          * in inode here, because we can't hold it across the trans_reserve.
1346          * If the IDs do change before we take the ilock, we're covered
1347          * because the i_*dquot fields will get updated anyway.
1348          */
1349         if (XFS_IS_QUOTA_ON(mp)) {
1350                 code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,
1351                                          ip->i_d.di_gid, fa->fsx_projid,
1352                                          XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);
1353                 if (code)
1354                         return code;
1355         }
1356
1357         /*
1358          * Changing DAX config may require inode locking for mapping
1359          * invalidation. These need to be held all the way to transaction commit
1360          * or cancel time, so need to be passed through to
1361          * xfs_ioctl_setattr_get_trans() so it can apply them to the join call
1362          * appropriately.
1363          */
1364         code = xfs_ioctl_setattr_dax_invalidate(ip, fa, &join_flags);
1365         if (code)
1366                 goto error_free_dquots;
1367
1368         tp = xfs_ioctl_setattr_get_trans(ip, join_flags);
1369         if (IS_ERR(tp)) {
1370                 code = PTR_ERR(tp);
1371                 goto error_free_dquots;
1372         }
1373
1374
1375         if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp) &&
1376             xfs_get_projid(ip) != fa->fsx_projid) {
1377                 code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL, pdqp,
1378                                 capable(CAP_FOWNER) ?  XFS_QMOPT_FORCE_RES : 0);
1379                 if (code)       /* out of quota */
1380                         goto error_trans_cancel;
1381         }
1382
1383         code = xfs_ioctl_setattr_check_extsize(ip, fa);
1384         if (code)
1385                 goto error_trans_cancel;
1386
1387         code = xfs_ioctl_setattr_check_cowextsize(ip, fa);
1388         if (code)
1389                 goto error_trans_cancel;
1390
1391         code = xfs_ioctl_setattr_xflags(tp, ip, fa);
1392         if (code)
1393                 goto error_trans_cancel;
1394
1395         /*
1396          * Change file ownership.  Must be the owner or privileged.  CAP_FSETID
1397          * overrides the following restrictions:
1398          *
1399          * The set-user-ID and set-group-ID bits of a file will be cleared upon
1400          * successful return from chown()
1401          */
1402
1403         if ((VFS_I(ip)->i_mode & (S_ISUID|S_ISGID)) &&
1404             !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID))
1405                 VFS_I(ip)->i_mode &= ~(S_ISUID|S_ISGID);
1406
1407         /* Change the ownerships and register project quota modifications */
1408         if (xfs_get_projid(ip) != fa->fsx_projid) {
1409                 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {
1410                         olddquot = xfs_qm_vop_chown(tp, ip,
1411                                                 &ip->i_pdquot, pdqp);
1412                 }
1413                 ASSERT(ip->i_d.di_version > 1);
1414                 xfs_set_projid(ip, fa->fsx_projid);
1415         }
1416
1417         /*
1418          * Only set the extent size hint if we've already determined that the
1419          * extent size hint should be set on the inode. If no extent size flags
1420          * are set on the inode then unconditionally clear the extent size hint.
1421          */
1422         if (ip->i_d.di_flags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
1423                 ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1424         else
1425                 ip->i_d.di_extsize = 0;
1426         if (ip->i_d.di_version == 3 &&
1427             (ip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE))
1428                 ip->i_d.di_cowextsize = fa->fsx_cowextsize >>
1429                                 mp->m_sb.sb_blocklog;
1430         else
1431                 ip->i_d.di_cowextsize = 0;
1432
1433         code = xfs_trans_commit(tp);
1434
1435         /*
1436          * Release any dquot(s) the inode had kept before chown.
1437          */
1438         xfs_qm_dqrele(olddquot);
1439         xfs_qm_dqrele(udqp);
1440         xfs_qm_dqrele(pdqp);
1441
1442         return code;
1443
1444 error_trans_cancel:
1445         xfs_trans_cancel(tp);
1446 error_free_dquots:
1447         xfs_qm_dqrele(udqp);
1448         xfs_qm_dqrele(pdqp);
1449         return code;
1450 }
1451
1452 STATIC int
1453 xfs_ioc_fssetxattr(
1454         xfs_inode_t             *ip,
1455         struct file             *filp,
1456         void                    __user *arg)
1457 {
1458         struct fsxattr          fa;
1459         int error;
1460
1461         if (copy_from_user(&fa, arg, sizeof(fa)))
1462                 return -EFAULT;
1463
1464         error = mnt_want_write_file(filp);
1465         if (error)
1466                 return error;
1467         error = xfs_ioctl_setattr(ip, &fa);
1468         mnt_drop_write_file(filp);
1469         return error;
1470 }
1471
1472 STATIC int
1473 xfs_ioc_getxflags(
1474         xfs_inode_t             *ip,
1475         void                    __user *arg)
1476 {
1477         unsigned int            flags;
1478
1479         flags = xfs_di2lxflags(ip->i_d.di_flags);
1480         if (copy_to_user(arg, &flags, sizeof(flags)))
1481                 return -EFAULT;
1482         return 0;
1483 }
1484
1485 STATIC int
1486 xfs_ioc_setxflags(
1487         struct xfs_inode        *ip,
1488         struct file             *filp,
1489         void                    __user *arg)
1490 {
1491         struct xfs_trans        *tp;
1492         struct fsxattr          fa;
1493         unsigned int            flags;
1494         int                     join_flags = 0;
1495         int                     error;
1496
1497         if (copy_from_user(&flags, arg, sizeof(flags)))
1498                 return -EFAULT;
1499
1500         if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1501                       FS_NOATIME_FL | FS_NODUMP_FL | \
1502                       FS_SYNC_FL))
1503                 return -EOPNOTSUPP;
1504
1505         fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
1506
1507         error = mnt_want_write_file(filp);
1508         if (error)
1509                 return error;
1510
1511         /*
1512          * Changing DAX config may require inode locking for mapping
1513          * invalidation. These need to be held all the way to transaction commit
1514          * or cancel time, so need to be passed through to
1515          * xfs_ioctl_setattr_get_trans() so it can apply them to the join call
1516          * appropriately.
1517          */
1518         error = xfs_ioctl_setattr_dax_invalidate(ip, &fa, &join_flags);
1519         if (error)
1520                 goto out_drop_write;
1521
1522         tp = xfs_ioctl_setattr_get_trans(ip, join_flags);
1523         if (IS_ERR(tp)) {
1524                 error = PTR_ERR(tp);
1525                 goto out_drop_write;
1526         }
1527
1528         error = xfs_ioctl_setattr_xflags(tp, ip, &fa);
1529         if (error) {
1530                 xfs_trans_cancel(tp);
1531                 goto out_drop_write;
1532         }
1533
1534         error = xfs_trans_commit(tp);
1535 out_drop_write:
1536         mnt_drop_write_file(filp);
1537         return error;
1538 }
1539
1540 static bool
1541 xfs_getbmap_format(
1542         struct kgetbmap         *p,
1543         struct getbmapx __user  *u,
1544         size_t                  recsize)
1545 {
1546         if (put_user(p->bmv_offset, &u->bmv_offset) ||
1547             put_user(p->bmv_block, &u->bmv_block) ||
1548             put_user(p->bmv_length, &u->bmv_length) ||
1549             put_user(0, &u->bmv_count) ||
1550             put_user(0, &u->bmv_entries))
1551                 return false;
1552         if (recsize < sizeof(struct getbmapx))
1553                 return true;
1554         if (put_user(0, &u->bmv_iflags) ||
1555             put_user(p->bmv_oflags, &u->bmv_oflags) ||
1556             put_user(0, &u->bmv_unused1) ||
1557             put_user(0, &u->bmv_unused2))
1558                 return false;
1559         return true;
1560 }
1561
1562 STATIC int
1563 xfs_ioc_getbmap(
1564         struct file             *file,
1565         unsigned int            cmd,
1566         void                    __user *arg)
1567 {
1568         struct getbmapx         bmx = { 0 };
1569         struct kgetbmap         *buf;
1570         size_t                  recsize;
1571         int                     error, i;
1572
1573         switch (cmd) {
1574         case XFS_IOC_GETBMAPA:
1575                 bmx.bmv_iflags = BMV_IF_ATTRFORK;
1576                 /*FALLTHRU*/
1577         case XFS_IOC_GETBMAP:
1578                 if (file->f_mode & FMODE_NOCMTIME)
1579                         bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
1580                 /* struct getbmap is a strict subset of struct getbmapx. */
1581                 recsize = sizeof(struct getbmap);
1582                 break;
1583         case XFS_IOC_GETBMAPX:
1584                 recsize = sizeof(struct getbmapx);
1585                 break;
1586         default:
1587                 return -EINVAL;
1588         }
1589
1590         if (copy_from_user(&bmx, arg, recsize))
1591                 return -EFAULT;
1592
1593         if (bmx.bmv_count < 2)
1594                 return -EINVAL;
1595         if (bmx.bmv_count > ULONG_MAX / recsize)
1596                 return -ENOMEM;
1597
1598         buf = kmem_zalloc_large(bmx.bmv_count * sizeof(*buf), 0);
1599         if (!buf)
1600                 return -ENOMEM;
1601
1602         error = xfs_getbmap(XFS_I(file_inode(file)), &bmx, buf);
1603         if (error)
1604                 goto out_free_buf;
1605
1606         error = -EFAULT;
1607         if (copy_to_user(arg, &bmx, recsize))
1608                 goto out_free_buf;
1609         arg += recsize;
1610
1611         for (i = 0; i < bmx.bmv_entries; i++) {
1612                 if (!xfs_getbmap_format(buf + i, arg, recsize))
1613                         goto out_free_buf;
1614                 arg += recsize;
1615         }
1616
1617         error = 0;
1618 out_free_buf:
1619         kmem_free(buf);
1620         return error;
1621 }
1622
1623 struct getfsmap_info {
1624         struct xfs_mount        *mp;
1625         struct fsmap_head __user *data;
1626         unsigned int            idx;
1627         __u32                   last_flags;
1628 };
1629
1630 STATIC int
1631 xfs_getfsmap_format(struct xfs_fsmap *xfm, void *priv)
1632 {
1633         struct getfsmap_info    *info = priv;
1634         struct fsmap            fm;
1635
1636         trace_xfs_getfsmap_mapping(info->mp, xfm);
1637
1638         info->last_flags = xfm->fmr_flags;
1639         xfs_fsmap_from_internal(&fm, xfm);
1640         if (copy_to_user(&info->data->fmh_recs[info->idx++], &fm,
1641                         sizeof(struct fsmap)))
1642                 return -EFAULT;
1643
1644         return 0;
1645 }
1646
1647 STATIC int
1648 xfs_ioc_getfsmap(
1649         struct xfs_inode        *ip,
1650         struct fsmap_head       __user *arg)
1651 {
1652         struct getfsmap_info    info = { NULL };
1653         struct xfs_fsmap_head   xhead = {0};
1654         struct fsmap_head       head;
1655         bool                    aborted = false;
1656         int                     error;
1657
1658         if (copy_from_user(&head, arg, sizeof(struct fsmap_head)))
1659                 return -EFAULT;
1660         if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) ||
1661             memchr_inv(head.fmh_keys[0].fmr_reserved, 0,
1662                        sizeof(head.fmh_keys[0].fmr_reserved)) ||
1663             memchr_inv(head.fmh_keys[1].fmr_reserved, 0,
1664                        sizeof(head.fmh_keys[1].fmr_reserved)))
1665                 return -EINVAL;
1666
1667         xhead.fmh_iflags = head.fmh_iflags;
1668         xhead.fmh_count = head.fmh_count;
1669         xfs_fsmap_to_internal(&xhead.fmh_keys[0], &head.fmh_keys[0]);
1670         xfs_fsmap_to_internal(&xhead.fmh_keys[1], &head.fmh_keys[1]);
1671
1672         trace_xfs_getfsmap_low_key(ip->i_mount, &xhead.fmh_keys[0]);
1673         trace_xfs_getfsmap_high_key(ip->i_mount, &xhead.fmh_keys[1]);
1674
1675         info.mp = ip->i_mount;
1676         info.data = arg;
1677         error = xfs_getfsmap(ip->i_mount, &xhead, xfs_getfsmap_format, &info);
1678         if (error == XFS_BTREE_QUERY_RANGE_ABORT) {
1679                 error = 0;
1680                 aborted = true;
1681         } else if (error)
1682                 return error;
1683
1684         /* If we didn't abort, set the "last" flag in the last fmx */
1685         if (!aborted && info.idx) {
1686                 info.last_flags |= FMR_OF_LAST;
1687                 if (copy_to_user(&info.data->fmh_recs[info.idx - 1].fmr_flags,
1688                                 &info.last_flags, sizeof(info.last_flags)))
1689                         return -EFAULT;
1690         }
1691
1692         /* copy back header */
1693         head.fmh_entries = xhead.fmh_entries;
1694         head.fmh_oflags = xhead.fmh_oflags;
1695         if (copy_to_user(arg, &head, sizeof(struct fsmap_head)))
1696                 return -EFAULT;
1697
1698         return 0;
1699 }
1700
1701 STATIC int
1702 xfs_ioc_scrub_metadata(
1703         struct xfs_inode                *ip,
1704         void                            __user *arg)
1705 {
1706         struct xfs_scrub_metadata       scrub;
1707         int                             error;
1708
1709         if (!capable(CAP_SYS_ADMIN))
1710                 return -EPERM;
1711
1712         if (copy_from_user(&scrub, arg, sizeof(scrub)))
1713                 return -EFAULT;
1714
1715         error = xfs_scrub_metadata(ip, &scrub);
1716         if (error)
1717                 return error;
1718
1719         if (copy_to_user(arg, &scrub, sizeof(scrub)))
1720                 return -EFAULT;
1721
1722         return 0;
1723 }
1724
1725 int
1726 xfs_ioc_swapext(
1727         xfs_swapext_t   *sxp)
1728 {
1729         xfs_inode_t     *ip, *tip;
1730         struct fd       f, tmp;
1731         int             error = 0;
1732
1733         /* Pull information for the target fd */
1734         f = fdget((int)sxp->sx_fdtarget);
1735         if (!f.file) {
1736                 error = -EINVAL;
1737                 goto out;
1738         }
1739
1740         if (!(f.file->f_mode & FMODE_WRITE) ||
1741             !(f.file->f_mode & FMODE_READ) ||
1742             (f.file->f_flags & O_APPEND)) {
1743                 error = -EBADF;
1744                 goto out_put_file;
1745         }
1746
1747         tmp = fdget((int)sxp->sx_fdtmp);
1748         if (!tmp.file) {
1749                 error = -EINVAL;
1750                 goto out_put_file;
1751         }
1752
1753         if (!(tmp.file->f_mode & FMODE_WRITE) ||
1754             !(tmp.file->f_mode & FMODE_READ) ||
1755             (tmp.file->f_flags & O_APPEND)) {
1756                 error = -EBADF;
1757                 goto out_put_tmp_file;
1758         }
1759
1760         if (IS_SWAPFILE(file_inode(f.file)) ||
1761             IS_SWAPFILE(file_inode(tmp.file))) {
1762                 error = -EINVAL;
1763                 goto out_put_tmp_file;
1764         }
1765
1766         /*
1767          * We need to ensure that the fds passed in point to XFS inodes
1768          * before we cast and access them as XFS structures as we have no
1769          * control over what the user passes us here.
1770          */
1771         if (f.file->f_op != &xfs_file_operations ||
1772             tmp.file->f_op != &xfs_file_operations) {
1773                 error = -EINVAL;
1774                 goto out_put_tmp_file;
1775         }
1776
1777         ip = XFS_I(file_inode(f.file));
1778         tip = XFS_I(file_inode(tmp.file));
1779
1780         if (ip->i_mount != tip->i_mount) {
1781                 error = -EINVAL;
1782                 goto out_put_tmp_file;
1783         }
1784
1785         if (ip->i_ino == tip->i_ino) {
1786                 error = -EINVAL;
1787                 goto out_put_tmp_file;
1788         }
1789
1790         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1791                 error = -EIO;
1792                 goto out_put_tmp_file;
1793         }
1794
1795         error = xfs_swap_extents(ip, tip, sxp);
1796
1797  out_put_tmp_file:
1798         fdput(tmp);
1799  out_put_file:
1800         fdput(f);
1801  out:
1802         return error;
1803 }
1804
1805 static int
1806 xfs_ioc_getlabel(
1807         struct xfs_mount        *mp,
1808         char                    __user *user_label)
1809 {
1810         struct xfs_sb           *sbp = &mp->m_sb;
1811         char                    label[XFSLABEL_MAX + 1];
1812
1813         /* Paranoia */
1814         BUILD_BUG_ON(sizeof(sbp->sb_fname) > FSLABEL_MAX);
1815
1816         /* 1 larger than sb_fname, so this ensures a trailing NUL char */
1817         memset(label, 0, sizeof(label));
1818         spin_lock(&mp->m_sb_lock);
1819         strncpy(label, sbp->sb_fname, XFSLABEL_MAX);
1820         spin_unlock(&mp->m_sb_lock);
1821
1822         if (copy_to_user(user_label, label, sizeof(label)))
1823                 return -EFAULT;
1824         return 0;
1825 }
1826
1827 static int
1828 xfs_ioc_setlabel(
1829         struct file             *filp,
1830         struct xfs_mount        *mp,
1831         char                    __user *newlabel)
1832 {
1833         struct xfs_sb           *sbp = &mp->m_sb;
1834         char                    label[XFSLABEL_MAX + 1];
1835         size_t                  len;
1836         int                     error;
1837
1838         if (!capable(CAP_SYS_ADMIN))
1839                 return -EPERM;
1840         /*
1841          * The generic ioctl allows up to FSLABEL_MAX chars, but XFS is much
1842          * smaller, at 12 bytes.  We copy one more to be sure we find the
1843          * (required) NULL character to test the incoming label length.
1844          * NB: The on disk label doesn't need to be null terminated.
1845          */
1846         if (copy_from_user(label, newlabel, XFSLABEL_MAX + 1))
1847                 return -EFAULT;
1848         len = strnlen(label, XFSLABEL_MAX + 1);
1849         if (len > sizeof(sbp->sb_fname))
1850                 return -EINVAL;
1851
1852         error = mnt_want_write_file(filp);
1853         if (error)
1854                 return error;
1855
1856         spin_lock(&mp->m_sb_lock);
1857         memset(sbp->sb_fname, 0, sizeof(sbp->sb_fname));
1858         memcpy(sbp->sb_fname, label, len);
1859         spin_unlock(&mp->m_sb_lock);
1860
1861         /*
1862          * Now we do several things to satisfy userspace.
1863          * In addition to normal logging of the primary superblock, we also
1864          * immediately write these changes to sector zero for the primary, then
1865          * update all backup supers (as xfs_db does for a label change), then
1866          * invalidate the block device page cache.  This is so that any prior
1867          * buffered reads from userspace (i.e. from blkid) are invalidated,
1868          * and userspace will see the newly-written label.
1869          */
1870         error = xfs_sync_sb_buf(mp);
1871         if (error)
1872                 goto out;
1873         /*
1874          * growfs also updates backup supers so lock against that.
1875          */
1876         mutex_lock(&mp->m_growlock);
1877         error = xfs_update_secondary_sbs(mp);
1878         mutex_unlock(&mp->m_growlock);
1879
1880         invalidate_bdev(mp->m_ddev_targp->bt_bdev);
1881
1882 out:
1883         mnt_drop_write_file(filp);
1884         return error;
1885 }
1886
1887 /*
1888  * Note: some of the ioctl's return positive numbers as a
1889  * byte count indicating success, such as readlink_by_handle.
1890  * So we don't "sign flip" like most other routines.  This means
1891  * true errors need to be returned as a negative value.
1892  */
1893 long
1894 xfs_file_ioctl(
1895         struct file             *filp,
1896         unsigned int            cmd,
1897         unsigned long           p)
1898 {
1899         struct inode            *inode = file_inode(filp);
1900         struct xfs_inode        *ip = XFS_I(inode);
1901         struct xfs_mount        *mp = ip->i_mount;
1902         void                    __user *arg = (void __user *)p;
1903         int                     error;
1904
1905         trace_xfs_file_ioctl(ip);
1906
1907         switch (cmd) {
1908         case FITRIM:
1909                 return xfs_ioc_trim(mp, arg);
1910         case FS_IOC_GETFSLABEL:
1911                 return xfs_ioc_getlabel(mp, arg);
1912         case FS_IOC_SETFSLABEL:
1913                 return xfs_ioc_setlabel(filp, mp, arg);
1914         case XFS_IOC_ALLOCSP:
1915         case XFS_IOC_FREESP:
1916         case XFS_IOC_RESVSP:
1917         case XFS_IOC_UNRESVSP:
1918         case XFS_IOC_ALLOCSP64:
1919         case XFS_IOC_FREESP64:
1920         case XFS_IOC_RESVSP64:
1921         case XFS_IOC_UNRESVSP64:
1922         case XFS_IOC_ZERO_RANGE: {
1923                 xfs_flock64_t           bf;
1924
1925                 if (copy_from_user(&bf, arg, sizeof(bf)))
1926                         return -EFAULT;
1927                 return xfs_ioc_space(filp, cmd, &bf);
1928         }
1929         case XFS_IOC_DIOINFO: {
1930                 struct dioattr  da;
1931                 xfs_buftarg_t   *target =
1932                         XFS_IS_REALTIME_INODE(ip) ?
1933                         mp->m_rtdev_targp : mp->m_ddev_targp;
1934
1935                 da.d_mem =  da.d_miniosz = target->bt_logical_sectorsize;
1936                 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1937
1938                 if (copy_to_user(arg, &da, sizeof(da)))
1939                         return -EFAULT;
1940                 return 0;
1941         }
1942
1943         case XFS_IOC_FSBULKSTAT_SINGLE:
1944         case XFS_IOC_FSBULKSTAT:
1945         case XFS_IOC_FSINUMBERS:
1946                 return xfs_ioc_bulkstat(mp, cmd, arg);
1947
1948         case XFS_IOC_FSGEOMETRY_V1:
1949                 return xfs_ioc_fsgeometry_v1(mp, arg);
1950
1951         case XFS_IOC_FSGEOMETRY:
1952                 return xfs_ioc_fsgeometry(mp, arg);
1953
1954         case XFS_IOC_GETVERSION:
1955                 return put_user(inode->i_generation, (int __user *)arg);
1956
1957         case XFS_IOC_FSGETXATTR:
1958                 return xfs_ioc_fsgetxattr(ip, 0, arg);
1959         case XFS_IOC_FSGETXATTRA:
1960                 return xfs_ioc_fsgetxattr(ip, 1, arg);
1961         case XFS_IOC_FSSETXATTR:
1962                 return xfs_ioc_fssetxattr(ip, filp, arg);
1963         case XFS_IOC_GETXFLAGS:
1964                 return xfs_ioc_getxflags(ip, arg);
1965         case XFS_IOC_SETXFLAGS:
1966                 return xfs_ioc_setxflags(ip, filp, arg);
1967
1968         case XFS_IOC_FSSETDM: {
1969                 struct fsdmidata        dmi;
1970
1971                 if (copy_from_user(&dmi, arg, sizeof(dmi)))
1972                         return -EFAULT;
1973
1974                 error = mnt_want_write_file(filp);
1975                 if (error)
1976                         return error;
1977
1978                 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1979                                 dmi.fsd_dmstate);
1980                 mnt_drop_write_file(filp);
1981                 return error;
1982         }
1983
1984         case XFS_IOC_GETBMAP:
1985         case XFS_IOC_GETBMAPA:
1986         case XFS_IOC_GETBMAPX:
1987                 return xfs_ioc_getbmap(filp, cmd, arg);
1988
1989         case FS_IOC_GETFSMAP:
1990                 return xfs_ioc_getfsmap(ip, arg);
1991
1992         case XFS_IOC_SCRUB_METADATA:
1993                 return xfs_ioc_scrub_metadata(ip, arg);
1994
1995         case XFS_IOC_FD_TO_HANDLE:
1996         case XFS_IOC_PATH_TO_HANDLE:
1997         case XFS_IOC_PATH_TO_FSHANDLE: {
1998                 xfs_fsop_handlereq_t    hreq;
1999
2000                 if (copy_from_user(&hreq, arg, sizeof(hreq)))
2001                         return -EFAULT;
2002                 return xfs_find_handle(cmd, &hreq);
2003         }
2004         case XFS_IOC_OPEN_BY_HANDLE: {
2005                 xfs_fsop_handlereq_t    hreq;
2006
2007                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
2008                         return -EFAULT;
2009                 return xfs_open_by_handle(filp, &hreq);
2010         }
2011         case XFS_IOC_FSSETDM_BY_HANDLE:
2012                 return xfs_fssetdm_by_handle(filp, arg);
2013
2014         case XFS_IOC_READLINK_BY_HANDLE: {
2015                 xfs_fsop_handlereq_t    hreq;
2016
2017                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
2018                         return -EFAULT;
2019                 return xfs_readlink_by_handle(filp, &hreq);
2020         }
2021         case XFS_IOC_ATTRLIST_BY_HANDLE:
2022                 return xfs_attrlist_by_handle(filp, arg);
2023
2024         case XFS_IOC_ATTRMULTI_BY_HANDLE:
2025                 return xfs_attrmulti_by_handle(filp, arg);
2026
2027         case XFS_IOC_SWAPEXT: {
2028                 struct xfs_swapext      sxp;
2029
2030                 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
2031                         return -EFAULT;
2032                 error = mnt_want_write_file(filp);
2033                 if (error)
2034                         return error;
2035                 error = xfs_ioc_swapext(&sxp);
2036                 mnt_drop_write_file(filp);
2037                 return error;
2038         }
2039
2040         case XFS_IOC_FSCOUNTS: {
2041                 xfs_fsop_counts_t out;
2042
2043                 error = xfs_fs_counts(mp, &out);
2044                 if (error)
2045                         return error;
2046
2047                 if (copy_to_user(arg, &out, sizeof(out)))
2048                         return -EFAULT;
2049                 return 0;
2050         }
2051
2052         case XFS_IOC_SET_RESBLKS: {
2053                 xfs_fsop_resblks_t inout;
2054                 uint64_t           in;
2055
2056                 if (!capable(CAP_SYS_ADMIN))
2057                         return -EPERM;
2058
2059                 if (mp->m_flags & XFS_MOUNT_RDONLY)
2060                         return -EROFS;
2061
2062                 if (copy_from_user(&inout, arg, sizeof(inout)))
2063                         return -EFAULT;
2064
2065                 error = mnt_want_write_file(filp);
2066                 if (error)
2067                         return error;
2068
2069                 /* input parameter is passed in resblks field of structure */
2070                 in = inout.resblks;
2071                 error = xfs_reserve_blocks(mp, &in, &inout);
2072                 mnt_drop_write_file(filp);
2073                 if (error)
2074                         return error;
2075
2076                 if (copy_to_user(arg, &inout, sizeof(inout)))
2077                         return -EFAULT;
2078                 return 0;
2079         }
2080
2081         case XFS_IOC_GET_RESBLKS: {
2082                 xfs_fsop_resblks_t out;
2083
2084                 if (!capable(CAP_SYS_ADMIN))
2085                         return -EPERM;
2086
2087                 error = xfs_reserve_blocks(mp, NULL, &out);
2088                 if (error)
2089                         return error;
2090
2091                 if (copy_to_user(arg, &out, sizeof(out)))
2092                         return -EFAULT;
2093
2094                 return 0;
2095         }
2096
2097         case XFS_IOC_FSGROWFSDATA: {
2098                 xfs_growfs_data_t in;
2099
2100                 if (copy_from_user(&in, arg, sizeof(in)))
2101                         return -EFAULT;
2102
2103                 error = mnt_want_write_file(filp);
2104                 if (error)
2105                         return error;
2106                 error = xfs_growfs_data(mp, &in);
2107                 mnt_drop_write_file(filp);
2108                 return error;
2109         }
2110
2111         case XFS_IOC_FSGROWFSLOG: {
2112                 xfs_growfs_log_t in;
2113
2114                 if (copy_from_user(&in, arg, sizeof(in)))
2115                         return -EFAULT;
2116
2117                 error = mnt_want_write_file(filp);
2118                 if (error)
2119                         return error;
2120                 error = xfs_growfs_log(mp, &in);
2121                 mnt_drop_write_file(filp);
2122                 return error;
2123         }
2124
2125         case XFS_IOC_FSGROWFSRT: {
2126                 xfs_growfs_rt_t in;
2127
2128                 if (copy_from_user(&in, arg, sizeof(in)))
2129                         return -EFAULT;
2130
2131                 error = mnt_want_write_file(filp);
2132                 if (error)
2133                         return error;
2134                 error = xfs_growfs_rt(mp, &in);
2135                 mnt_drop_write_file(filp);
2136                 return error;
2137         }
2138
2139         case XFS_IOC_GOINGDOWN: {
2140                 uint32_t in;
2141
2142                 if (!capable(CAP_SYS_ADMIN))
2143                         return -EPERM;
2144
2145                 if (get_user(in, (uint32_t __user *)arg))
2146                         return -EFAULT;
2147
2148                 return xfs_fs_goingdown(mp, in);
2149         }
2150
2151         case XFS_IOC_ERROR_INJECTION: {
2152                 xfs_error_injection_t in;
2153
2154                 if (!capable(CAP_SYS_ADMIN))
2155                         return -EPERM;
2156
2157                 if (copy_from_user(&in, arg, sizeof(in)))
2158                         return -EFAULT;
2159
2160                 return xfs_errortag_add(mp, in.errtag);
2161         }
2162
2163         case XFS_IOC_ERROR_CLEARALL:
2164                 if (!capable(CAP_SYS_ADMIN))
2165                         return -EPERM;
2166
2167                 return xfs_errortag_clearall(mp);
2168
2169         case XFS_IOC_FREE_EOFBLOCKS: {
2170                 struct xfs_fs_eofblocks eofb;
2171                 struct xfs_eofblocks keofb;
2172
2173                 if (!capable(CAP_SYS_ADMIN))
2174                         return -EPERM;
2175
2176                 if (mp->m_flags & XFS_MOUNT_RDONLY)
2177                         return -EROFS;
2178
2179                 if (copy_from_user(&eofb, arg, sizeof(eofb)))
2180                         return -EFAULT;
2181
2182                 error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
2183                 if (error)
2184                         return error;
2185
2186                 sb_start_write(mp->m_super);
2187                 error = xfs_icache_free_eofblocks(mp, &keofb);
2188                 sb_end_write(mp->m_super);
2189                 return error;
2190         }
2191
2192         default:
2193                 return -ENOTTY;
2194         }
2195 }