fs/xfs/xfs_ioctl.c

   1 /*
   2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18 #include "xfs.h"
  19 #include "xfs_fs.h"
  20 #include "xfs_shared.h"
  21 #include "xfs_format.h"
  22 #include "xfs_log_format.h"
  23 #include "xfs_trans_resv.h"
  24 #include "xfs_mount.h"
  25 #include "xfs_inode.h"
  26 #include "xfs_ioctl.h"
  27 #include "xfs_alloc.h"
  28 #include "xfs_rtalloc.h"
  29 #include "xfs_itable.h"
  30 #include "xfs_error.h"
  31 #include "xfs_attr.h"
  32 #include "xfs_bmap.h"
  33 #include "xfs_bmap_util.h"
  34 #include "xfs_fsops.h"
  35 #include "xfs_discard.h"
  36 #include "xfs_quota.h"
  37 #include "xfs_export.h"
  38 #include "xfs_trace.h"
  39 #include "xfs_icache.h"
  40 #include "xfs_symlink.h"
  41 #include "xfs_trans.h"
  42 #include "xfs_pnfs.h"
  43
  44 #include <linux/capability.h>
  45 #include <linux/dcache.h>
  46 #include <linux/mount.h>
  47 #include <linux/namei.h>
  48 #include <linux/pagemap.h>
  49 #include <linux/slab.h>
  50 #include <linux/exportfs.h>
  51
  52 /*
  53  * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
  54  * a file or fs handle.
  55  *
  56  * XFS_IOC_PATH_TO_FSHANDLE
  57  *    returns fs handle for a mount point or path within that mount point
  58  * XFS_IOC_FD_TO_HANDLE
  59  *    returns full handle for a FD opened in user space
  60  * XFS_IOC_PATH_TO_HANDLE
  61  *    returns full handle for a path
  62  */
  63 int
  64 xfs_find_handle(
  65         unsigned int            cmd,
  66         xfs_fsop_handlereq_t    *hreq)
  67 {
  68         int                     hsize;
  69         xfs_handle_t            handle;
  70         struct inode            *inode;
  71         struct fd               f = {NULL};
  72         struct path             path;
  73         int                     error;
  74         struct xfs_inode        *ip;
  75
  76         if (cmd == XFS_IOC_FD_TO_HANDLE) {
  77                 f = fdget(hreq->fd);
  78                 if (!f.file)
  79                         return -EBADF;
  80                 inode = file_inode(f.file);
  81         } else {
  82                 error = user_lpath((const char __user *)hreq->path, &path);
  83                 if (error)
  84                         return error;
  85                 inode = d_inode(path.dentry);
  86         }
  87         ip = XFS_I(inode);
  88
  89         /*
  90          * We can only generate handles for inodes residing on a XFS filesystem,
  91          * and only for regular files, directories or symbolic links.
  92          */
  93         error = -EINVAL;
  94         if (inode->i_sb->s_magic != XFS_SB_MAGIC)
  95                 goto out_put;
  96
  97         error = -EBADF;
  98         if (!S_ISREG(inode->i_mode) &&
  99             !S_ISDIR(inode->i_mode) &&
 100             !S_ISLNK(inode->i_mode))
 101                 goto out_put;
 102
 103
 104         memcpy(&handle.ha_fsid, ip->i_mount->m_fixedfsid, sizeof(xfs_fsid_t));
 105
 106         if (cmd == XFS_IOC_PATH_TO_FSHANDLE) {
 107                 /*
 108                  * This handle only contains an fsid, zero the rest.
 109                  */
 110                 memset(&handle.ha_fid, 0, sizeof(handle.ha_fid));
 111                 hsize = sizeof(xfs_fsid_t);
 112         } else {
 113                 handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
 114                                         sizeof(handle.ha_fid.fid_len);
 115                 handle.ha_fid.fid_pad = 0;
 116                 handle.ha_fid.fid_gen = ip->i_d.di_gen;
 117                 handle.ha_fid.fid_ino = ip->i_ino;
 118
 119                 hsize = XFS_HSIZE(handle);
 120         }
 121
 122         error = -EFAULT;
 123         if (copy_to_user(hreq->ohandle, &handle, hsize) ||
 124             copy_to_user(hreq->ohandlen, &hsize, sizeof(__s32)))
 125                 goto out_put;
 126
 127         error = 0;
 128
 129  out_put:
 130         if (cmd == XFS_IOC_FD_TO_HANDLE)
 131                 fdput(f);
 132         else
 133                 path_put(&path);
 134         return error;
 135 }
 136
 137 /*
 138  * No need to do permission checks on the various pathname components
 139  * as the handle operations are privileged.
 140  */
 141 STATIC int
 142 xfs_handle_acceptable(
 143         void                    *context,
 144         struct dentry           *dentry)
 145 {
 146         return 1;
 147 }
 148
 149 /*
 150  * Convert userspace handle data into a dentry.
 151  */
 152 struct dentry *
 153 xfs_handle_to_dentry(
 154         struct file             *parfilp,
 155         void __user             *uhandle,
 156         u32                     hlen)
 157 {
 158         xfs_handle_t            handle;
 159         struct xfs_fid64        fid;
 160
 161         /*
 162          * Only allow handle opens under a directory.
 163          */
 164         if (!S_ISDIR(file_inode(parfilp)->i_mode))
 165                 return ERR_PTR(-ENOTDIR);
 166
 167         if (hlen != sizeof(xfs_handle_t))
 168                 return ERR_PTR(-EINVAL);
 169         if (copy_from_user(&handle, uhandle, hlen))
 170                 return ERR_PTR(-EFAULT);
 171         if (handle.ha_fid.fid_len !=
 172             sizeof(handle.ha_fid) - sizeof(handle.ha_fid.fid_len))
 173                 return ERR_PTR(-EINVAL);
 174
 175         memset(&fid, 0, sizeof(struct fid));
 176         fid.ino = handle.ha_fid.fid_ino;
 177         fid.gen = handle.ha_fid.fid_gen;
 178
 179         return exportfs_decode_fh(parfilp->f_path.mnt, (struct fid *)&fid, 3,
 180                         FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG,
 181                         xfs_handle_acceptable, NULL);
 182 }
 183
 184 STATIC struct dentry *
 185 xfs_handlereq_to_dentry(
 186         struct file             *parfilp,
 187         xfs_fsop_handlereq_t    *hreq)
 188 {
 189         return xfs_handle_to_dentry(parfilp, hreq->ihandle, hreq->ihandlen);
 190 }
 191
 192 int
 193 xfs_open_by_handle(
 194         struct file             *parfilp,
 195         xfs_fsop_handlereq_t    *hreq)
 196 {
 197         const struct cred       *cred = current_cred();
 198         int                     error;
 199         int                     fd;
 200         int                     permflag;
 201         struct file             *filp;
 202         struct inode            *inode;
 203         struct dentry           *dentry;
 204         fmode_t                 fmode;
 205         struct path             path;
 206
 207         if (!capable(CAP_SYS_ADMIN))
 208                 return -EPERM;
 209
 210         dentry = xfs_handlereq_to_dentry(parfilp, hreq);
 211         if (IS_ERR(dentry))
 212                 return PTR_ERR(dentry);
 213         inode = d_inode(dentry);
 214
 215         /* Restrict xfs_open_by_handle to directories & regular files. */
 216         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
 217                 error = -EPERM;
 218                 goto out_dput;
 219         }
 220
 221 #if BITS_PER_LONG != 32
 222         hreq->oflags |= O_LARGEFILE;
 223 #endif
 224
 225         permflag = hreq->oflags;
 226         fmode = OPEN_FMODE(permflag);
 227         if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
 228             (fmode & FMODE_WRITE) && IS_APPEND(inode)) {
 229                 error = -EPERM;
 230                 goto out_dput;
 231         }
 232
 233         if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
 234                 error = -EACCES;
 235                 goto out_dput;
 236         }
 237
 238         /* Can't write directories. */
 239         if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {
 240                 error = -EISDIR;
 241                 goto out_dput;
 242         }
 243
 244         fd = get_unused_fd_flags(0);
 245         if (fd < 0) {
 246                 error = fd;
 247                 goto out_dput;
 248         }
 249
 250         path.mnt = parfilp->f_path.mnt;
 251         path.dentry = dentry;
 252         filp = dentry_open(&path, hreq->oflags, cred);
 253         dput(dentry);
 254         if (IS_ERR(filp)) {
 255                 put_unused_fd(fd);
 256                 return PTR_ERR(filp);
 257         }
 258
 259         if (S_ISREG(inode->i_mode)) {
 260                 filp->f_flags |= O_NOATIME;
 261                 filp->f_mode |= FMODE_NOCMTIME;
 262         }
 263
 264         fd_install(fd, filp);
 265         return fd;
 266
 267  out_dput:
 268         dput(dentry);
 269         return error;
 270 }
 271
 272 int
 273 xfs_readlink_by_handle(
 274         struct file             *parfilp,
 275         xfs_fsop_handlereq_t    *hreq)
 276 {
 277         struct dentry           *dentry;
 278         __u32                   olen;
 279         void                    *link;
 280         int                     error;
 281
 282         if (!capable(CAP_SYS_ADMIN))
 283                 return -EPERM;
 284
 285         dentry = xfs_handlereq_to_dentry(parfilp, hreq);
 286         if (IS_ERR(dentry))
 287                 return PTR_ERR(dentry);
 288
 289         /* Restrict this handle operation to symlinks only. */
 290         if (!d_is_symlink(dentry)) {
 291                 error = -EINVAL;
 292                 goto out_dput;
 293         }
 294
 295         if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {
 296                 error = -EFAULT;
 297                 goto out_dput;
 298         }
 299
 300         link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
 301         if (!link) {
 302                 error = -ENOMEM;
 303                 goto out_dput;
 304         }
 305
 306         error = xfs_readlink(XFS_I(d_inode(dentry)), link);
 307         if (error)
 308                 goto out_kfree;
 309         error = readlink_copy(hreq->ohandle, olen, link);
 310         if (error)
 311                 goto out_kfree;
 312
 313  out_kfree:
 314         kfree(link);
 315  out_dput:
 316         dput(dentry);
 317         return error;
 318 }
 319
 320 int
 321 xfs_set_dmattrs(
 322         xfs_inode_t     *ip,
 323         u_int           evmask,
 324         u_int16_t       state)
 325 {
 326         xfs_mount_t     *mp = ip->i_mount;
 327         xfs_trans_t     *tp;
 328         int             error;
 329
 330         if (!capable(CAP_SYS_ADMIN))
 331                 return -EPERM;
 332
 333         if (XFS_FORCED_SHUTDOWN(mp))
 334                 return -EIO;
 335
 336         tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
 337         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
 338         if (error) {
 339                 xfs_trans_cancel(tp);
 340                 return error;
 341         }
 342         xfs_ilock(ip, XFS_ILOCK_EXCL);
 343         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 344
 345         ip->i_d.di_dmevmask = evmask;
 346         ip->i_d.di_dmstate  = state;
 347
 348         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 349         error = xfs_trans_commit(tp);
 350
 351         return error;
 352 }
 353
 354 STATIC int
 355 xfs_fssetdm_by_handle(
 356         struct file             *parfilp,
 357         void                    __user *arg)
 358 {
 359         int                     error;
 360         struct fsdmidata        fsd;
 361         xfs_fsop_setdm_handlereq_t dmhreq;
 362         struct dentry           *dentry;
 363
 364         if (!capable(CAP_MKNOD))
 365                 return -EPERM;
 366         if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
 367                 return -EFAULT;
 368
 369         error = mnt_want_write_file(parfilp);
 370         if (error)
 371                 return error;
 372
 373         dentry = xfs_handlereq_to_dentry(parfilp, &dmhreq.hreq);
 374         if (IS_ERR(dentry)) {
 375                 mnt_drop_write_file(parfilp);
 376                 return PTR_ERR(dentry);
 377         }
 378
 379         if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {
 380                 error = -EPERM;
 381                 goto out;
 382         }
 383
 384         if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
 385                 error = -EFAULT;
 386                 goto out;
 387         }
 388
 389         error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,
 390                                  fsd.fsd_dmstate);
 391
 392  out:
 393         mnt_drop_write_file(parfilp);
 394         dput(dentry);
 395         return error;
 396 }
 397
 398 STATIC int
 399 xfs_attrlist_by_handle(
 400         struct file             *parfilp,
 401         void                    __user *arg)
 402 {
 403         int                     error = -ENOMEM;
 404         attrlist_cursor_kern_t  *cursor;
 405         xfs_fsop_attrlist_handlereq_t al_hreq;
 406         struct dentry           *dentry;
 407         char                    *kbuf;
 408
 409         if (!capable(CAP_SYS_ADMIN))
 410                 return -EPERM;
 411         if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
 412                 return -EFAULT;
 413         if (al_hreq.buflen < sizeof(struct attrlist) ||
 414             al_hreq.buflen > XATTR_LIST_MAX)
 415                 return -EINVAL;
 416
 417         /*
 418          * Reject flags, only allow namespaces.
 419          */
 420         if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
 421                 return -EINVAL;
 422
 423         dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);
 424         if (IS_ERR(dentry))
 425                 return PTR_ERR(dentry);
 426
 427         kbuf = kmem_zalloc_large(al_hreq.buflen, KM_SLEEP);
 428         if (!kbuf)
 429                 goto out_dput;
 430
 431         cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
 432         error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,
 433                                         al_hreq.flags, cursor);
 434         if (error)
 435                 goto out_kfree;
 436
 437         if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
 438                 error = -EFAULT;
 439
 440 out_kfree:
 441         kmem_free(kbuf);
 442 out_dput:
 443         dput(dentry);
 444         return error;
 445 }
 446
 447 int
 448 xfs_attrmulti_attr_get(
 449         struct inode            *inode,
 450         unsigned char           *name,
 451         unsigned char           __user *ubuf,
 452         __uint32_t              *len,
 453         __uint32_t              flags)
 454 {
 455         unsigned char           *kbuf;
 456         int                     error = -EFAULT;
 457
 458         if (*len > XATTR_SIZE_MAX)
 459                 return -EINVAL;
 460         kbuf = kmem_zalloc_large(*len, KM_SLEEP);
 461         if (!kbuf)
 462                 return -ENOMEM;
 463
 464         error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
 465         if (error)
 466                 goto out_kfree;
 467
 468         if (copy_to_user(ubuf, kbuf, *len))
 469                 error = -EFAULT;
 470
 471 out_kfree:
 472         kmem_free(kbuf);
 473         return error;
 474 }
 475
 476 int
 477 xfs_attrmulti_attr_set(
 478         struct inode            *inode,
 479         unsigned char           *name,
 480         const unsigned char     __user *ubuf,
 481         __uint32_t              len,
 482         __uint32_t              flags)
 483 {
 484         unsigned char           *kbuf;
 485         int                     error;
 486
 487         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 488                 return -EPERM;
 489         if (len > XATTR_SIZE_MAX)
 490                 return -EINVAL;
 491
 492         kbuf = memdup_user(ubuf, len);
 493         if (IS_ERR(kbuf))
 494                 return PTR_ERR(kbuf);
 495
 496         error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
 497         kfree(kbuf);
 498         return error;
 499 }
 500
 501 int
 502 xfs_attrmulti_attr_remove(
 503         struct inode            *inode,
 504         unsigned char           *name,
 505         __uint32_t              flags)
 506 {
 507         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 508                 return -EPERM;
 509         return xfs_attr_remove(XFS_I(inode), name, flags);
 510 }
 511
 512 STATIC int
 513 xfs_attrmulti_by_handle(
 514         struct file             *parfilp,
 515         void                    __user *arg)
 516 {
 517         int                     error;
 518         xfs_attr_multiop_t      *ops;
 519         xfs_fsop_attrmulti_handlereq_t am_hreq;
 520         struct dentry           *dentry;
 521         unsigned int            i, size;
 522         unsigned char           *attr_name;
 523
 524         if (!capable(CAP_SYS_ADMIN))
 525                 return -EPERM;
 526         if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
 527                 return -EFAULT;
 528
 529         /* overflow check */
 530         if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
 531                 return -E2BIG;
 532
 533         dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);
 534         if (IS_ERR(dentry))
 535                 return PTR_ERR(dentry);
 536
 537         error = -E2BIG;
 538         size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
 539         if (!size || size > 16 * PAGE_SIZE)
 540                 goto out_dput;
 541
 542         ops = memdup_user(am_hreq.ops, size);
 543         if (IS_ERR(ops)) {
 544                 error = PTR_ERR(ops);
 545                 goto out_dput;
 546         }
 547
 548         error = -ENOMEM;
 549         attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
 550         if (!attr_name)
 551                 goto out_kfree_ops;
 552
 553         error = 0;
 554         for (i = 0; i < am_hreq.opcount; i++) {
 555                 ops[i].am_error = strncpy_from_user((char *)attr_name,
 556                                 ops[i].am_attrname, MAXNAMELEN);
 557                 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
 558                         error = -ERANGE;
 559                 if (ops[i].am_error < 0)
 560                         break;
 561
 562                 switch (ops[i].am_opcode) {
 563                 case ATTR_OP_GET:
 564                         ops[i].am_error = xfs_attrmulti_attr_get(
 565                                         d_inode(dentry), attr_name,
 566                                         ops[i].am_attrvalue, &ops[i].am_length,
 567                                         ops[i].am_flags);
 568                         break;
 569                 case ATTR_OP_SET:
 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_set(
 574                                         d_inode(dentry), attr_name,
 575                                         ops[i].am_attrvalue, ops[i].am_length,
 576                                         ops[i].am_flags);
 577                         mnt_drop_write_file(parfilp);
 578                         break;
 579                 case ATTR_OP_REMOVE:
 580                         ops[i].am_error = mnt_want_write_file(parfilp);
 581                         if (ops[i].am_error)
 582                                 break;
 583                         ops[i].am_error = xfs_attrmulti_attr_remove(
 584                                         d_inode(dentry), attr_name,
 585                                         ops[i].am_flags);
 586                         mnt_drop_write_file(parfilp);
 587                         break;
 588                 default:
 589                         ops[i].am_error = -EINVAL;
 590                 }
 591         }
 592
 593         if (copy_to_user(am_hreq.ops, ops, size))
 594                 error = -EFAULT;
 595
 596         kfree(attr_name);
 597  out_kfree_ops:
 598         kfree(ops);
 599  out_dput:
 600         dput(dentry);
 601         return error;
 602 }
 603
 604 int
 605 xfs_ioc_space(
 606         struct xfs_inode        *ip,
 607         struct inode            *inode,
 608         struct file             *filp,
 609         int                     ioflags,
 610         unsigned int            cmd,
 611         xfs_flock64_t           *bf)
 612 {
 613         struct iattr            iattr;
 614         enum xfs_prealloc_flags flags = 0;
 615         uint                    iolock = XFS_IOLOCK_EXCL;
 616         int                     error;
 617
 618         /*
 619          * Only allow the sys admin to reserve space unless
 620          * unwritten extents are enabled.
 621          */
 622         if (!xfs_sb_version_hasextflgbit(&ip->i_mount->m_sb) &&
 623             !capable(CAP_SYS_ADMIN))
 624                 return -EPERM;
 625
 626         if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
 627                 return -EPERM;
 628
 629         if (!(filp->f_mode & FMODE_WRITE))
 630                 return -EBADF;
 631
 632         if (!S_ISREG(inode->i_mode))
 633                 return -EINVAL;
 634
 635         if (filp->f_flags & O_DSYNC)
 636                 flags |= XFS_PREALLOC_SYNC;
 637         if (ioflags & XFS_IO_INVIS)
 638                 flags |= XFS_PREALLOC_INVISIBLE;
 639
 640         error = mnt_want_write_file(filp);
 641         if (error)
 642                 return error;
 643
 644         xfs_ilock(ip, iolock);
 645         error = xfs_break_layouts(inode, &iolock, false);
 646         if (error)
 647                 goto out_unlock;
 648
 649         xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
 650         iolock |= XFS_MMAPLOCK_EXCL;
 651
 652         switch (bf->l_whence) {
 653         case 0: /*SEEK_SET*/
 654                 break;
 655         case 1: /*SEEK_CUR*/
 656                 bf->l_start += filp->f_pos;
 657                 break;
 658         case 2: /*SEEK_END*/
 659                 bf->l_start += XFS_ISIZE(ip);
 660                 break;
 661         default:
 662                 error = -EINVAL;
 663                 goto out_unlock;
 664         }
 665
 666         /*
 667          * length of <= 0 for resv/unresv/zero is invalid.  length for
 668          * alloc/free is ignored completely and we have no idea what userspace
 669          * might have set it to, so set it to zero to allow range
 670          * checks to pass.
 671          */
 672         switch (cmd) {
 673         case XFS_IOC_ZERO_RANGE:
 674         case XFS_IOC_RESVSP:
 675         case XFS_IOC_RESVSP64:
 676         case XFS_IOC_UNRESVSP:
 677         case XFS_IOC_UNRESVSP64:
 678                 if (bf->l_len <= 0) {
 679                         error = -EINVAL;
 680                         goto out_unlock;
 681                 }
 682                 break;
 683         default:
 684                 bf->l_len = 0;
 685                 break;
 686         }
 687
 688         if (bf->l_start < 0 ||
 689             bf->l_start > inode->i_sb->s_maxbytes ||
 690             bf->l_start + bf->l_len < 0 ||
 691             bf->l_start + bf->l_len >= inode->i_sb->s_maxbytes) {
 692                 error = -EINVAL;
 693                 goto out_unlock;
 694         }
 695
 696         switch (cmd) {
 697         case XFS_IOC_ZERO_RANGE:
 698                 flags |= XFS_PREALLOC_SET;
 699                 error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
 700                 break;
 701         case XFS_IOC_RESVSP:
 702         case XFS_IOC_RESVSP64:
 703                 flags |= XFS_PREALLOC_SET;
 704                 error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
 705                                                 XFS_BMAPI_PREALLOC);
 706                 break;
 707         case XFS_IOC_UNRESVSP:
 708         case XFS_IOC_UNRESVSP64:
 709                 error = xfs_free_file_space(ip, bf->l_start, bf->l_len);
 710                 break;
 711         case XFS_IOC_ALLOCSP:
 712         case XFS_IOC_ALLOCSP64:
 713         case XFS_IOC_FREESP:
 714         case XFS_IOC_FREESP64:
 715                 flags |= XFS_PREALLOC_CLEAR;
 716                 if (bf->l_start > XFS_ISIZE(ip)) {
 717                         error = xfs_alloc_file_space(ip, XFS_ISIZE(ip),
 718                                         bf->l_start - XFS_ISIZE(ip), 0);
 719                         if (error)
 720                                 goto out_unlock;
 721                 }
 722
 723                 iattr.ia_valid = ATTR_SIZE;
 724                 iattr.ia_size = bf->l_start;
 725
 726                 error = xfs_setattr_size(ip, &iattr);
 727                 break;
 728         default:
 729                 ASSERT(0);
 730                 error = -EINVAL;
 731         }
 732
 733         if (error)
 734                 goto out_unlock;
 735
 736         error = xfs_update_prealloc_flags(ip, flags);
 737
 738 out_unlock:
 739         xfs_iunlock(ip, iolock);
 740         mnt_drop_write_file(filp);
 741         return error;
 742 }
 743
 744 STATIC int
 745 xfs_ioc_bulkstat(
 746         xfs_mount_t             *mp,
 747         unsigned int            cmd,
 748         void                    __user *arg)
 749 {
 750         xfs_fsop_bulkreq_t      bulkreq;
 751         int                     count;  /* # of records returned */
 752         xfs_ino_t               inlast; /* last inode number */
 753         int                     done;
 754         int                     error;
 755
 756         /* done = 1 if there are more stats to get and if bulkstat */
 757         /* should be called again (unused here, but used in dmapi) */
 758
 759         if (!capable(CAP_SYS_ADMIN))
 760                 return -EPERM;
 761
 762         if (XFS_FORCED_SHUTDOWN(mp))
 763                 return -EIO;
 764
 765         if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
 766                 return -EFAULT;
 767
 768         if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
 769                 return -EFAULT;
 770
 771         if ((count = bulkreq.icount) <= 0)
 772                 return -EINVAL;
 773
 774         if (bulkreq.ubuffer == NULL)
 775                 return -EINVAL;
 776
 777         if (cmd == XFS_IOC_FSINUMBERS)
 778                 error = xfs_inumbers(mp, &inlast, &count,
 779                                         bulkreq.ubuffer, xfs_inumbers_fmt);
 780         else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
 781                 error = xfs_bulkstat_one(mp, inlast, bulkreq.ubuffer,
 782                                         sizeof(xfs_bstat_t), NULL, &done);
 783         else    /* XFS_IOC_FSBULKSTAT */
 784                 error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
 785                                      sizeof(xfs_bstat_t), bulkreq.ubuffer,
 786                                      &done);
 787
 788         if (error)
 789                 return error;
 790
 791         if (bulkreq.ocount != NULL) {
 792                 if (copy_to_user(bulkreq.lastip, &inlast,
 793                                                 sizeof(xfs_ino_t)))
 794                         return -EFAULT;
 795
 796                 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
 797                         return -EFAULT;
 798         }
 799
 800         return 0;
 801 }
 802
 803 STATIC int
 804 xfs_ioc_fsgeometry_v1(
 805         xfs_mount_t             *mp,
 806         void                    __user *arg)
 807 {
 808         xfs_fsop_geom_t         fsgeo;
 809         int                     error;
 810
 811         error = xfs_fs_geometry(mp, &fsgeo, 3);
 812         if (error)
 813                 return error;
 814
 815         /*
 816          * Caller should have passed an argument of type
 817          * xfs_fsop_geom_v1_t.  This is a proper subset of the
 818          * xfs_fsop_geom_t that xfs_fs_geometry() fills in.
 819          */
 820         if (copy_to_user(arg, &fsgeo, sizeof(xfs_fsop_geom_v1_t)))
 821                 return -EFAULT;
 822         return 0;
 823 }
 824
 825 STATIC int
 826 xfs_ioc_fsgeometry(
 827         xfs_mount_t             *mp,
 828         void                    __user *arg)
 829 {
 830         xfs_fsop_geom_t         fsgeo;
 831         int                     error;
 832
 833         error = xfs_fs_geometry(mp, &fsgeo, 4);
 834         if (error)
 835                 return error;
 836
 837         if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
 838                 return -EFAULT;
 839         return 0;
 840 }
 841
 842 /*
 843  * Linux extended inode flags interface.
 844  */
 845
 846 STATIC unsigned int
 847 xfs_merge_ioc_xflags(
 848         unsigned int    flags,
 849         unsigned int    start)
 850 {
 851         unsigned int    xflags = start;
 852
 853         if (flags & FS_IMMUTABLE_FL)
 854                 xflags |= XFS_XFLAG_IMMUTABLE;
 855         else
 856                 xflags &= ~XFS_XFLAG_IMMUTABLE;
 857         if (flags & FS_APPEND_FL)
 858                 xflags |= XFS_XFLAG_APPEND;
 859         else
 860                 xflags &= ~XFS_XFLAG_APPEND;
 861         if (flags & FS_SYNC_FL)
 862                 xflags |= XFS_XFLAG_SYNC;
 863         else
 864                 xflags &= ~XFS_XFLAG_SYNC;
 865         if (flags & FS_NOATIME_FL)
 866                 xflags |= XFS_XFLAG_NOATIME;
 867         else
 868                 xflags &= ~XFS_XFLAG_NOATIME;
 869         if (flags & FS_NODUMP_FL)
 870                 xflags |= XFS_XFLAG_NODUMP;
 871         else
 872                 xflags &= ~XFS_XFLAG_NODUMP;
 873
 874         return xflags;
 875 }
 876
 877 STATIC unsigned int
 878 xfs_di2lxflags(
 879         __uint16_t      di_flags)
 880 {
 881         unsigned int    flags = 0;
 882
 883         if (di_flags & XFS_DIFLAG_IMMUTABLE)
 884                 flags |= FS_IMMUTABLE_FL;
 885         if (di_flags & XFS_DIFLAG_APPEND)
 886                 flags |= FS_APPEND_FL;
 887         if (di_flags & XFS_DIFLAG_SYNC)
 888                 flags |= FS_SYNC_FL;
 889         if (di_flags & XFS_DIFLAG_NOATIME)
 890                 flags |= FS_NOATIME_FL;
 891         if (di_flags & XFS_DIFLAG_NODUMP)
 892                 flags |= FS_NODUMP_FL;
 893         return flags;
 894 }
 895
 896 STATIC int
 897 xfs_ioc_fsgetxattr(
 898         xfs_inode_t             *ip,
 899         int                     attr,
 900         void                    __user *arg)
 901 {
 902         struct fsxattr          fa;
 903
 904         memset(&fa, 0, sizeof(struct fsxattr));
 905
 906         xfs_ilock(ip, XFS_ILOCK_SHARED);
 907         fa.fsx_xflags = xfs_ip2xflags(ip);
 908         fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
 909         fa.fsx_projid = xfs_get_projid(ip);
 910
 911         if (attr) {
 912                 if (ip->i_afp) {
 913                         if (ip->i_afp->if_flags & XFS_IFEXTENTS)
 914                                 fa.fsx_nextents = ip->i_afp->if_bytes /
 915                                                         sizeof(xfs_bmbt_rec_t);
 916                         else
 917                                 fa.fsx_nextents = ip->i_d.di_anextents;
 918                 } else
 919                         fa.fsx_nextents = 0;
 920         } else {
 921                 if (ip->i_df.if_flags & XFS_IFEXTENTS)
 922                         fa.fsx_nextents = ip->i_df.if_bytes /
 923                                                 sizeof(xfs_bmbt_rec_t);
 924                 else
 925                         fa.fsx_nextents = ip->i_d.di_nextents;
 926         }
 927         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 928
 929         if (copy_to_user(arg, &fa, sizeof(fa)))
 930                 return -EFAULT;
 931         return 0;
 932 }
 933
 934 STATIC void
 935 xfs_set_diflags(
 936         struct xfs_inode        *ip,
 937         unsigned int            xflags)
 938 {
 939         unsigned int            di_flags;
 940
 941         /* can't set PREALLOC this way, just preserve it */
 942         di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
 943         if (xflags & XFS_XFLAG_IMMUTABLE)
 944                 di_flags |= XFS_DIFLAG_IMMUTABLE;
 945         if (xflags & XFS_XFLAG_APPEND)
 946                 di_flags |= XFS_DIFLAG_APPEND;
 947         if (xflags & XFS_XFLAG_SYNC)
 948                 di_flags |= XFS_DIFLAG_SYNC;
 949         if (xflags & XFS_XFLAG_NOATIME)
 950                 di_flags |= XFS_DIFLAG_NOATIME;
 951         if (xflags & XFS_XFLAG_NODUMP)
 952                 di_flags |= XFS_DIFLAG_NODUMP;
 953         if (xflags & XFS_XFLAG_NODEFRAG)
 954                 di_flags |= XFS_DIFLAG_NODEFRAG;
 955         if (xflags & XFS_XFLAG_FILESTREAM)
 956                 di_flags |= XFS_DIFLAG_FILESTREAM;
 957         if (S_ISDIR(ip->i_d.di_mode)) {
 958                 if (xflags & XFS_XFLAG_RTINHERIT)
 959                         di_flags |= XFS_DIFLAG_RTINHERIT;
 960                 if (xflags & XFS_XFLAG_NOSYMLINKS)
 961                         di_flags |= XFS_DIFLAG_NOSYMLINKS;
 962                 if (xflags & XFS_XFLAG_EXTSZINHERIT)
 963                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
 964                 if (xflags & XFS_XFLAG_PROJINHERIT)
 965                         di_flags |= XFS_DIFLAG_PROJINHERIT;
 966         } else if (S_ISREG(ip->i_d.di_mode)) {
 967                 if (xflags & XFS_XFLAG_REALTIME)
 968                         di_flags |= XFS_DIFLAG_REALTIME;
 969                 if (xflags & XFS_XFLAG_EXTSIZE)
 970                         di_flags |= XFS_DIFLAG_EXTSIZE;
 971         }
 972
 973         ip->i_d.di_flags = di_flags;
 974 }
 975
 976 STATIC void
 977 xfs_diflags_to_linux(
 978         struct xfs_inode        *ip)
 979 {
 980         struct inode            *inode = VFS_I(ip);
 981         unsigned int            xflags = xfs_ip2xflags(ip);
 982
 983         if (xflags & XFS_XFLAG_IMMUTABLE)
 984                 inode->i_flags |= S_IMMUTABLE;
 985         else
 986                 inode->i_flags &= ~S_IMMUTABLE;
 987         if (xflags & XFS_XFLAG_APPEND)
 988                 inode->i_flags |= S_APPEND;
 989         else
 990                 inode->i_flags &= ~S_APPEND;
 991         if (xflags & XFS_XFLAG_SYNC)
 992                 inode->i_flags |= S_SYNC;
 993         else
 994                 inode->i_flags &= ~S_SYNC;
 995         if (xflags & XFS_XFLAG_NOATIME)
 996                 inode->i_flags |= S_NOATIME;
 997         else
 998                 inode->i_flags &= ~S_NOATIME;
 999 }
1000
1001 static int
1002 xfs_ioctl_setattr_xflags(
1003         struct xfs_trans        *tp,
1004         struct xfs_inode        *ip,
1005         struct fsxattr          *fa)
1006 {
1007         struct xfs_mount        *mp = ip->i_mount;
1008
1009         /* Can't change realtime flag if any extents are allocated. */
1010         if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1011             XFS_IS_REALTIME_INODE(ip) != (fa->fsx_xflags & XFS_XFLAG_REALTIME))
1012                 return -EINVAL;
1013
1014         /* If realtime flag is set then must have realtime device */
1015         if (fa->fsx_xflags & XFS_XFLAG_REALTIME) {
1016                 if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
1017                     (ip->i_d.di_extsize % mp->m_sb.sb_rextsize))
1018                         return -EINVAL;
1019         }
1020
1021         /*
1022          * Can't modify an immutable/append-only file unless
1023          * we have appropriate permission.
1024          */
1025         if (((ip->i_d.di_flags & (XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND)) ||
1026              (fa->fsx_xflags & (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
1027             !capable(CAP_LINUX_IMMUTABLE))
1028                 return -EPERM;
1029
1030         xfs_set_diflags(ip, fa->fsx_xflags);
1031         xfs_diflags_to_linux(ip);
1032         xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1033         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1034         XFS_STATS_INC(xs_ig_attrchg);
1035         return 0;
1036 }
1037
1038 /*
1039  * Set up the transaction structure for the setattr operation, checking that we
1040  * have permission to do so. On success, return a clean transaction and the
1041  * inode locked exclusively ready for further operation specific checks. On
1042  * failure, return an error without modifying or locking the inode.
1043  */
1044 static struct xfs_trans *
1045 xfs_ioctl_setattr_get_trans(
1046         struct xfs_inode        *ip)
1047 {
1048         struct xfs_mount        *mp = ip->i_mount;
1049         struct xfs_trans        *tp;
1050         int                     error;
1051
1052         if (mp->m_flags & XFS_MOUNT_RDONLY)
1053                 return ERR_PTR(-EROFS);
1054         if (XFS_FORCED_SHUTDOWN(mp))
1055                 return ERR_PTR(-EIO);
1056
1057         tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
1058         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
1059         if (error)
1060                 goto out_cancel;
1061
1062         xfs_ilock(ip, XFS_ILOCK_EXCL);
1063         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1064
1065         /*
1066          * CAP_FOWNER overrides the following restrictions:
1067          *
1068          * The user ID of the calling process must be equal to the file owner
1069          * ID, except in cases where the CAP_FSETID capability is applicable.
1070          */
1071         if (!inode_owner_or_capable(VFS_I(ip))) {
1072                 error = -EPERM;
1073                 goto out_cancel;
1074         }
1075
1076         if (mp->m_flags & XFS_MOUNT_WSYNC)
1077                 xfs_trans_set_sync(tp);
1078
1079         return tp;
1080
1081 out_cancel:
1082         xfs_trans_cancel(tp);
1083         return ERR_PTR(error);
1084 }
1085
1086 /*
1087  * extent size hint validation is somewhat cumbersome. Rules are:
1088  *
1089  * 1. extent size hint is only valid for directories and regular files
1090  * 2. XFS_XFLAG_EXTSIZE is only valid for regular files
1091  * 3. XFS_XFLAG_EXTSZINHERIT is only valid for directories.
1092  * 4. can only be changed on regular files if no extents are allocated
1093  * 5. can be changed on directories at any time
1094  * 6. extsize hint of 0 turns off hints, clears inode flags.
1095  * 7. Extent size must be a multiple of the appropriate block size.
1096  * 8. for non-realtime files, the extent size hint must be limited
1097  *    to half the AG size to avoid alignment extending the extent beyond the
1098  *    limits of the AG.
1099  */
1100 static int
1101 xfs_ioctl_setattr_check_extsize(
1102         struct xfs_inode        *ip,
1103         struct fsxattr          *fa)
1104 {
1105         struct xfs_mount        *mp = ip->i_mount;
1106
1107         if ((fa->fsx_xflags & XFS_XFLAG_EXTSIZE) && !S_ISREG(ip->i_d.di_mode))
1108                 return -EINVAL;
1109
1110         if ((fa->fsx_xflags & XFS_XFLAG_EXTSZINHERIT) &&
1111             !S_ISDIR(ip->i_d.di_mode))
1112                 return -EINVAL;
1113
1114         if (S_ISREG(ip->i_d.di_mode) && ip->i_d.di_nextents &&
1115             ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) != fa->fsx_extsize))
1116                 return -EINVAL;
1117
1118         if (fa->fsx_extsize != 0) {
1119                 xfs_extlen_t    size;
1120                 xfs_fsblock_t   extsize_fsb;
1121
1122                 extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
1123                 if (extsize_fsb > MAXEXTLEN)
1124                         return -EINVAL;
1125
1126                 if (XFS_IS_REALTIME_INODE(ip) ||
1127                     (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1128                         size = mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog;
1129                 } else {
1130                         size = mp->m_sb.sb_blocksize;
1131                         if (extsize_fsb > mp->m_sb.sb_agblocks / 2)
1132                                 return -EINVAL;
1133                 }
1134
1135                 if (fa->fsx_extsize % size)
1136                         return -EINVAL;
1137         } else
1138                 fa->fsx_xflags &= ~(XFS_XFLAG_EXTSIZE | XFS_XFLAG_EXTSZINHERIT);
1139
1140         return 0;
1141 }
1142
1143 static int
1144 xfs_ioctl_setattr_check_projid(
1145         struct xfs_inode        *ip,
1146         struct fsxattr          *fa)
1147 {
1148         /* Disallow 32bit project ids if projid32bit feature is not enabled. */
1149         if (fa->fsx_projid > (__uint16_t)-1 &&
1150             !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
1151                 return -EINVAL;
1152
1153         /*
1154          * Project Quota ID state is only allowed to change from within the init
1155          * namespace. Enforce that restriction only if we are trying to change
1156          * the quota ID state. Everything else is allowed in user namespaces.
1157          */
1158         if (current_user_ns() == &init_user_ns)
1159                 return 0;
1160
1161         if (xfs_get_projid(ip) != fa->fsx_projid)
1162                 return -EINVAL;
1163         if ((fa->fsx_xflags & XFS_XFLAG_PROJINHERIT) !=
1164             (ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT))
1165                 return -EINVAL;
1166
1167         return 0;
1168 }
1169
1170 STATIC int
1171 xfs_ioctl_setattr(
1172         xfs_inode_t             *ip,
1173         struct fsxattr          *fa)
1174 {
1175         struct xfs_mount        *mp = ip->i_mount;
1176         struct xfs_trans        *tp;
1177         struct xfs_dquot        *udqp = NULL;
1178         struct xfs_dquot        *pdqp = NULL;
1179         struct xfs_dquot        *olddquot = NULL;
1180         int                     code;
1181
1182         trace_xfs_ioctl_setattr(ip);
1183
1184         code = xfs_ioctl_setattr_check_projid(ip, fa);
1185         if (code)
1186                 return code;
1187
1188         /*
1189          * If disk quotas is on, we make sure that the dquots do exist on disk,
1190          * before we start any other transactions. Trying to do this later
1191          * is messy. We don't care to take a readlock to look at the ids
1192          * in inode here, because we can't hold it across the trans_reserve.
1193          * If the IDs do change before we take the ilock, we're covered
1194          * because the i_*dquot fields will get updated anyway.
1195          */
1196         if (XFS_IS_QUOTA_ON(mp)) {
1197                 code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,
1198                                          ip->i_d.di_gid, fa->fsx_projid,
1199                                          XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);
1200                 if (code)
1201                         return code;
1202         }
1203
1204         tp = xfs_ioctl_setattr_get_trans(ip);
1205         if (IS_ERR(tp)) {
1206                 code = PTR_ERR(tp);
1207                 goto error_free_dquots;
1208         }
1209
1210
1211         if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp) &&
1212             xfs_get_projid(ip) != fa->fsx_projid) {
1213                 code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL, pdqp,
1214                                 capable(CAP_FOWNER) ?  XFS_QMOPT_FORCE_RES : 0);
1215                 if (code)       /* out of quota */
1216                         goto error_trans_cancel;
1217         }
1218
1219         code = xfs_ioctl_setattr_check_extsize(ip, fa);
1220         if (code)
1221                 goto error_trans_cancel;
1222
1223         code = xfs_ioctl_setattr_xflags(tp, ip, fa);
1224         if (code)
1225                 goto error_trans_cancel;
1226
1227         /*
1228          * Change file ownership.  Must be the owner or privileged.  CAP_FSETID
1229          * overrides the following restrictions:
1230          *
1231          * The set-user-ID and set-group-ID bits of a file will be cleared upon
1232          * successful return from chown()
1233          */
1234
1235         if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
1236             !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID))
1237                 ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
1238
1239         /* Change the ownerships and register project quota modifications */
1240         if (xfs_get_projid(ip) != fa->fsx_projid) {
1241                 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {
1242                         olddquot = xfs_qm_vop_chown(tp, ip,
1243                                                 &ip->i_pdquot, pdqp);
1244                 }
1245                 ASSERT(ip->i_d.di_version > 1);
1246                 xfs_set_projid(ip, fa->fsx_projid);
1247         }
1248
1249         /*
1250          * Only set the extent size hint if we've already determined that the
1251          * extent size hint should be set on the inode. If no extent size flags
1252          * are set on the inode then unconditionally clear the extent size hint.
1253          */
1254         if (ip->i_d.di_flags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
1255                 ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1256         else
1257                 ip->i_d.di_extsize = 0;
1258
1259         code = xfs_trans_commit(tp);
1260
1261         /*
1262          * Release any dquot(s) the inode had kept before chown.
1263          */
1264         xfs_qm_dqrele(olddquot);
1265         xfs_qm_dqrele(udqp);
1266         xfs_qm_dqrele(pdqp);
1267
1268         return code;
1269
1270 error_trans_cancel:
1271         xfs_trans_cancel(tp);
1272 error_free_dquots:
1273         xfs_qm_dqrele(udqp);
1274         xfs_qm_dqrele(pdqp);
1275         return code;
1276 }
1277
1278 STATIC int
1279 xfs_ioc_fssetxattr(
1280         xfs_inode_t             *ip,
1281         struct file             *filp,
1282         void                    __user *arg)
1283 {
1284         struct fsxattr          fa;
1285         int error;
1286
1287         if (copy_from_user(&fa, arg, sizeof(fa)))
1288                 return -EFAULT;
1289
1290         error = mnt_want_write_file(filp);
1291         if (error)
1292                 return error;
1293         error = xfs_ioctl_setattr(ip, &fa);
1294         mnt_drop_write_file(filp);
1295         return error;
1296 }
1297
1298 STATIC int
1299 xfs_ioc_getxflags(
1300         xfs_inode_t             *ip,
1301         void                    __user *arg)
1302 {
1303         unsigned int            flags;
1304
1305         flags = xfs_di2lxflags(ip->i_d.di_flags);
1306         if (copy_to_user(arg, &flags, sizeof(flags)))
1307                 return -EFAULT;
1308         return 0;
1309 }
1310
1311 STATIC int
1312 xfs_ioc_setxflags(
1313         struct xfs_inode        *ip,
1314         struct file             *filp,
1315         void                    __user *arg)
1316 {
1317         struct xfs_trans        *tp;
1318         struct fsxattr          fa;
1319         unsigned int            flags;
1320         int                     error;
1321
1322         if (copy_from_user(&flags, arg, sizeof(flags)))
1323                 return -EFAULT;
1324
1325         if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1326                       FS_NOATIME_FL | FS_NODUMP_FL | \
1327                       FS_SYNC_FL))
1328                 return -EOPNOTSUPP;
1329
1330         fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
1331
1332         error = mnt_want_write_file(filp);
1333         if (error)
1334                 return error;
1335
1336         tp = xfs_ioctl_setattr_get_trans(ip);
1337         if (IS_ERR(tp)) {
1338                 error = PTR_ERR(tp);
1339                 goto out_drop_write;
1340         }
1341
1342         error = xfs_ioctl_setattr_xflags(tp, ip, &fa);
1343         if (error) {
1344                 xfs_trans_cancel(tp);
1345                 goto out_drop_write;
1346         }
1347
1348         error = xfs_trans_commit(tp);
1349 out_drop_write:
1350         mnt_drop_write_file(filp);
1351         return error;
1352 }
1353
1354 STATIC int
1355 xfs_getbmap_format(void **ap, struct getbmapx *bmv, int *full)
1356 {
1357         struct getbmap __user   *base = (struct getbmap __user *)*ap;
1358
1359         /* copy only getbmap portion (not getbmapx) */
1360         if (copy_to_user(base, bmv, sizeof(struct getbmap)))
1361                 return -EFAULT;
1362
1363         *ap += sizeof(struct getbmap);
1364         return 0;
1365 }
1366
1367 STATIC int
1368 xfs_ioc_getbmap(
1369         struct xfs_inode        *ip,
1370         int                     ioflags,
1371         unsigned int            cmd,
1372         void                    __user *arg)
1373 {
1374         struct getbmapx         bmx;
1375         int                     error;
1376
1377         if (copy_from_user(&bmx, arg, sizeof(struct getbmapx)))
1378                 return -EFAULT;
1379
1380         if (bmx.bmv_count < 2)
1381                 return -EINVAL;
1382
1383         bmx.bmv_iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1384         if (ioflags & XFS_IO_INVIS)
1385                 bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
1386
1387         error = xfs_getbmap(ip, &bmx, xfs_getbmap_format,
1388                             (__force struct getbmap *)arg+1);
1389         if (error)
1390                 return error;
1391
1392         /* copy back header - only size of getbmap */
1393         if (copy_to_user(arg, &bmx, sizeof(struct getbmap)))
1394                 return -EFAULT;
1395         return 0;
1396 }
1397
1398 STATIC int
1399 xfs_getbmapx_format(void **ap, struct getbmapx *bmv, int *full)
1400 {
1401         struct getbmapx __user  *base = (struct getbmapx __user *)*ap;
1402
1403         if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
1404                 return -EFAULT;
1405
1406         *ap += sizeof(struct getbmapx);
1407         return 0;
1408 }
1409
1410 STATIC int
1411 xfs_ioc_getbmapx(
1412         struct xfs_inode        *ip,
1413         void                    __user *arg)
1414 {
1415         struct getbmapx         bmx;
1416         int                     error;
1417
1418         if (copy_from_user(&bmx, arg, sizeof(bmx)))
1419                 return -EFAULT;
1420
1421         if (bmx.bmv_count < 2)
1422                 return -EINVAL;
1423
1424         if (bmx.bmv_iflags & (~BMV_IF_VALID))
1425                 return -EINVAL;
1426
1427         error = xfs_getbmap(ip, &bmx, xfs_getbmapx_format,
1428                             (__force struct getbmapx *)arg+1);
1429         if (error)
1430                 return error;
1431
1432         /* copy back header */
1433         if (copy_to_user(arg, &bmx, sizeof(struct getbmapx)))
1434                 return -EFAULT;
1435
1436         return 0;
1437 }
1438
1439 int
1440 xfs_ioc_swapext(
1441         xfs_swapext_t   *sxp)
1442 {
1443         xfs_inode_t     *ip, *tip;
1444         struct fd       f, tmp;
1445         int             error = 0;
1446
1447         /* Pull information for the target fd */
1448         f = fdget((int)sxp->sx_fdtarget);
1449         if (!f.file) {
1450                 error = -EINVAL;
1451                 goto out;
1452         }
1453
1454         if (!(f.file->f_mode & FMODE_WRITE) ||
1455             !(f.file->f_mode & FMODE_READ) ||
1456             (f.file->f_flags & O_APPEND)) {
1457                 error = -EBADF;
1458                 goto out_put_file;
1459         }
1460
1461         tmp = fdget((int)sxp->sx_fdtmp);
1462         if (!tmp.file) {
1463                 error = -EINVAL;
1464                 goto out_put_file;
1465         }
1466
1467         if (!(tmp.file->f_mode & FMODE_WRITE) ||
1468             !(tmp.file->f_mode & FMODE_READ) ||
1469             (tmp.file->f_flags & O_APPEND)) {
1470                 error = -EBADF;
1471                 goto out_put_tmp_file;
1472         }
1473
1474         if (IS_SWAPFILE(file_inode(f.file)) ||
1475             IS_SWAPFILE(file_inode(tmp.file))) {
1476                 error = -EINVAL;
1477                 goto out_put_tmp_file;
1478         }
1479
1480         ip = XFS_I(file_inode(f.file));
1481         tip = XFS_I(file_inode(tmp.file));
1482
1483         if (ip->i_mount != tip->i_mount) {
1484                 error = -EINVAL;
1485                 goto out_put_tmp_file;
1486         }
1487
1488         if (ip->i_ino == tip->i_ino) {
1489                 error = -EINVAL;
1490                 goto out_put_tmp_file;
1491         }
1492
1493         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1494                 error = -EIO;
1495                 goto out_put_tmp_file;
1496         }
1497
1498         error = xfs_swap_extents(ip, tip, sxp);
1499
1500  out_put_tmp_file:
1501         fdput(tmp);
1502  out_put_file:
1503         fdput(f);
1504  out:
1505         return error;
1506 }
1507
1508 /*
1509  * Note: some of the ioctl's return positive numbers as a
1510  * byte count indicating success, such as readlink_by_handle.
1511  * So we don't "sign flip" like most other routines.  This means
1512  * true errors need to be returned as a negative value.
1513  */
1514 long
1515 xfs_file_ioctl(
1516         struct file             *filp,
1517         unsigned int            cmd,
1518         unsigned long           p)
1519 {
1520         struct inode            *inode = file_inode(filp);
1521         struct xfs_inode        *ip = XFS_I(inode);
1522         struct xfs_mount        *mp = ip->i_mount;
1523         void                    __user *arg = (void __user *)p;
1524         int                     ioflags = 0;
1525         int                     error;
1526
1527         if (filp->f_mode & FMODE_NOCMTIME)
1528                 ioflags |= XFS_IO_INVIS;
1529
1530         trace_xfs_file_ioctl(ip);
1531
1532         switch (cmd) {
1533         case FITRIM:
1534                 return xfs_ioc_trim(mp, arg);
1535         case XFS_IOC_ALLOCSP:
1536         case XFS_IOC_FREESP:
1537         case XFS_IOC_RESVSP:
1538         case XFS_IOC_UNRESVSP:
1539         case XFS_IOC_ALLOCSP64:
1540         case XFS_IOC_FREESP64:
1541         case XFS_IOC_RESVSP64:
1542         case XFS_IOC_UNRESVSP64:
1543         case XFS_IOC_ZERO_RANGE: {
1544                 xfs_flock64_t           bf;
1545
1546                 if (copy_from_user(&bf, arg, sizeof(bf)))
1547                         return -EFAULT;
1548                 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
1549         }
1550         case XFS_IOC_DIOINFO: {
1551                 struct dioattr  da;
1552                 xfs_buftarg_t   *target =
1553                         XFS_IS_REALTIME_INODE(ip) ?
1554                         mp->m_rtdev_targp : mp->m_ddev_targp;
1555
1556                 da.d_mem =  da.d_miniosz = target->bt_logical_sectorsize;
1557                 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1558
1559                 if (copy_to_user(arg, &da, sizeof(da)))
1560                         return -EFAULT;
1561                 return 0;
1562         }
1563
1564         case XFS_IOC_FSBULKSTAT_SINGLE:
1565         case XFS_IOC_FSBULKSTAT:
1566         case XFS_IOC_FSINUMBERS:
1567                 return xfs_ioc_bulkstat(mp, cmd, arg);
1568
1569         case XFS_IOC_FSGEOMETRY_V1:
1570                 return xfs_ioc_fsgeometry_v1(mp, arg);
1571
1572         case XFS_IOC_FSGEOMETRY:
1573                 return xfs_ioc_fsgeometry(mp, arg);
1574
1575         case XFS_IOC_GETVERSION:
1576                 return put_user(inode->i_generation, (int __user *)arg);
1577
1578         case XFS_IOC_FSGETXATTR:
1579                 return xfs_ioc_fsgetxattr(ip, 0, arg);
1580         case XFS_IOC_FSGETXATTRA:
1581                 return xfs_ioc_fsgetxattr(ip, 1, arg);
1582         case XFS_IOC_FSSETXATTR:
1583                 return xfs_ioc_fssetxattr(ip, filp, arg);
1584         case XFS_IOC_GETXFLAGS:
1585                 return xfs_ioc_getxflags(ip, arg);
1586         case XFS_IOC_SETXFLAGS:
1587                 return xfs_ioc_setxflags(ip, filp, arg);
1588
1589         case XFS_IOC_FSSETDM: {
1590                 struct fsdmidata        dmi;
1591
1592                 if (copy_from_user(&dmi, arg, sizeof(dmi)))
1593                         return -EFAULT;
1594
1595                 error = mnt_want_write_file(filp);
1596                 if (error)
1597                         return error;
1598
1599                 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1600                                 dmi.fsd_dmstate);
1601                 mnt_drop_write_file(filp);
1602                 return error;
1603         }
1604
1605         case XFS_IOC_GETBMAP:
1606         case XFS_IOC_GETBMAPA:
1607                 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1608
1609         case XFS_IOC_GETBMAPX:
1610                 return xfs_ioc_getbmapx(ip, arg);
1611
1612         case XFS_IOC_FD_TO_HANDLE:
1613         case XFS_IOC_PATH_TO_HANDLE:
1614         case XFS_IOC_PATH_TO_FSHANDLE: {
1615                 xfs_fsop_handlereq_t    hreq;
1616
1617                 if (copy_from_user(&hreq, arg, sizeof(hreq)))
1618                         return -EFAULT;
1619                 return xfs_find_handle(cmd, &hreq);
1620         }
1621         case XFS_IOC_OPEN_BY_HANDLE: {
1622                 xfs_fsop_handlereq_t    hreq;
1623
1624                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1625                         return -EFAULT;
1626                 return xfs_open_by_handle(filp, &hreq);
1627         }
1628         case XFS_IOC_FSSETDM_BY_HANDLE:
1629                 return xfs_fssetdm_by_handle(filp, arg);
1630
1631         case XFS_IOC_READLINK_BY_HANDLE: {
1632                 xfs_fsop_handlereq_t    hreq;
1633
1634                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1635                         return -EFAULT;
1636                 return xfs_readlink_by_handle(filp, &hreq);
1637         }
1638         case XFS_IOC_ATTRLIST_BY_HANDLE:
1639                 return xfs_attrlist_by_handle(filp, arg);
1640
1641         case XFS_IOC_ATTRMULTI_BY_HANDLE:
1642                 return xfs_attrmulti_by_handle(filp, arg);
1643
1644         case XFS_IOC_SWAPEXT: {
1645                 struct xfs_swapext      sxp;
1646
1647                 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
1648                         return -EFAULT;
1649                 error = mnt_want_write_file(filp);
1650                 if (error)
1651                         return error;
1652                 error = xfs_ioc_swapext(&sxp);
1653                 mnt_drop_write_file(filp);
1654                 return error;
1655         }
1656
1657         case XFS_IOC_FSCOUNTS: {
1658                 xfs_fsop_counts_t out;
1659
1660                 error = xfs_fs_counts(mp, &out);
1661                 if (error)
1662                         return error;
1663
1664                 if (copy_to_user(arg, &out, sizeof(out)))
1665                         return -EFAULT;
1666                 return 0;
1667         }
1668
1669         case XFS_IOC_SET_RESBLKS: {
1670                 xfs_fsop_resblks_t inout;
1671                 __uint64_t         in;
1672
1673                 if (!capable(CAP_SYS_ADMIN))
1674                         return -EPERM;
1675
1676                 if (mp->m_flags & XFS_MOUNT_RDONLY)
1677                         return -EROFS;
1678
1679                 if (copy_from_user(&inout, arg, sizeof(inout)))
1680                         return -EFAULT;
1681
1682                 error = mnt_want_write_file(filp);
1683                 if (error)
1684                         return error;
1685
1686                 /* input parameter is passed in resblks field of structure */
1687                 in = inout.resblks;
1688                 error = xfs_reserve_blocks(mp, &in, &inout);
1689                 mnt_drop_write_file(filp);
1690                 if (error)
1691                         return error;
1692
1693                 if (copy_to_user(arg, &inout, sizeof(inout)))
1694                         return -EFAULT;
1695                 return 0;
1696         }
1697
1698         case XFS_IOC_GET_RESBLKS: {
1699                 xfs_fsop_resblks_t out;
1700
1701                 if (!capable(CAP_SYS_ADMIN))
1702                         return -EPERM;
1703
1704                 error = xfs_reserve_blocks(mp, NULL, &out);
1705                 if (error)
1706                         return error;
1707
1708                 if (copy_to_user(arg, &out, sizeof(out)))
1709                         return -EFAULT;
1710
1711                 return 0;
1712         }
1713
1714         case XFS_IOC_FSGROWFSDATA: {
1715                 xfs_growfs_data_t in;
1716
1717                 if (copy_from_user(&in, arg, sizeof(in)))
1718                         return -EFAULT;
1719
1720                 error = mnt_want_write_file(filp);
1721                 if (error)
1722                         return error;
1723                 error = xfs_growfs_data(mp, &in);
1724                 mnt_drop_write_file(filp);
1725                 return error;
1726         }
1727
1728         case XFS_IOC_FSGROWFSLOG: {
1729                 xfs_growfs_log_t in;
1730
1731                 if (copy_from_user(&in, arg, sizeof(in)))
1732                         return -EFAULT;
1733
1734                 error = mnt_want_write_file(filp);
1735                 if (error)
1736                         return error;
1737                 error = xfs_growfs_log(mp, &in);
1738                 mnt_drop_write_file(filp);
1739                 return error;
1740         }
1741
1742         case XFS_IOC_FSGROWFSRT: {
1743                 xfs_growfs_rt_t in;
1744
1745                 if (copy_from_user(&in, arg, sizeof(in)))
1746                         return -EFAULT;
1747
1748                 error = mnt_want_write_file(filp);
1749                 if (error)
1750                         return error;
1751                 error = xfs_growfs_rt(mp, &in);
1752                 mnt_drop_write_file(filp);
1753                 return error;
1754         }
1755
1756         case XFS_IOC_GOINGDOWN: {
1757                 __uint32_t in;
1758
1759                 if (!capable(CAP_SYS_ADMIN))
1760                         return -EPERM;
1761
1762                 if (get_user(in, (__uint32_t __user *)arg))
1763                         return -EFAULT;
1764
1765                 return xfs_fs_goingdown(mp, in);
1766         }
1767
1768         case XFS_IOC_ERROR_INJECTION: {
1769                 xfs_error_injection_t in;
1770
1771                 if (!capable(CAP_SYS_ADMIN))
1772                         return -EPERM;
1773
1774                 if (copy_from_user(&in, arg, sizeof(in)))
1775                         return -EFAULT;
1776
1777                 return xfs_errortag_add(in.errtag, mp);
1778         }
1779
1780         case XFS_IOC_ERROR_CLEARALL:
1781                 if (!capable(CAP_SYS_ADMIN))
1782                         return -EPERM;
1783
1784                 return xfs_errortag_clearall(mp, 1);
1785
1786         case XFS_IOC_FREE_EOFBLOCKS: {
1787                 struct xfs_fs_eofblocks eofb;
1788                 struct xfs_eofblocks keofb;
1789
1790                 if (!capable(CAP_SYS_ADMIN))
1791                         return -EPERM;
1792
1793                 if (mp->m_flags & XFS_MOUNT_RDONLY)
1794                         return -EROFS;
1795
1796                 if (copy_from_user(&eofb, arg, sizeof(eofb)))
1797                         return -EFAULT;
1798
1799                 error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
1800                 if (error)
1801                         return error;
1802
1803                 return xfs_icache_free_eofblocks(mp, &keofb);
1804         }
1805
1806         default:
1807                 return -ENOTTY;
1808         }
1809 }