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