fs/xfs/xfs_ioctl.c

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