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