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