kernel/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, 0);
 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, 0);
 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
 486         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 487                 return -EPERM;
 488         if (len > XATTR_SIZE_MAX)
 489                 return -EINVAL;
 490
 491         kbuf = memdup_user(ubuf, len);
 492         if (IS_ERR(kbuf))
 493                 return PTR_ERR(kbuf);
 494
 495         return xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
 496 }
 497
 498 int
 499 xfs_attrmulti_attr_remove(
 500         struct inode            *inode,
 501         unsigned char           *name,
 502         __uint32_t              flags)
 503 {
 504         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 505                 return -EPERM;
 506         return xfs_attr_remove(XFS_I(inode), name, flags);
 507 }
 508
 509 STATIC int
 510 xfs_attrmulti_by_handle(
 511         struct file             *parfilp,
 512         void                    __user *arg)
 513 {
 514         int                     error;
 515         xfs_attr_multiop_t      *ops;
 516         xfs_fsop_attrmulti_handlereq_t am_hreq;
 517         struct dentry           *dentry;
 518         unsigned int            i, size;
 519         unsigned char           *attr_name;
 520
 521         if (!capable(CAP_SYS_ADMIN))
 522                 return -EPERM;
 523         if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
 524                 return -EFAULT;
 525
 526         /* overflow check */
 527         if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
 528                 return -E2BIG;
 529
 530         dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);
 531         if (IS_ERR(dentry))
 532                 return PTR_ERR(dentry);
 533
 534         error = -E2BIG;
 535         size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
 536         if (!size || size > 16 * PAGE_SIZE)
 537                 goto out_dput;
 538
 539         ops = memdup_user(am_hreq.ops, size);
 540         if (IS_ERR(ops)) {
 541                 error = PTR_ERR(ops);
 542                 goto out_dput;
 543         }
 544
 545         error = -ENOMEM;
 546         attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
 547         if (!attr_name)
 548                 goto out_kfree_ops;
 549
 550         error = 0;
 551         for (i = 0; i < am_hreq.opcount; i++) {
 552                 ops[i].am_error = strncpy_from_user((char *)attr_name,
 553                                 ops[i].am_attrname, MAXNAMELEN);
 554                 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
 555                         error = -ERANGE;
 556                 if (ops[i].am_error < 0)
 557                         break;
 558
 559                 switch (ops[i].am_opcode) {
 560                 case ATTR_OP_GET:
 561                         ops[i].am_error = xfs_attrmulti_attr_get(
 562                                         d_inode(dentry), attr_name,
 563                                         ops[i].am_attrvalue, &ops[i].am_length,
 564                                         ops[i].am_flags);
 565                         break;
 566                 case ATTR_OP_SET:
 567                         ops[i].am_error = mnt_want_write_file(parfilp);
 568                         if (ops[i].am_error)
 569                                 break;
 570                         ops[i].am_error = xfs_attrmulti_attr_set(
 571                                         d_inode(dentry), attr_name,
 572                                         ops[i].am_attrvalue, ops[i].am_length,
 573                                         ops[i].am_flags);
 574                         mnt_drop_write_file(parfilp);
 575                         break;
 576                 case ATTR_OP_REMOVE:
 577                         ops[i].am_error = mnt_want_write_file(parfilp);
 578                         if (ops[i].am_error)
 579                                 break;
 580                         ops[i].am_error = xfs_attrmulti_attr_remove(
 581                                         d_inode(dentry), attr_name,
 582                                         ops[i].am_flags);
 583                         mnt_drop_write_file(parfilp);
 584                         break;
 585                 default:
 586                         ops[i].am_error = -EINVAL;
 587                 }
 588         }
 589
 590         if (copy_to_user(am_hreq.ops, ops, size))
 591                 error = -EFAULT;
 592
 593         kfree(attr_name);
 594  out_kfree_ops:
 595         kfree(ops);
 596  out_dput:
 597         dput(dentry);
 598         return error;
 599 }
 600
 601 int
 602 xfs_ioc_space(
 603         struct xfs_inode        *ip,
 604         struct inode            *inode,
 605         struct file             *filp,
 606         int                     ioflags,
 607         unsigned int            cmd,
 608         xfs_flock64_t           *bf)
 609 {
 610         struct iattr            iattr;
 611         enum xfs_prealloc_flags flags = 0;
 612         uint                    iolock = XFS_IOLOCK_EXCL;
 613         int                     error;
 614
 615         /*
 616          * Only allow the sys admin to reserve space unless
 617          * unwritten extents are enabled.
 618          */
 619         if (!xfs_sb_version_hasextflgbit(&ip->i_mount->m_sb) &&
 620             !capable(CAP_SYS_ADMIN))
 621                 return -EPERM;
 622
 623         if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
 624                 return -EPERM;
 625
 626         if (!(filp->f_mode & FMODE_WRITE))
 627                 return -EBADF;
 628
 629         if (!S_ISREG(inode->i_mode))
 630                 return -EINVAL;
 631
 632         if (filp->f_flags & O_DSYNC)
 633                 flags |= XFS_PREALLOC_SYNC;
 634         if (ioflags & XFS_IO_INVIS)
 635                 flags |= XFS_PREALLOC_INVISIBLE;
 636
 637         error = mnt_want_write_file(filp);
 638         if (error)
 639                 return error;
 640
 641         xfs_ilock(ip, iolock);
 642         error = xfs_break_layouts(inode, &iolock, false);
 643         if (error)
 644                 goto out_unlock;
 645
 646         xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
 647         iolock |= XFS_MMAPLOCK_EXCL;
 648
 649         switch (bf->l_whence) {
 650         case 0: /*SEEK_SET*/
 651                 break;
 652         case 1: /*SEEK_CUR*/
 653                 bf->l_start += filp->f_pos;
 654                 break;
 655         case 2: /*SEEK_END*/
 656                 bf->l_start += XFS_ISIZE(ip);
 657                 break;
 658         default:
 659                 error = -EINVAL;
 660                 goto out_unlock;
 661         }
 662
 663         /*
 664          * length of <= 0 for resv/unresv/zero is invalid.  length for
 665          * alloc/free is ignored completely and we have no idea what userspace
 666          * might have set it to, so set it to zero to allow range
 667          * checks to pass.
 668          */
 669         switch (cmd) {
 670         case XFS_IOC_ZERO_RANGE:
 671         case XFS_IOC_RESVSP:
 672         case XFS_IOC_RESVSP64:
 673         case XFS_IOC_UNRESVSP:
 674         case XFS_IOC_UNRESVSP64:
 675                 if (bf->l_len <= 0) {
 676                         error = -EINVAL;
 677                         goto out_unlock;
 678                 }
 679                 break;
 680         default:
 681                 bf->l_len = 0;
 682                 break;
 683         }
 684
 685         if (bf->l_start < 0 ||
 686             bf->l_start > inode->i_sb->s_maxbytes ||
 687             bf->l_start + bf->l_len < 0 ||
 688             bf->l_start + bf->l_len >= inode->i_sb->s_maxbytes) {
 689                 error = -EINVAL;
 690                 goto out_unlock;
 691         }
 692
 693         switch (cmd) {
 694         case XFS_IOC_ZERO_RANGE:
 695                 flags |= XFS_PREALLOC_SET;
 696                 error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
 697                 break;
 698         case XFS_IOC_RESVSP:
 699         case XFS_IOC_RESVSP64:
 700                 flags |= XFS_PREALLOC_SET;
 701                 error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
 702                                                 XFS_BMAPI_PREALLOC);
 703                 break;
 704         case XFS_IOC_UNRESVSP:
 705         case XFS_IOC_UNRESVSP64:
 706                 error = xfs_free_file_space(ip, bf->l_start, bf->l_len);
 707                 break;
 708         case XFS_IOC_ALLOCSP:
 709         case XFS_IOC_ALLOCSP64:
 710         case XFS_IOC_FREESP:
 711         case XFS_IOC_FREESP64:
 712                 flags |= XFS_PREALLOC_CLEAR;
 713                 if (bf->l_start > XFS_ISIZE(ip)) {
 714                         error = xfs_alloc_file_space(ip, XFS_ISIZE(ip),
 715                                         bf->l_start - XFS_ISIZE(ip), 0);
 716                         if (error)
 717                                 goto out_unlock;
 718                 }
 719
 720                 iattr.ia_valid = ATTR_SIZE;
 721                 iattr.ia_size = bf->l_start;
 722
 723                 error = xfs_setattr_size(ip, &iattr);
 724                 break;
 725         default:
 726                 ASSERT(0);
 727                 error = -EINVAL;
 728         }
 729
 730         if (error)
 731                 goto out_unlock;
 732
 733         error = xfs_update_prealloc_flags(ip, flags);
 734
 735 out_unlock:
 736         xfs_iunlock(ip, iolock);
 737         mnt_drop_write_file(filp);
 738         return error;
 739 }
 740
 741 STATIC int
 742 xfs_ioc_bulkstat(
 743         xfs_mount_t             *mp,
 744         unsigned int            cmd,
 745         void                    __user *arg)
 746 {
 747         xfs_fsop_bulkreq_t      bulkreq;
 748         int                     count;  /* # of records returned */
 749         xfs_ino_t               inlast; /* last inode number */
 750         int                     done;
 751         int                     error;
 752
 753         /* done = 1 if there are more stats to get and if bulkstat */
 754         /* should be called again (unused here, but used in dmapi) */
 755
 756         if (!capable(CAP_SYS_ADMIN))
 757                 return -EPERM;
 758
 759         if (XFS_FORCED_SHUTDOWN(mp))
 760                 return -EIO;
 761
 762         if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
 763                 return -EFAULT;
 764
 765         if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
 766                 return -EFAULT;
 767
 768         if ((count = bulkreq.icount) <= 0)
 769                 return -EINVAL;
 770
 771         if (bulkreq.ubuffer == NULL)
 772                 return -EINVAL;
 773
 774         if (cmd == XFS_IOC_FSINUMBERS)
 775                 error = xfs_inumbers(mp, &inlast, &count,
 776                                         bulkreq.ubuffer, xfs_inumbers_fmt);
 777         else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
 778                 error = xfs_bulkstat_one(mp, inlast, bulkreq.ubuffer,
 779                                         sizeof(xfs_bstat_t), NULL, &done);
 780         else    /* XFS_IOC_FSBULKSTAT */
 781                 error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
 782                                      sizeof(xfs_bstat_t), bulkreq.ubuffer,
 783                                      &done);
 784
 785         if (error)
 786                 return error;
 787
 788         if (bulkreq.ocount != NULL) {
 789                 if (copy_to_user(bulkreq.lastip, &inlast,
 790                                                 sizeof(xfs_ino_t)))
 791                         return -EFAULT;
 792
 793                 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
 794                         return -EFAULT;
 795         }
 796
 797         return 0;
 798 }
 799
 800 STATIC int
 801 xfs_ioc_fsgeometry_v1(
 802         xfs_mount_t             *mp,
 803         void                    __user *arg)
 804 {
 805         xfs_fsop_geom_t         fsgeo;
 806         int                     error;
 807
 808         error = xfs_fs_geometry(mp, &fsgeo, 3);
 809         if (error)
 810                 return error;
 811
 812         /*
 813          * Caller should have passed an argument of type
 814          * xfs_fsop_geom_v1_t.  This is a proper subset of the
 815          * xfs_fsop_geom_t that xfs_fs_geometry() fills in.
 816          */
 817         if (copy_to_user(arg, &fsgeo, sizeof(xfs_fsop_geom_v1_t)))
 818                 return -EFAULT;
 819         return 0;
 820 }
 821
 822 STATIC int
 823 xfs_ioc_fsgeometry(
 824         xfs_mount_t             *mp,
 825         void                    __user *arg)
 826 {
 827         xfs_fsop_geom_t         fsgeo;
 828         int                     error;
 829
 830         error = xfs_fs_geometry(mp, &fsgeo, 4);
 831         if (error)
 832                 return error;
 833
 834         if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
 835                 return -EFAULT;
 836         return 0;
 837 }
 838
 839 /*
 840  * Linux extended inode flags interface.
 841  */
 842
 843 STATIC unsigned int
 844 xfs_merge_ioc_xflags(
 845         unsigned int    flags,
 846         unsigned int    start)
 847 {
 848         unsigned int    xflags = start;
 849
 850         if (flags & FS_IMMUTABLE_FL)
 851                 xflags |= XFS_XFLAG_IMMUTABLE;
 852         else
 853                 xflags &= ~XFS_XFLAG_IMMUTABLE;
 854         if (flags & FS_APPEND_FL)
 855                 xflags |= XFS_XFLAG_APPEND;
 856         else
 857                 xflags &= ~XFS_XFLAG_APPEND;
 858         if (flags & FS_SYNC_FL)
 859                 xflags |= XFS_XFLAG_SYNC;
 860         else
 861                 xflags &= ~XFS_XFLAG_SYNC;
 862         if (flags & FS_NOATIME_FL)
 863                 xflags |= XFS_XFLAG_NOATIME;
 864         else
 865                 xflags &= ~XFS_XFLAG_NOATIME;
 866         if (flags & FS_NODUMP_FL)
 867                 xflags |= XFS_XFLAG_NODUMP;
 868         else
 869                 xflags &= ~XFS_XFLAG_NODUMP;
 870
 871         return xflags;
 872 }
 873
 874 STATIC unsigned int
 875 xfs_di2lxflags(
 876         __uint16_t      di_flags)
 877 {
 878         unsigned int    flags = 0;
 879
 880         if (di_flags & XFS_DIFLAG_IMMUTABLE)
 881                 flags |= FS_IMMUTABLE_FL;
 882         if (di_flags & XFS_DIFLAG_APPEND)
 883                 flags |= FS_APPEND_FL;
 884         if (di_flags & XFS_DIFLAG_SYNC)
 885                 flags |= FS_SYNC_FL;
 886         if (di_flags & XFS_DIFLAG_NOATIME)
 887                 flags |= FS_NOATIME_FL;
 888         if (di_flags & XFS_DIFLAG_NODUMP)
 889                 flags |= FS_NODUMP_FL;
 890         return flags;
 891 }
 892
 893 STATIC int
 894 xfs_ioc_fsgetxattr(
 895         xfs_inode_t             *ip,
 896         int                     attr,
 897         void                    __user *arg)
 898 {
 899         struct fsxattr          fa;
 900
 901         memset(&fa, 0, sizeof(struct fsxattr));
 902
 903         xfs_ilock(ip, XFS_ILOCK_SHARED);
 904         fa.fsx_xflags = xfs_ip2xflags(ip);
 905         fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
 906         fa.fsx_projid = xfs_get_projid(ip);
 907
 908         if (attr) {
 909                 if (ip->i_afp) {
 910                         if (ip->i_afp->if_flags & XFS_IFEXTENTS)
 911                                 fa.fsx_nextents = ip->i_afp->if_bytes /
 912                                                         sizeof(xfs_bmbt_rec_t);
 913                         else
 914                                 fa.fsx_nextents = ip->i_d.di_anextents;
 915                 } else
 916                         fa.fsx_nextents = 0;
 917         } else {
 918                 if (ip->i_df.if_flags & XFS_IFEXTENTS)
 919                         fa.fsx_nextents = ip->i_df.if_bytes /
 920                                                 sizeof(xfs_bmbt_rec_t);
 921                 else
 922                         fa.fsx_nextents = ip->i_d.di_nextents;
 923         }
 924         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 925
 926         if (copy_to_user(arg, &fa, sizeof(fa)))
 927                 return -EFAULT;
 928         return 0;
 929 }
 930
 931 STATIC void
 932 xfs_set_diflags(
 933         struct xfs_inode        *ip,
 934         unsigned int            xflags)
 935 {
 936         unsigned int            di_flags;
 937
 938         /* can't set PREALLOC this way, just preserve it */
 939         di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
 940         if (xflags & XFS_XFLAG_IMMUTABLE)
 941                 di_flags |= XFS_DIFLAG_IMMUTABLE;
 942         if (xflags & XFS_XFLAG_APPEND)
 943                 di_flags |= XFS_DIFLAG_APPEND;
 944         if (xflags & XFS_XFLAG_SYNC)
 945                 di_flags |= XFS_DIFLAG_SYNC;
 946         if (xflags & XFS_XFLAG_NOATIME)
 947                 di_flags |= XFS_DIFLAG_NOATIME;
 948         if (xflags & XFS_XFLAG_NODUMP)
 949                 di_flags |= XFS_DIFLAG_NODUMP;
 950         if (xflags & XFS_XFLAG_NODEFRAG)
 951                 di_flags |= XFS_DIFLAG_NODEFRAG;
 952         if (xflags & XFS_XFLAG_FILESTREAM)
 953                 di_flags |= XFS_DIFLAG_FILESTREAM;
 954         if (S_ISDIR(ip->i_d.di_mode)) {
 955                 if (xflags & XFS_XFLAG_RTINHERIT)
 956                         di_flags |= XFS_DIFLAG_RTINHERIT;
 957                 if (xflags & XFS_XFLAG_NOSYMLINKS)
 958                         di_flags |= XFS_DIFLAG_NOSYMLINKS;
 959                 if (xflags & XFS_XFLAG_EXTSZINHERIT)
 960                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
 961                 if (xflags & XFS_XFLAG_PROJINHERIT)
 962                         di_flags |= XFS_DIFLAG_PROJINHERIT;
 963         } else if (S_ISREG(ip->i_d.di_mode)) {
 964                 if (xflags & XFS_XFLAG_REALTIME)
 965                         di_flags |= XFS_DIFLAG_REALTIME;
 966                 if (xflags & XFS_XFLAG_EXTSIZE)
 967                         di_flags |= XFS_DIFLAG_EXTSIZE;
 968         }
 969
 970         ip->i_d.di_flags = di_flags;
 971 }
 972
 973 STATIC void
 974 xfs_diflags_to_linux(
 975         struct xfs_inode        *ip)
 976 {
 977         struct inode            *inode = VFS_I(ip);
 978         unsigned int            xflags = xfs_ip2xflags(ip);
 979
 980         if (xflags & XFS_XFLAG_IMMUTABLE)
 981                 inode->i_flags |= S_IMMUTABLE;
 982         else
 983                 inode->i_flags &= ~S_IMMUTABLE;
 984         if (xflags & XFS_XFLAG_APPEND)
 985                 inode->i_flags |= S_APPEND;
 986         else
 987                 inode->i_flags &= ~S_APPEND;
 988         if (xflags & XFS_XFLAG_SYNC)
 989                 inode->i_flags |= S_SYNC;
 990         else
 991                 inode->i_flags &= ~S_SYNC;
 992         if (xflags & XFS_XFLAG_NOATIME)
 993                 inode->i_flags |= S_NOATIME;
 994         else
 995                 inode->i_flags &= ~S_NOATIME;
 996 }
 997
 998 static int
 999 xfs_ioctl_setattr_xflags(
1000         struct xfs_trans        *tp,
1001         struct xfs_inode        *ip,
1002         struct fsxattr          *fa)
1003 {
1004         struct xfs_mount        *mp = ip->i_mount;
1005
1006         /* Can't change realtime flag if any extents are allocated. */
1007         if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1008             XFS_IS_REALTIME_INODE(ip) != (fa->fsx_xflags & XFS_XFLAG_REALTIME))
1009                 return -EINVAL;
1010
1011         /* If realtime flag is set then must have realtime device */
1012         if (fa->fsx_xflags & XFS_XFLAG_REALTIME) {
1013                 if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
1014                     (ip->i_d.di_extsize % mp->m_sb.sb_rextsize))
1015                         return -EINVAL;
1016         }
1017
1018         /*
1019          * Can't modify an immutable/append-only file unless
1020          * we have appropriate permission.
1021          */
1022         if (((ip->i_d.di_flags & (XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND)) ||
1023              (fa->fsx_xflags & (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
1024             !capable(CAP_LINUX_IMMUTABLE))
1025                 return -EPERM;
1026
1027         xfs_set_diflags(ip, fa->fsx_xflags);
1028         xfs_diflags_to_linux(ip);
1029         xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1030         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1031         XFS_STATS_INC(xs_ig_attrchg);
1032         return 0;
1033 }
1034
1035 /*
1036  * Set up the transaction structure for the setattr operation, checking that we
1037  * have permission to do so. On success, return a clean transaction and the
1038  * inode locked exclusively ready for further operation specific checks. On
1039  * failure, return an error without modifying or locking the inode.
1040  */
1041 static struct xfs_trans *
1042 xfs_ioctl_setattr_get_trans(
1043         struct xfs_inode        *ip)
1044 {
1045         struct xfs_mount        *mp = ip->i_mount;
1046         struct xfs_trans        *tp;
1047         int                     error;
1048
1049         if (mp->m_flags & XFS_MOUNT_RDONLY)
1050                 return ERR_PTR(-EROFS);
1051         if (XFS_FORCED_SHUTDOWN(mp))
1052                 return ERR_PTR(-EIO);
1053
1054         tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
1055         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
1056         if (error)
1057                 goto out_cancel;
1058
1059         xfs_ilock(ip, XFS_ILOCK_EXCL);
1060         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1061
1062         /*
1063          * CAP_FOWNER overrides the following restrictions:
1064          *
1065          * The user ID of the calling process must be equal to the file owner
1066          * ID, except in cases where the CAP_FSETID capability is applicable.
1067          */
1068         if (!inode_owner_or_capable(VFS_I(ip))) {
1069                 error = -EPERM;
1070                 goto out_cancel;
1071         }
1072
1073         if (mp->m_flags & XFS_MOUNT_WSYNC)
1074                 xfs_trans_set_sync(tp);
1075
1076         return tp;
1077
1078 out_cancel:
1079         xfs_trans_cancel(tp, 0);
1080         return ERR_PTR(error);
1081 }
1082
1083 /*
1084  * extent size hint validation is somewhat cumbersome. Rules are:
1085  *
1086  * 1. extent size hint is only valid for directories and regular files
1087  * 2. XFS_XFLAG_EXTSIZE is only valid for regular files
1088  * 3. XFS_XFLAG_EXTSZINHERIT is only valid for directories.
1089  * 4. can only be changed on regular files if no extents are allocated
1090  * 5. can be changed on directories at any time
1091  * 6. extsize hint of 0 turns off hints, clears inode flags.
1092  * 7. Extent size must be a multiple of the appropriate block size.
1093  * 8. for non-realtime files, the extent size hint must be limited
1094  *    to half the AG size to avoid alignment extending the extent beyond the
1095  *    limits of the AG.
1096  */
1097 static int
1098 xfs_ioctl_setattr_check_extsize(
1099         struct xfs_inode        *ip,
1100         struct fsxattr          *fa)
1101 {
1102         struct xfs_mount        *mp = ip->i_mount;
1103
1104         if ((fa->fsx_xflags & XFS_XFLAG_EXTSIZE) && !S_ISREG(ip->i_d.di_mode))
1105                 return -EINVAL;
1106
1107         if ((fa->fsx_xflags & XFS_XFLAG_EXTSZINHERIT) &&
1108             !S_ISDIR(ip->i_d.di_mode))
1109                 return -EINVAL;
1110
1111         if (S_ISREG(ip->i_d.di_mode) && ip->i_d.di_nextents &&
1112             ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) != fa->fsx_extsize))
1113                 return -EINVAL;
1114
1115         if (fa->fsx_extsize != 0) {
1116                 xfs_extlen_t    size;
1117                 xfs_fsblock_t   extsize_fsb;
1118
1119                 extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
1120                 if (extsize_fsb > MAXEXTLEN)
1121                         return -EINVAL;
1122
1123                 if (XFS_IS_REALTIME_INODE(ip) ||
1124                     (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1125                         size = mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog;
1126                 } else {
1127                         size = mp->m_sb.sb_blocksize;
1128                         if (extsize_fsb > mp->m_sb.sb_agblocks / 2)
1129                                 return -EINVAL;
1130                 }
1131
1132                 if (fa->fsx_extsize % size)
1133                         return -EINVAL;
1134         } else
1135                 fa->fsx_xflags &= ~(XFS_XFLAG_EXTSIZE | XFS_XFLAG_EXTSZINHERIT);
1136
1137         return 0;
1138 }
1139
1140 static int
1141 xfs_ioctl_setattr_check_projid(
1142         struct xfs_inode        *ip,
1143         struct fsxattr          *fa)
1144 {
1145         /* Disallow 32bit project ids if projid32bit feature is not enabled. */
1146         if (fa->fsx_projid > (__uint16_t)-1 &&
1147             !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
1148                 return -EINVAL;
1149
1150         /*
1151          * Project Quota ID state is only allowed to change from within the init
1152          * namespace. Enforce that restriction only if we are trying to change
1153          * the quota ID state. Everything else is allowed in user namespaces.
1154          */
1155         if (current_user_ns() == &init_user_ns)
1156                 return 0;
1157
1158         if (xfs_get_projid(ip) != fa->fsx_projid)
1159                 return -EINVAL;
1160         if ((fa->fsx_xflags & XFS_XFLAG_PROJINHERIT) !=
1161             (ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT))
1162                 return -EINVAL;
1163
1164         return 0;
1165 }
1166
1167 STATIC int
1168 xfs_ioctl_setattr(
1169         xfs_inode_t             *ip,
1170         struct fsxattr          *fa)
1171 {
1172         struct xfs_mount        *mp = ip->i_mount;
1173         struct xfs_trans        *tp;
1174         struct xfs_dquot        *udqp = NULL;
1175         struct xfs_dquot        *pdqp = NULL;
1176         struct xfs_dquot        *olddquot = NULL;
1177         int                     code;
1178
1179         trace_xfs_ioctl_setattr(ip);
1180
1181         code = xfs_ioctl_setattr_check_projid(ip, fa);
1182         if (code)
1183                 return code;
1184
1185         /*
1186          * If disk quotas is on, we make sure that the dquots do exist on disk,
1187          * before we start any other transactions. Trying to do this later
1188          * is messy. We don't care to take a readlock to look at the ids
1189          * in inode here, because we can't hold it across the trans_reserve.
1190          * If the IDs do change before we take the ilock, we're covered
1191          * because the i_*dquot fields will get updated anyway.
1192          */
1193         if (XFS_IS_QUOTA_ON(mp)) {
1194                 code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,
1195                                          ip->i_d.di_gid, fa->fsx_projid,
1196                                          XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);
1197                 if (code)
1198                         return code;
1199         }
1200
1201         tp = xfs_ioctl_setattr_get_trans(ip);
1202         if (IS_ERR(tp)) {
1203                 code = PTR_ERR(tp);
1204                 goto error_free_dquots;
1205         }
1206
1207
1208         if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp) &&
1209             xfs_get_projid(ip) != fa->fsx_projid) {
1210                 code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL, pdqp,
1211                                 capable(CAP_FOWNER) ?  XFS_QMOPT_FORCE_RES : 0);
1212                 if (code)       /* out of quota */
1213                         goto error_trans_cancel;
1214         }
1215
1216         code = xfs_ioctl_setattr_check_extsize(ip, fa);
1217         if (code)
1218                 goto error_trans_cancel;
1219
1220         code = xfs_ioctl_setattr_xflags(tp, ip, fa);
1221         if (code)
1222                 goto error_trans_cancel;
1223
1224         /*
1225          * Change file ownership.  Must be the owner or privileged.  CAP_FSETID
1226          * overrides the following restrictions:
1227          *
1228          * The set-user-ID and set-group-ID bits of a file will be cleared upon
1229          * successful return from chown()
1230          */
1231
1232         if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
1233             !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID))
1234                 ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
1235
1236         /* Change the ownerships and register project quota modifications */
1237         if (xfs_get_projid(ip) != fa->fsx_projid) {
1238                 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {
1239                         olddquot = xfs_qm_vop_chown(tp, ip,
1240                                                 &ip->i_pdquot, pdqp);
1241                 }
1242                 ASSERT(ip->i_d.di_version > 1);
1243                 xfs_set_projid(ip, fa->fsx_projid);
1244         }
1245
1246         /*
1247          * Only set the extent size hint if we've already determined that the
1248          * extent size hint should be set on the inode. If no extent size flags
1249          * are set on the inode then unconditionally clear the extent size hint.
1250          */
1251         if (ip->i_d.di_flags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
1252                 ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1253         else
1254                 ip->i_d.di_extsize = 0;
1255
1256         code = xfs_trans_commit(tp, 0);
1257
1258         /*
1259          * Release any dquot(s) the inode had kept before chown.
1260          */
1261         xfs_qm_dqrele(olddquot);
1262         xfs_qm_dqrele(udqp);
1263         xfs_qm_dqrele(pdqp);
1264
1265         return code;
1266
1267 error_trans_cancel:
1268         xfs_trans_cancel(tp, 0);
1269 error_free_dquots:
1270         xfs_qm_dqrele(udqp);
1271         xfs_qm_dqrele(pdqp);
1272         return code;
1273 }
1274
1275 STATIC int
1276 xfs_ioc_fssetxattr(
1277         xfs_inode_t             *ip,
1278         struct file             *filp,
1279         void                    __user *arg)
1280 {
1281         struct fsxattr          fa;
1282         int error;
1283
1284         if (copy_from_user(&fa, arg, sizeof(fa)))
1285                 return -EFAULT;
1286
1287         error = mnt_want_write_file(filp);
1288         if (error)
1289                 return error;
1290         error = xfs_ioctl_setattr(ip, &fa);
1291         mnt_drop_write_file(filp);
1292         return error;
1293 }
1294
1295 STATIC int
1296 xfs_ioc_getxflags(
1297         xfs_inode_t             *ip,
1298         void                    __user *arg)
1299 {
1300         unsigned int            flags;
1301
1302         flags = xfs_di2lxflags(ip->i_d.di_flags);
1303         if (copy_to_user(arg, &flags, sizeof(flags)))
1304                 return -EFAULT;
1305         return 0;
1306 }
1307
1308 STATIC int
1309 xfs_ioc_setxflags(
1310         struct xfs_inode        *ip,
1311         struct file             *filp,
1312         void                    __user *arg)
1313 {
1314         struct xfs_trans        *tp;
1315         struct fsxattr          fa;
1316         unsigned int            flags;
1317         int                     error;
1318
1319         if (copy_from_user(&flags, arg, sizeof(flags)))
1320                 return -EFAULT;
1321
1322         if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1323                       FS_NOATIME_FL | FS_NODUMP_FL | \
1324                       FS_SYNC_FL))
1325                 return -EOPNOTSUPP;
1326
1327         fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
1328
1329         error = mnt_want_write_file(filp);
1330         if (error)
1331                 return error;
1332
1333         tp = xfs_ioctl_setattr_get_trans(ip);
1334         if (IS_ERR(tp)) {
1335                 error = PTR_ERR(tp);
1336                 goto out_drop_write;
1337         }
1338
1339         error = xfs_ioctl_setattr_xflags(tp, ip, &fa);
1340         if (error) {
1341                 xfs_trans_cancel(tp, 0);
1342                 goto out_drop_write;
1343         }
1344
1345         error = xfs_trans_commit(tp, 0);
1346 out_drop_write:
1347         mnt_drop_write_file(filp);
1348         return error;
1349 }
1350
1351 STATIC int
1352 xfs_getbmap_format(void **ap, struct getbmapx *bmv, int *full)
1353 {
1354         struct getbmap __user   *base = (struct getbmap __user *)*ap;
1355
1356         /* copy only getbmap portion (not getbmapx) */
1357         if (copy_to_user(base, bmv, sizeof(struct getbmap)))
1358                 return -EFAULT;
1359
1360         *ap += sizeof(struct getbmap);
1361         return 0;
1362 }
1363
1364 STATIC int
1365 xfs_ioc_getbmap(
1366         struct xfs_inode        *ip,
1367         int                     ioflags,
1368         unsigned int            cmd,
1369         void                    __user *arg)
1370 {
1371         struct getbmapx         bmx;
1372         int                     error;
1373
1374         if (copy_from_user(&bmx, arg, sizeof(struct getbmapx)))
1375                 return -EFAULT;
1376
1377         if (bmx.bmv_count < 2)
1378                 return -EINVAL;
1379
1380         bmx.bmv_iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1381         if (ioflags & XFS_IO_INVIS)
1382                 bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
1383
1384         error = xfs_getbmap(ip, &bmx, xfs_getbmap_format,
1385                             (__force struct getbmap *)arg+1);
1386         if (error)
1387                 return error;
1388
1389         /* copy back header - only size of getbmap */
1390         if (copy_to_user(arg, &bmx, sizeof(struct getbmap)))
1391                 return -EFAULT;
1392         return 0;
1393 }
1394
1395 STATIC int
1396 xfs_getbmapx_format(void **ap, struct getbmapx *bmv, int *full)
1397 {
1398         struct getbmapx __user  *base = (struct getbmapx __user *)*ap;
1399
1400         if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
1401                 return -EFAULT;
1402
1403         *ap += sizeof(struct getbmapx);
1404         return 0;
1405 }
1406
1407 STATIC int
1408 xfs_ioc_getbmapx(
1409         struct xfs_inode        *ip,
1410         void                    __user *arg)
1411 {
1412         struct getbmapx         bmx;
1413         int                     error;
1414
1415         if (copy_from_user(&bmx, arg, sizeof(bmx)))
1416                 return -EFAULT;
1417
1418         if (bmx.bmv_count < 2)
1419                 return -EINVAL;
1420
1421         if (bmx.bmv_iflags & (~BMV_IF_VALID))
1422                 return -EINVAL;
1423
1424         error = xfs_getbmap(ip, &bmx, xfs_getbmapx_format,
1425                             (__force struct getbmapx *)arg+1);
1426         if (error)
1427                 return error;
1428
1429         /* copy back header */
1430         if (copy_to_user(arg, &bmx, sizeof(struct getbmapx)))
1431                 return -EFAULT;
1432
1433         return 0;
1434 }
1435
1436 int
1437 xfs_ioc_swapext(
1438         xfs_swapext_t   *sxp)
1439 {
1440         xfs_inode_t     *ip, *tip;
1441         struct fd       f, tmp;
1442         int             error = 0;
1443
1444         /* Pull information for the target fd */
1445         f = fdget((int)sxp->sx_fdtarget);
1446         if (!f.file) {
1447                 error = -EINVAL;
1448                 goto out;
1449         }
1450
1451         if (!(f.file->f_mode & FMODE_WRITE) ||
1452             !(f.file->f_mode & FMODE_READ) ||
1453             (f.file->f_flags & O_APPEND)) {
1454                 error = -EBADF;
1455                 goto out_put_file;
1456         }
1457
1458         tmp = fdget((int)sxp->sx_fdtmp);
1459         if (!tmp.file) {
1460                 error = -EINVAL;
1461                 goto out_put_file;
1462         }
1463
1464         if (!(tmp.file->f_mode & FMODE_WRITE) ||
1465             !(tmp.file->f_mode & FMODE_READ) ||
1466             (tmp.file->f_flags & O_APPEND)) {
1467                 error = -EBADF;
1468                 goto out_put_tmp_file;
1469         }
1470
1471         if (IS_SWAPFILE(file_inode(f.file)) ||
1472             IS_SWAPFILE(file_inode(tmp.file))) {
1473                 error = -EINVAL;
1474                 goto out_put_tmp_file;
1475         }
1476
1477         ip = XFS_I(file_inode(f.file));
1478         tip = XFS_I(file_inode(tmp.file));
1479
1480         if (ip->i_mount != tip->i_mount) {
1481                 error = -EINVAL;
1482                 goto out_put_tmp_file;
1483         }
1484
1485         if (ip->i_ino == tip->i_ino) {
1486                 error = -EINVAL;
1487                 goto out_put_tmp_file;
1488         }
1489
1490         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1491                 error = -EIO;
1492                 goto out_put_tmp_file;
1493         }
1494
1495         error = xfs_swap_extents(ip, tip, sxp);
1496
1497  out_put_tmp_file:
1498         fdput(tmp);
1499  out_put_file:
1500         fdput(f);
1501  out:
1502         return error;
1503 }
1504
1505 /*
1506  * Note: some of the ioctl's return positive numbers as a
1507  * byte count indicating success, such as readlink_by_handle.
1508  * So we don't "sign flip" like most other routines.  This means
1509  * true errors need to be returned as a negative value.
1510  */
1511 long
1512 xfs_file_ioctl(
1513         struct file             *filp,
1514         unsigned int            cmd,
1515         unsigned long           p)
1516 {
1517         struct inode            *inode = file_inode(filp);
1518         struct xfs_inode        *ip = XFS_I(inode);
1519         struct xfs_mount        *mp = ip->i_mount;
1520         void                    __user *arg = (void __user *)p;
1521         int                     ioflags = 0;
1522         int                     error;
1523
1524         if (filp->f_mode & FMODE_NOCMTIME)
1525                 ioflags |= XFS_IO_INVIS;
1526
1527         trace_xfs_file_ioctl(ip);
1528
1529         switch (cmd) {
1530         case FITRIM:
1531                 return xfs_ioc_trim(mp, arg);
1532         case XFS_IOC_ALLOCSP:
1533         case XFS_IOC_FREESP:
1534         case XFS_IOC_RESVSP:
1535         case XFS_IOC_UNRESVSP:
1536         case XFS_IOC_ALLOCSP64:
1537         case XFS_IOC_FREESP64:
1538         case XFS_IOC_RESVSP64:
1539         case XFS_IOC_UNRESVSP64:
1540         case XFS_IOC_ZERO_RANGE: {
1541                 xfs_flock64_t           bf;
1542
1543                 if (copy_from_user(&bf, arg, sizeof(bf)))
1544                         return -EFAULT;
1545                 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
1546         }
1547         case XFS_IOC_DIOINFO: {
1548                 struct dioattr  da;
1549                 xfs_buftarg_t   *target =
1550                         XFS_IS_REALTIME_INODE(ip) ?
1551                         mp->m_rtdev_targp : mp->m_ddev_targp;
1552
1553                 da.d_mem =  da.d_miniosz = target->bt_logical_sectorsize;
1554                 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1555
1556                 if (copy_to_user(arg, &da, sizeof(da)))
1557                         return -EFAULT;
1558                 return 0;
1559         }
1560
1561         case XFS_IOC_FSBULKSTAT_SINGLE:
1562         case XFS_IOC_FSBULKSTAT:
1563         case XFS_IOC_FSINUMBERS:
1564                 return xfs_ioc_bulkstat(mp, cmd, arg);
1565
1566         case XFS_IOC_FSGEOMETRY_V1:
1567                 return xfs_ioc_fsgeometry_v1(mp, arg);
1568
1569         case XFS_IOC_FSGEOMETRY:
1570                 return xfs_ioc_fsgeometry(mp, arg);
1571
1572         case XFS_IOC_GETVERSION:
1573                 return put_user(inode->i_generation, (int __user *)arg);
1574
1575         case XFS_IOC_FSGETXATTR:
1576                 return xfs_ioc_fsgetxattr(ip, 0, arg);
1577         case XFS_IOC_FSGETXATTRA:
1578                 return xfs_ioc_fsgetxattr(ip, 1, arg);
1579         case XFS_IOC_FSSETXATTR:
1580                 return xfs_ioc_fssetxattr(ip, filp, arg);
1581         case XFS_IOC_GETXFLAGS:
1582                 return xfs_ioc_getxflags(ip, arg);
1583         case XFS_IOC_SETXFLAGS:
1584                 return xfs_ioc_setxflags(ip, filp, arg);
1585
1586         case XFS_IOC_FSSETDM: {
1587                 struct fsdmidata        dmi;
1588
1589                 if (copy_from_user(&dmi, arg, sizeof(dmi)))
1590                         return -EFAULT;
1591
1592                 error = mnt_want_write_file(filp);
1593                 if (error)
1594                         return error;
1595
1596                 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1597                                 dmi.fsd_dmstate);
1598                 mnt_drop_write_file(filp);
1599                 return error;
1600         }
1601
1602         case XFS_IOC_GETBMAP:
1603         case XFS_IOC_GETBMAPA:
1604                 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1605
1606         case XFS_IOC_GETBMAPX:
1607                 return xfs_ioc_getbmapx(ip, arg);
1608
1609         case XFS_IOC_FD_TO_HANDLE:
1610         case XFS_IOC_PATH_TO_HANDLE:
1611         case XFS_IOC_PATH_TO_FSHANDLE: {
1612                 xfs_fsop_handlereq_t    hreq;
1613
1614                 if (copy_from_user(&hreq, arg, sizeof(hreq)))
1615                         return -EFAULT;
1616                 return xfs_find_handle(cmd, &hreq);
1617         }
1618         case XFS_IOC_OPEN_BY_HANDLE: {
1619                 xfs_fsop_handlereq_t    hreq;
1620
1621                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1622                         return -EFAULT;
1623                 return xfs_open_by_handle(filp, &hreq);
1624         }
1625         case XFS_IOC_FSSETDM_BY_HANDLE:
1626                 return xfs_fssetdm_by_handle(filp, arg);
1627
1628         case XFS_IOC_READLINK_BY_HANDLE: {
1629                 xfs_fsop_handlereq_t    hreq;
1630
1631                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1632                         return -EFAULT;
1633                 return xfs_readlink_by_handle(filp, &hreq);
1634         }
1635         case XFS_IOC_ATTRLIST_BY_HANDLE:
1636                 return xfs_attrlist_by_handle(filp, arg);
1637
1638         case XFS_IOC_ATTRMULTI_BY_HANDLE:
1639                 return xfs_attrmulti_by_handle(filp, arg);
1640
1641         case XFS_IOC_SWAPEXT: {
1642                 struct xfs_swapext      sxp;
1643
1644                 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
1645                         return -EFAULT;
1646                 error = mnt_want_write_file(filp);
1647                 if (error)
1648                         return error;
1649                 error = xfs_ioc_swapext(&sxp);
1650                 mnt_drop_write_file(filp);
1651                 return error;
1652         }
1653
1654         case XFS_IOC_FSCOUNTS: {
1655                 xfs_fsop_counts_t out;
1656
1657                 error = xfs_fs_counts(mp, &out);
1658                 if (error)
1659                         return error;
1660
1661                 if (copy_to_user(arg, &out, sizeof(out)))
1662                         return -EFAULT;
1663                 return 0;
1664         }
1665
1666         case XFS_IOC_SET_RESBLKS: {
1667                 xfs_fsop_resblks_t inout;
1668                 __uint64_t         in;
1669
1670                 if (!capable(CAP_SYS_ADMIN))
1671                         return -EPERM;
1672
1673                 if (mp->m_flags & XFS_MOUNT_RDONLY)
1674                         return -EROFS;
1675
1676                 if (copy_from_user(&inout, arg, sizeof(inout)))
1677                         return -EFAULT;
1678
1679                 error = mnt_want_write_file(filp);
1680                 if (error)
1681                         return error;
1682
1683                 /* input parameter is passed in resblks field of structure */
1684                 in = inout.resblks;
1685                 error = xfs_reserve_blocks(mp, &in, &inout);
1686                 mnt_drop_write_file(filp);
1687                 if (error)
1688                         return error;
1689
1690                 if (copy_to_user(arg, &inout, sizeof(inout)))
1691                         return -EFAULT;
1692                 return 0;
1693         }
1694
1695         case XFS_IOC_GET_RESBLKS: {
1696                 xfs_fsop_resblks_t out;
1697
1698                 if (!capable(CAP_SYS_ADMIN))
1699                         return -EPERM;
1700
1701                 error = xfs_reserve_blocks(mp, NULL, &out);
1702                 if (error)
1703                         return error;
1704
1705                 if (copy_to_user(arg, &out, sizeof(out)))
1706                         return -EFAULT;
1707
1708                 return 0;
1709         }
1710
1711         case XFS_IOC_FSGROWFSDATA: {
1712                 xfs_growfs_data_t in;
1713
1714                 if (copy_from_user(&in, arg, sizeof(in)))
1715                         return -EFAULT;
1716
1717                 error = mnt_want_write_file(filp);
1718                 if (error)
1719                         return error;
1720                 error = xfs_growfs_data(mp, &in);
1721                 mnt_drop_write_file(filp);
1722                 return error;
1723         }
1724
1725         case XFS_IOC_FSGROWFSLOG: {
1726                 xfs_growfs_log_t in;
1727
1728                 if (copy_from_user(&in, arg, sizeof(in)))
1729                         return -EFAULT;
1730
1731                 error = mnt_want_write_file(filp);
1732                 if (error)
1733                         return error;
1734                 error = xfs_growfs_log(mp, &in);
1735                 mnt_drop_write_file(filp);
1736                 return error;
1737         }
1738
1739         case XFS_IOC_FSGROWFSRT: {
1740                 xfs_growfs_rt_t in;
1741
1742                 if (copy_from_user(&in, arg, sizeof(in)))
1743                         return -EFAULT;
1744
1745                 error = mnt_want_write_file(filp);
1746                 if (error)
1747                         return error;
1748                 error = xfs_growfs_rt(mp, &in);
1749                 mnt_drop_write_file(filp);
1750                 return error;
1751         }
1752
1753         case XFS_IOC_GOINGDOWN: {
1754                 __uint32_t in;
1755
1756                 if (!capable(CAP_SYS_ADMIN))
1757                         return -EPERM;
1758
1759                 if (get_user(in, (__uint32_t __user *)arg))
1760                         return -EFAULT;
1761
1762                 return xfs_fs_goingdown(mp, in);
1763         }
1764
1765         case XFS_IOC_ERROR_INJECTION: {
1766                 xfs_error_injection_t in;
1767
1768                 if (!capable(CAP_SYS_ADMIN))
1769                         return -EPERM;
1770
1771                 if (copy_from_user(&in, arg, sizeof(in)))
1772                         return -EFAULT;
1773
1774                 return xfs_errortag_add(in.errtag, mp);
1775         }
1776
1777         case XFS_IOC_ERROR_CLEARALL:
1778                 if (!capable(CAP_SYS_ADMIN))
1779                         return -EPERM;
1780
1781                 return xfs_errortag_clearall(mp, 1);
1782
1783         case XFS_IOC_FREE_EOFBLOCKS: {
1784                 struct xfs_fs_eofblocks eofb;
1785                 struct xfs_eofblocks keofb;
1786
1787                 if (!capable(CAP_SYS_ADMIN))
1788                         return -EPERM;
1789
1790                 if (mp->m_flags & XFS_MOUNT_RDONLY)
1791                         return -EROFS;
1792
1793                 if (copy_from_user(&eofb, arg, sizeof(eofb)))
1794                         return -EFAULT;
1795
1796                 error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
1797                 if (error)
1798                         return error;
1799
1800                 return xfs_icache_free_eofblocks(mp, &keofb);
1801         }
1802
1803         default:
1804                 return -ENOTTY;
1805         }
1806 }