fs/xfs/linux-2.6/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_bit.h"
  21 #include "xfs_log.h"
  22 #include "xfs_inum.h"
  23 #include "xfs_trans.h"
  24 #include "xfs_sb.h"
  25 #include "xfs_ag.h"
  26 #include "xfs_dir2.h"
  27 #include "xfs_alloc.h"
  28 #include "xfs_dmapi.h"
  29 #include "xfs_mount.h"
  30 #include "xfs_bmap_btree.h"
  31 #include "xfs_alloc_btree.h"
  32 #include "xfs_ialloc_btree.h"
  33 #include "xfs_attr_sf.h"
  34 #include "xfs_dir2_sf.h"
  35 #include "xfs_dinode.h"
  36 #include "xfs_inode.h"
  37 #include "xfs_btree.h"
  38 #include "xfs_ialloc.h"
  39 #include "xfs_rtalloc.h"
  40 #include "xfs_itable.h"
  41 #include "xfs_error.h"
  42 #include "xfs_rw.h"
  43 #include "xfs_acl.h"
  44 #include "xfs_attr.h"
  45 #include "xfs_bmap.h"
  46 #include "xfs_buf_item.h"
  47 #include "xfs_utils.h"
  48 #include "xfs_dfrag.h"
  49 #include "xfs_fsops.h"
  50 #include "xfs_vnodeops.h"
  51
  52 #include <linux/capability.h>
  53 #include <linux/dcache.h>
  54 #include <linux/mount.h>
  55 #include <linux/namei.h>
  56 #include <linux/pagemap.h>
  57
  58 /*
  59  * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
  60  * a file or fs handle.
  61  *
  62  * XFS_IOC_PATH_TO_FSHANDLE
  63  *    returns fs handle for a mount point or path within that mount point
  64  * XFS_IOC_FD_TO_HANDLE
  65  *    returns full handle for a FD opened in user space
  66  * XFS_IOC_PATH_TO_HANDLE
  67  *    returns full handle for a path
  68  */
  69 STATIC int
  70 xfs_find_handle(
  71         unsigned int            cmd,
  72         void                    __user *arg)
  73 {
  74         int                     hsize;
  75         xfs_handle_t            handle;
  76         xfs_fsop_handlereq_t    hreq;
  77         struct inode            *inode;
  78
  79         if (copy_from_user(&hreq, arg, sizeof(hreq)))
  80                 return -XFS_ERROR(EFAULT);
  81
  82         memset((char *)&handle, 0, sizeof(handle));
  83
  84         switch (cmd) {
  85         case XFS_IOC_PATH_TO_FSHANDLE:
  86         case XFS_IOC_PATH_TO_HANDLE: {
  87                 struct path path;
  88                 int error = user_lpath((const char __user *)hreq.path, &path);
  89                 if (error)
  90                         return error;
  91
  92                 ASSERT(path.dentry);
  93                 ASSERT(path.dentry->d_inode);
  94                 inode = igrab(path.dentry->d_inode);
  95                 path_put(&path);
  96                 break;
  97         }
  98
  99         case XFS_IOC_FD_TO_HANDLE: {
 100                 struct file     *file;
 101
 102                 file = fget(hreq.fd);
 103                 if (!file)
 104                     return -EBADF;
 105
 106                 ASSERT(file->f_path.dentry);
 107                 ASSERT(file->f_path.dentry->d_inode);
 108                 inode = igrab(file->f_path.dentry->d_inode);
 109                 fput(file);
 110                 break;
 111         }
 112
 113         default:
 114                 ASSERT(0);
 115                 return -XFS_ERROR(EINVAL);
 116         }
 117
 118         if (inode->i_sb->s_magic != XFS_SB_MAGIC) {
 119                 /* we're not in XFS anymore, Toto */
 120                 iput(inode);
 121                 return -XFS_ERROR(EINVAL);
 122         }
 123
 124         switch (inode->i_mode & S_IFMT) {
 125         case S_IFREG:
 126         case S_IFDIR:
 127         case S_IFLNK:
 128                 break;
 129         default:
 130                 iput(inode);
 131                 return -XFS_ERROR(EBADF);
 132         }
 133
 134         /* now we can grab the fsid */
 135         memcpy(&handle.ha_fsid, XFS_I(inode)->i_mount->m_fixedfsid,
 136                         sizeof(xfs_fsid_t));
 137         hsize = sizeof(xfs_fsid_t);
 138
 139         if (cmd != XFS_IOC_PATH_TO_FSHANDLE) {
 140                 xfs_inode_t     *ip = XFS_I(inode);
 141                 int             lock_mode;
 142
 143                 /* need to get access to the xfs_inode to read the generation */
 144                 lock_mode = xfs_ilock_map_shared(ip);
 145
 146                 /* fill in fid section of handle from inode */
 147                 handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
 148                                         sizeof(handle.ha_fid.fid_len);
 149                 handle.ha_fid.fid_pad = 0;
 150                 handle.ha_fid.fid_gen = ip->i_d.di_gen;
 151                 handle.ha_fid.fid_ino = ip->i_ino;
 152
 153                 xfs_iunlock_map_shared(ip, lock_mode);
 154
 155                 hsize = XFS_HSIZE(handle);
 156         }
 157
 158         /* now copy our handle into the user buffer & write out the size */
 159         if (copy_to_user(hreq.ohandle, &handle, hsize) ||
 160             copy_to_user(hreq.ohandlen, &hsize, sizeof(__s32))) {
 161                 iput(inode);
 162                 return -XFS_ERROR(EFAULT);
 163         }
 164
 165         iput(inode);
 166         return 0;
 167 }
 168
 169
 170 /*
 171  * Convert userspace handle data into inode.
 172  *
 173  * We use the fact that all the fsop_handlereq ioctl calls have a data
 174  * structure argument whose first component is always a xfs_fsop_handlereq_t,
 175  * so we can pass that sub structure into this handy, shared routine.
 176  *
 177  * If no error, caller must always iput the returned inode.
 178  */
 179 STATIC int
 180 xfs_vget_fsop_handlereq(
 181         xfs_mount_t             *mp,
 182         struct inode            *parinode,      /* parent inode pointer    */
 183         xfs_fsop_handlereq_t    *hreq,
 184         struct inode            **inode)
 185 {
 186         void                    __user *hanp;
 187         size_t                  hlen;
 188         xfs_fid_t               *xfid;
 189         xfs_handle_t            *handlep;
 190         xfs_handle_t            handle;
 191         xfs_inode_t             *ip;
 192         xfs_ino_t               ino;
 193         __u32                   igen;
 194         int                     error;
 195
 196         /*
 197          * Only allow handle opens under a directory.
 198          */
 199         if (!S_ISDIR(parinode->i_mode))
 200                 return XFS_ERROR(ENOTDIR);
 201
 202         hanp = hreq->ihandle;
 203         hlen = hreq->ihandlen;
 204         handlep = &handle;
 205
 206         if (hlen < sizeof(handlep->ha_fsid) || hlen > sizeof(*handlep))
 207                 return XFS_ERROR(EINVAL);
 208         if (copy_from_user(handlep, hanp, hlen))
 209                 return XFS_ERROR(EFAULT);
 210         if (hlen < sizeof(*handlep))
 211                 memset(((char *)handlep) + hlen, 0, sizeof(*handlep) - hlen);
 212         if (hlen > sizeof(handlep->ha_fsid)) {
 213                 if (handlep->ha_fid.fid_len !=
 214                     (hlen - sizeof(handlep->ha_fsid) -
 215                             sizeof(handlep->ha_fid.fid_len)) ||
 216                     handlep->ha_fid.fid_pad)
 217                         return XFS_ERROR(EINVAL);
 218         }
 219
 220         /*
 221          * Crack the handle, obtain the inode # & generation #
 222          */
 223         xfid = (struct xfs_fid *)&handlep->ha_fid;
 224         if (xfid->fid_len == sizeof(*xfid) - sizeof(xfid->fid_len)) {
 225                 ino  = xfid->fid_ino;
 226                 igen = xfid->fid_gen;
 227         } else {
 228                 return XFS_ERROR(EINVAL);
 229         }
 230
 231         /*
 232          * Get the XFS inode, building a Linux inode to go with it.
 233          */
 234         error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_SHARED, &ip, 0);
 235         if (error)
 236                 return error;
 237         if (ip == NULL)
 238                 return XFS_ERROR(EIO);
 239         if (ip->i_d.di_gen != igen) {
 240                 xfs_iput_new(ip, XFS_ILOCK_SHARED);
 241                 return XFS_ERROR(ENOENT);
 242         }
 243
 244         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 245
 246         *inode = XFS_ITOV(ip);
 247         return 0;
 248 }
 249
 250 STATIC int
 251 xfs_open_by_handle(
 252         xfs_mount_t             *mp,
 253         void                    __user *arg,
 254         struct file             *parfilp,
 255         struct inode            *parinode)
 256 {
 257         int                     error;
 258         int                     new_fd;
 259         int                     permflag;
 260         struct file             *filp;
 261         struct inode            *inode;
 262         struct dentry           *dentry;
 263         xfs_fsop_handlereq_t    hreq;
 264
 265         if (!capable(CAP_SYS_ADMIN))
 266                 return -XFS_ERROR(EPERM);
 267         if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
 268                 return -XFS_ERROR(EFAULT);
 269
 270         error = xfs_vget_fsop_handlereq(mp, parinode, &hreq, &inode);
 271         if (error)
 272                 return -error;
 273
 274         /* Restrict xfs_open_by_handle to directories & regular files. */
 275         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
 276                 iput(inode);
 277                 return -XFS_ERROR(EINVAL);
 278         }
 279
 280 #if BITS_PER_LONG != 32
 281         hreq.oflags |= O_LARGEFILE;
 282 #endif
 283         /* Put open permission in namei format. */
 284         permflag = hreq.oflags;
 285         if ((permflag+1) & O_ACCMODE)
 286                 permflag++;
 287         if (permflag & O_TRUNC)
 288                 permflag |= 2;
 289
 290         if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
 291             (permflag & FMODE_WRITE) && IS_APPEND(inode)) {
 292                 iput(inode);
 293                 return -XFS_ERROR(EPERM);
 294         }
 295
 296         if ((permflag & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
 297                 iput(inode);
 298                 return -XFS_ERROR(EACCES);
 299         }
 300
 301         /* Can't write directories. */
 302         if ( S_ISDIR(inode->i_mode) && (permflag & FMODE_WRITE)) {
 303                 iput(inode);
 304                 return -XFS_ERROR(EISDIR);
 305         }
 306
 307         if ((new_fd = get_unused_fd()) < 0) {
 308                 iput(inode);
 309                 return new_fd;
 310         }
 311
 312         dentry = d_alloc_anon(inode);
 313         if (dentry == NULL) {
 314                 iput(inode);
 315                 put_unused_fd(new_fd);
 316                 return -XFS_ERROR(ENOMEM);
 317         }
 318
 319         /* Ensure umount returns EBUSY on umounts while this file is open. */
 320         mntget(parfilp->f_path.mnt);
 321
 322         /* Create file pointer. */
 323         filp = dentry_open(dentry, parfilp->f_path.mnt, hreq.oflags);
 324         if (IS_ERR(filp)) {
 325                 put_unused_fd(new_fd);
 326                 return -XFS_ERROR(-PTR_ERR(filp));
 327         }
 328         if (inode->i_mode & S_IFREG) {
 329                 /* invisible operation should not change atime */
 330                 filp->f_flags |= O_NOATIME;
 331                 filp->f_op = &xfs_invis_file_operations;
 332         }
 333
 334         fd_install(new_fd, filp);
 335         return new_fd;
 336 }
 337
 338 /*
 339  * This is a copy from fs/namei.c:vfs_readlink(), except for removing it's
 340  * unused first argument.
 341  */
 342 STATIC int
 343 do_readlink(
 344         char __user             *buffer,
 345         int                     buflen,
 346         const char              *link)
 347 {
 348         int len;
 349
 350         len = PTR_ERR(link);
 351         if (IS_ERR(link))
 352                 goto out;
 353
 354         len = strlen(link);
 355         if (len > (unsigned) buflen)
 356                 len = buflen;
 357         if (copy_to_user(buffer, link, len))
 358                 len = -EFAULT;
 359  out:
 360         return len;
 361 }
 362
 363
 364 STATIC int
 365 xfs_readlink_by_handle(
 366         xfs_mount_t             *mp,
 367         void                    __user *arg,
 368         struct inode            *parinode)
 369 {
 370         struct inode            *inode;
 371         xfs_fsop_handlereq_t    hreq;
 372         __u32                   olen;
 373         void                    *link;
 374         int                     error;
 375
 376         if (!capable(CAP_SYS_ADMIN))
 377                 return -XFS_ERROR(EPERM);
 378         if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
 379                 return -XFS_ERROR(EFAULT);
 380
 381         error = xfs_vget_fsop_handlereq(mp, parinode, &hreq, &inode);
 382         if (error)
 383                 return -error;
 384
 385         /* Restrict this handle operation to symlinks only. */
 386         if (!S_ISLNK(inode->i_mode)) {
 387                 error = -XFS_ERROR(EINVAL);
 388                 goto out_iput;
 389         }
 390
 391         if (copy_from_user(&olen, hreq.ohandlen, sizeof(__u32))) {
 392                 error = -XFS_ERROR(EFAULT);
 393                 goto out_iput;
 394         }
 395
 396         link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
 397         if (!link)
 398                 goto out_iput;
 399
 400         error = -xfs_readlink(XFS_I(inode), link);
 401         if (error)
 402                 goto out_kfree;
 403         error = do_readlink(hreq.ohandle, olen, link);
 404         if (error)
 405                 goto out_kfree;
 406
 407  out_kfree:
 408         kfree(link);
 409  out_iput:
 410         iput(inode);
 411         return error;
 412 }
 413
 414 STATIC int
 415 xfs_fssetdm_by_handle(
 416         xfs_mount_t             *mp,
 417         void                    __user *arg,
 418         struct inode            *parinode)
 419 {
 420         int                     error;
 421         struct fsdmidata        fsd;
 422         xfs_fsop_setdm_handlereq_t dmhreq;
 423         struct inode            *inode;
 424
 425         if (!capable(CAP_MKNOD))
 426                 return -XFS_ERROR(EPERM);
 427         if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
 428                 return -XFS_ERROR(EFAULT);
 429
 430         error = xfs_vget_fsop_handlereq(mp, parinode, &dmhreq.hreq, &inode);
 431         if (error)
 432                 return -error;
 433
 434         if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {
 435                 error = -XFS_ERROR(EPERM);
 436                 goto out;
 437         }
 438
 439         if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
 440                 error = -XFS_ERROR(EFAULT);
 441                 goto out;
 442         }
 443
 444         error = -xfs_set_dmattrs(XFS_I(inode), fsd.fsd_dmevmask,
 445                                  fsd.fsd_dmstate);
 446
 447  out:
 448         iput(inode);
 449         return error;
 450 }
 451
 452 STATIC int
 453 xfs_attrlist_by_handle(
 454         xfs_mount_t             *mp,
 455         void                    __user *arg,
 456         struct inode            *parinode)
 457 {
 458         int                     error;
 459         attrlist_cursor_kern_t  *cursor;
 460         xfs_fsop_attrlist_handlereq_t al_hreq;
 461         struct inode            *inode;
 462         char                    *kbuf;
 463
 464         if (!capable(CAP_SYS_ADMIN))
 465                 return -XFS_ERROR(EPERM);
 466         if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
 467                 return -XFS_ERROR(EFAULT);
 468         if (al_hreq.buflen > XATTR_LIST_MAX)
 469                 return -XFS_ERROR(EINVAL);
 470
 471         /*
 472          * Reject flags, only allow namespaces.
 473          */
 474         if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
 475                 return -XFS_ERROR(EINVAL);
 476
 477         error = xfs_vget_fsop_handlereq(mp, parinode, &al_hreq.hreq, &inode);
 478         if (error)
 479                 goto out;
 480
 481         kbuf = kmalloc(al_hreq.buflen, GFP_KERNEL);
 482         if (!kbuf)
 483                 goto out_vn_rele;
 484
 485         cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
 486         error = xfs_attr_list(XFS_I(inode), kbuf, al_hreq.buflen,
 487                                         al_hreq.flags, cursor);
 488         if (error)
 489                 goto out_kfree;
 490
 491         if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
 492                 error = -EFAULT;
 493
 494  out_kfree:
 495         kfree(kbuf);
 496  out_vn_rele:
 497         iput(inode);
 498  out:
 499         return -error;
 500 }
 501
 502 STATIC int
 503 xfs_attrmulti_attr_get(
 504         struct inode            *inode,
 505         char                    *name,
 506         char                    __user *ubuf,
 507         __uint32_t              *len,
 508         __uint32_t              flags)
 509 {
 510         char                    *kbuf;
 511         int                     error = EFAULT;
 512
 513         if (*len > XATTR_SIZE_MAX)
 514                 return EINVAL;
 515         kbuf = kmalloc(*len, GFP_KERNEL);
 516         if (!kbuf)
 517                 return ENOMEM;
 518
 519         error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
 520         if (error)
 521                 goto out_kfree;
 522
 523         if (copy_to_user(ubuf, kbuf, *len))
 524                 error = EFAULT;
 525
 526  out_kfree:
 527         kfree(kbuf);
 528         return error;
 529 }
 530
 531 STATIC int
 532 xfs_attrmulti_attr_set(
 533         struct inode            *inode,
 534         char                    *name,
 535         const char              __user *ubuf,
 536         __uint32_t              len,
 537         __uint32_t              flags)
 538 {
 539         char                    *kbuf;
 540         int                     error = EFAULT;
 541
 542         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 543                 return EPERM;
 544         if (len > XATTR_SIZE_MAX)
 545                 return EINVAL;
 546
 547         kbuf = kmalloc(len, GFP_KERNEL);
 548         if (!kbuf)
 549                 return ENOMEM;
 550
 551         if (copy_from_user(kbuf, ubuf, len))
 552                 goto out_kfree;
 553
 554         error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
 555
 556  out_kfree:
 557         kfree(kbuf);
 558         return error;
 559 }
 560
 561 STATIC int
 562 xfs_attrmulti_attr_remove(
 563         struct inode            *inode,
 564         char                    *name,
 565         __uint32_t              flags)
 566 {
 567         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 568                 return EPERM;
 569         return xfs_attr_remove(XFS_I(inode), name, flags);
 570 }
 571
 572 STATIC int
 573 xfs_attrmulti_by_handle(
 574         xfs_mount_t             *mp,
 575         void                    __user *arg,
 576         struct file             *parfilp,
 577         struct inode            *parinode)
 578 {
 579         int                     error;
 580         xfs_attr_multiop_t      *ops;
 581         xfs_fsop_attrmulti_handlereq_t am_hreq;
 582         struct inode            *inode;
 583         unsigned int            i, size;
 584         char                    *attr_name;
 585
 586         if (!capable(CAP_SYS_ADMIN))
 587                 return -XFS_ERROR(EPERM);
 588         if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
 589                 return -XFS_ERROR(EFAULT);
 590
 591         error = xfs_vget_fsop_handlereq(mp, parinode, &am_hreq.hreq, &inode);
 592         if (error)
 593                 goto out;
 594
 595         error = E2BIG;
 596         size = am_hreq.opcount * sizeof(attr_multiop_t);
 597         if (!size || size > 16 * PAGE_SIZE)
 598                 goto out_vn_rele;
 599
 600         error = ENOMEM;
 601         ops = kmalloc(size, GFP_KERNEL);
 602         if (!ops)
 603                 goto out_vn_rele;
 604
 605         error = EFAULT;
 606         if (copy_from_user(ops, am_hreq.ops, size))
 607                 goto out_kfree_ops;
 608
 609         attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
 610         if (!attr_name)
 611                 goto out_kfree_ops;
 612
 613
 614         error = 0;
 615         for (i = 0; i < am_hreq.opcount; i++) {
 616                 ops[i].am_error = strncpy_from_user(attr_name,
 617                                 ops[i].am_attrname, MAXNAMELEN);
 618                 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
 619                         error = -ERANGE;
 620                 if (ops[i].am_error < 0)
 621                         break;
 622
 623                 switch (ops[i].am_opcode) {
 624                 case ATTR_OP_GET:
 625                         ops[i].am_error = xfs_attrmulti_attr_get(inode,
 626                                         attr_name, ops[i].am_attrvalue,
 627                                         &ops[i].am_length, ops[i].am_flags);
 628                         break;
 629                 case ATTR_OP_SET:
 630                         ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
 631                         if (ops[i].am_error)
 632                                 break;
 633                         ops[i].am_error = xfs_attrmulti_attr_set(inode,
 634                                         attr_name, ops[i].am_attrvalue,
 635                                         ops[i].am_length, ops[i].am_flags);
 636                         mnt_drop_write(parfilp->f_path.mnt);
 637                         break;
 638                 case ATTR_OP_REMOVE:
 639                         ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
 640                         if (ops[i].am_error)
 641                                 break;
 642                         ops[i].am_error = xfs_attrmulti_attr_remove(inode,
 643                                         attr_name, ops[i].am_flags);
 644                         mnt_drop_write(parfilp->f_path.mnt);
 645                         break;
 646                 default:
 647                         ops[i].am_error = EINVAL;
 648                 }
 649         }
 650
 651         if (copy_to_user(am_hreq.ops, ops, size))
 652                 error = XFS_ERROR(EFAULT);
 653
 654         kfree(attr_name);
 655  out_kfree_ops:
 656         kfree(ops);
 657  out_vn_rele:
 658         iput(inode);
 659  out:
 660         return -error;
 661 }
 662
 663 STATIC int
 664 xfs_ioc_space(
 665         struct xfs_inode        *ip,
 666         struct inode            *inode,
 667         struct file             *filp,
 668         int                     ioflags,
 669         unsigned int            cmd,
 670         void                    __user *arg)
 671 {
 672         xfs_flock64_t           bf;
 673         int                     attr_flags = 0;
 674         int                     error;
 675
 676         if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
 677                 return -XFS_ERROR(EPERM);
 678
 679         if (!(filp->f_mode & FMODE_WRITE))
 680                 return -XFS_ERROR(EBADF);
 681
 682         if (!S_ISREG(inode->i_mode))
 683                 return -XFS_ERROR(EINVAL);
 684
 685         if (copy_from_user(&bf, arg, sizeof(bf)))
 686                 return -XFS_ERROR(EFAULT);
 687
 688         if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
 689                 attr_flags |= ATTR_NONBLOCK;
 690         if (ioflags & IO_INVIS)
 691                 attr_flags |= ATTR_DMI;
 692
 693         error = xfs_change_file_space(ip, cmd, &bf, filp->f_pos,
 694                                               NULL, attr_flags);
 695         return -error;
 696 }
 697
 698 STATIC int
 699 xfs_ioc_bulkstat(
 700         xfs_mount_t             *mp,
 701         unsigned int            cmd,
 702         void                    __user *arg)
 703 {
 704         xfs_fsop_bulkreq_t      bulkreq;
 705         int                     count;  /* # of records returned */
 706         xfs_ino_t               inlast; /* last inode number */
 707         int                     done;
 708         int                     error;
 709
 710         /* done = 1 if there are more stats to get and if bulkstat */
 711         /* should be called again (unused here, but used in dmapi) */
 712
 713         if (!capable(CAP_SYS_ADMIN))
 714                 return -EPERM;
 715
 716         if (XFS_FORCED_SHUTDOWN(mp))
 717                 return -XFS_ERROR(EIO);
 718
 719         if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
 720                 return -XFS_ERROR(EFAULT);
 721
 722         if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
 723                 return -XFS_ERROR(EFAULT);
 724
 725         if ((count = bulkreq.icount) <= 0)
 726                 return -XFS_ERROR(EINVAL);
 727
 728         if (bulkreq.ubuffer == NULL)
 729                 return -XFS_ERROR(EINVAL);
 730
 731         if (cmd == XFS_IOC_FSINUMBERS)
 732                 error = xfs_inumbers(mp, &inlast, &count,
 733                                         bulkreq.ubuffer, xfs_inumbers_fmt);
 734         else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
 735                 error = xfs_bulkstat_single(mp, &inlast,
 736                                                 bulkreq.ubuffer, &done);
 737         else    /* XFS_IOC_FSBULKSTAT */
 738                 error = xfs_bulkstat(mp, &inlast, &count,
 739                         (bulkstat_one_pf)xfs_bulkstat_one, NULL,
 740                         sizeof(xfs_bstat_t), bulkreq.ubuffer,
 741                         BULKSTAT_FG_QUICK, &done);
 742
 743         if (error)
 744                 return -error;
 745
 746         if (bulkreq.ocount != NULL) {
 747                 if (copy_to_user(bulkreq.lastip, &inlast,
 748                                                 sizeof(xfs_ino_t)))
 749                         return -XFS_ERROR(EFAULT);
 750
 751                 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
 752                         return -XFS_ERROR(EFAULT);
 753         }
 754
 755         return 0;
 756 }
 757
 758 STATIC int
 759 xfs_ioc_fsgeometry_v1(
 760         xfs_mount_t             *mp,
 761         void                    __user *arg)
 762 {
 763         xfs_fsop_geom_v1_t      fsgeo;
 764         int                     error;
 765
 766         error = xfs_fs_geometry(mp, (xfs_fsop_geom_t *)&fsgeo, 3);
 767         if (error)
 768                 return -error;
 769
 770         if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
 771                 return -XFS_ERROR(EFAULT);
 772         return 0;
 773 }
 774
 775 STATIC int
 776 xfs_ioc_fsgeometry(
 777         xfs_mount_t             *mp,
 778         void                    __user *arg)
 779 {
 780         xfs_fsop_geom_t         fsgeo;
 781         int                     error;
 782
 783         error = xfs_fs_geometry(mp, &fsgeo, 4);
 784         if (error)
 785                 return -error;
 786
 787         if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
 788                 return -XFS_ERROR(EFAULT);
 789         return 0;
 790 }
 791
 792 /*
 793  * Linux extended inode flags interface.
 794  */
 795
 796 STATIC unsigned int
 797 xfs_merge_ioc_xflags(
 798         unsigned int    flags,
 799         unsigned int    start)
 800 {
 801         unsigned int    xflags = start;
 802
 803         if (flags & FS_IMMUTABLE_FL)
 804                 xflags |= XFS_XFLAG_IMMUTABLE;
 805         else
 806                 xflags &= ~XFS_XFLAG_IMMUTABLE;
 807         if (flags & FS_APPEND_FL)
 808                 xflags |= XFS_XFLAG_APPEND;
 809         else
 810                 xflags &= ~XFS_XFLAG_APPEND;
 811         if (flags & FS_SYNC_FL)
 812                 xflags |= XFS_XFLAG_SYNC;
 813         else
 814                 xflags &= ~XFS_XFLAG_SYNC;
 815         if (flags & FS_NOATIME_FL)
 816                 xflags |= XFS_XFLAG_NOATIME;
 817         else
 818                 xflags &= ~XFS_XFLAG_NOATIME;
 819         if (flags & FS_NODUMP_FL)
 820                 xflags |= XFS_XFLAG_NODUMP;
 821         else
 822                 xflags &= ~XFS_XFLAG_NODUMP;
 823
 824         return xflags;
 825 }
 826
 827 STATIC unsigned int
 828 xfs_di2lxflags(
 829         __uint16_t      di_flags)
 830 {
 831         unsigned int    flags = 0;
 832
 833         if (di_flags & XFS_DIFLAG_IMMUTABLE)
 834                 flags |= FS_IMMUTABLE_FL;
 835         if (di_flags & XFS_DIFLAG_APPEND)
 836                 flags |= FS_APPEND_FL;
 837         if (di_flags & XFS_DIFLAG_SYNC)
 838                 flags |= FS_SYNC_FL;
 839         if (di_flags & XFS_DIFLAG_NOATIME)
 840                 flags |= FS_NOATIME_FL;
 841         if (di_flags & XFS_DIFLAG_NODUMP)
 842                 flags |= FS_NODUMP_FL;
 843         return flags;
 844 }
 845
 846 STATIC int
 847 xfs_ioc_fsgetxattr(
 848         xfs_inode_t             *ip,
 849         int                     attr,
 850         void                    __user *arg)
 851 {
 852         struct fsxattr          fa;
 853
 854         xfs_ilock(ip, XFS_ILOCK_SHARED);
 855         fa.fsx_xflags = xfs_ip2xflags(ip);
 856         fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
 857         fa.fsx_projid = ip->i_d.di_projid;
 858
 859         if (attr) {
 860                 if (ip->i_afp) {
 861                         if (ip->i_afp->if_flags & XFS_IFEXTENTS)
 862                                 fa.fsx_nextents = ip->i_afp->if_bytes /
 863                                                         sizeof(xfs_bmbt_rec_t);
 864                         else
 865                                 fa.fsx_nextents = ip->i_d.di_anextents;
 866                 } else
 867                         fa.fsx_nextents = 0;
 868         } else {
 869                 if (ip->i_df.if_flags & XFS_IFEXTENTS)
 870                         fa.fsx_nextents = ip->i_df.if_bytes /
 871                                                 sizeof(xfs_bmbt_rec_t);
 872                 else
 873                         fa.fsx_nextents = ip->i_d.di_nextents;
 874         }
 875         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 876
 877         if (copy_to_user(arg, &fa, sizeof(fa)))
 878                 return -EFAULT;
 879         return 0;
 880 }
 881
 882 STATIC int
 883 xfs_ioc_fssetxattr(
 884         xfs_inode_t             *ip,
 885         struct file             *filp,
 886         void                    __user *arg)
 887 {
 888         struct fsxattr          fa;
 889         struct bhv_vattr        *vattr;
 890         int                     error;
 891         int                     attr_flags;
 892
 893         if (copy_from_user(&fa, arg, sizeof(fa)))
 894                 return -EFAULT;
 895
 896         vattr = kmalloc(sizeof(*vattr), GFP_KERNEL);
 897         if (unlikely(!vattr))
 898                 return -ENOMEM;
 899
 900         attr_flags = 0;
 901         if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
 902                 attr_flags |= ATTR_NONBLOCK;
 903
 904         vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | XFS_AT_PROJID;
 905         vattr->va_xflags  = fa.fsx_xflags;
 906         vattr->va_extsize = fa.fsx_extsize;
 907         vattr->va_projid  = fa.fsx_projid;
 908
 909         error = -xfs_setattr(ip, vattr, attr_flags, NULL);
 910         if (!error)
 911                 vn_revalidate(XFS_ITOV(ip));    /* update flags */
 912         kfree(vattr);
 913         return 0;
 914 }
 915
 916 STATIC int
 917 xfs_ioc_getxflags(
 918         xfs_inode_t             *ip,
 919         void                    __user *arg)
 920 {
 921         unsigned int            flags;
 922
 923         flags = xfs_di2lxflags(ip->i_d.di_flags);
 924         if (copy_to_user(arg, &flags, sizeof(flags)))
 925                 return -EFAULT;
 926         return 0;
 927 }
 928
 929 STATIC int
 930 xfs_ioc_setxflags(
 931         xfs_inode_t             *ip,
 932         struct file             *filp,
 933         void                    __user *arg)
 934 {
 935         struct bhv_vattr        *vattr;
 936         unsigned int            flags;
 937         int                     attr_flags;
 938         int                     error;
 939
 940         if (copy_from_user(&flags, arg, sizeof(flags)))
 941                 return -EFAULT;
 942
 943         if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
 944                       FS_NOATIME_FL | FS_NODUMP_FL | \
 945                       FS_SYNC_FL))
 946                 return -EOPNOTSUPP;
 947
 948         vattr = kmalloc(sizeof(*vattr), GFP_KERNEL);
 949         if (unlikely(!vattr))
 950                 return -ENOMEM;
 951
 952         attr_flags = 0;
 953         if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
 954                 attr_flags |= ATTR_NONBLOCK;
 955
 956         vattr->va_mask = XFS_AT_XFLAGS;
 957         vattr->va_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
 958
 959         error = -xfs_setattr(ip, vattr, attr_flags, NULL);
 960         if (likely(!error))
 961                 vn_revalidate(XFS_ITOV(ip));    /* update flags */
 962         kfree(vattr);
 963         return error;
 964 }
 965
 966 STATIC int
 967 xfs_ioc_getbmap(
 968         struct xfs_inode        *ip,
 969         int                     ioflags,
 970         unsigned int            cmd,
 971         void                    __user *arg)
 972 {
 973         struct getbmap          bm;
 974         int                     iflags;
 975         int                     error;
 976
 977         if (copy_from_user(&bm, arg, sizeof(bm)))
 978                 return -XFS_ERROR(EFAULT);
 979
 980         if (bm.bmv_count < 2)
 981                 return -XFS_ERROR(EINVAL);
 982
 983         iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
 984         if (ioflags & IO_INVIS)
 985                 iflags |= BMV_IF_NO_DMAPI_READ;
 986
 987         error = xfs_getbmap(ip, &bm, (struct getbmap __user *)arg+1, iflags);
 988         if (error)
 989                 return -error;
 990
 991         if (copy_to_user(arg, &bm, sizeof(bm)))
 992                 return -XFS_ERROR(EFAULT);
 993         return 0;
 994 }
 995
 996 STATIC int
 997 xfs_ioc_getbmapx(
 998         struct xfs_inode        *ip,
 999         void                    __user *arg)
1000 {
1001         struct getbmapx         bmx;
1002         struct getbmap          bm;
1003         int                     iflags;
1004         int                     error;
1005
1006         if (copy_from_user(&bmx, arg, sizeof(bmx)))
1007                 return -XFS_ERROR(EFAULT);
1008
1009         if (bmx.bmv_count < 2)
1010                 return -XFS_ERROR(EINVAL);
1011
1012         /*
1013          * Map input getbmapx structure to a getbmap
1014          * structure for xfs_getbmap.
1015          */
1016         GETBMAP_CONVERT(bmx, bm);
1017
1018         iflags = bmx.bmv_iflags;
1019
1020         if (iflags & (~BMV_IF_VALID))
1021                 return -XFS_ERROR(EINVAL);
1022
1023         iflags |= BMV_IF_EXTENDED;
1024
1025         error = xfs_getbmap(ip, &bm, (struct getbmapx __user *)arg+1, iflags);
1026         if (error)
1027                 return -error;
1028
1029         GETBMAP_CONVERT(bm, bmx);
1030
1031         if (copy_to_user(arg, &bmx, sizeof(bmx)))
1032                 return -XFS_ERROR(EFAULT);
1033
1034         return 0;
1035 }
1036
1037 int
1038 xfs_ioctl(
1039         xfs_inode_t             *ip,
1040         struct file             *filp,
1041         int                     ioflags,
1042         unsigned int            cmd,
1043         void                    __user *arg)
1044 {
1045         struct inode            *inode = filp->f_path.dentry->d_inode;
1046         xfs_mount_t             *mp = ip->i_mount;
1047         int                     error;
1048
1049         xfs_itrace_entry(XFS_I(inode));
1050         switch (cmd) {
1051
1052         case XFS_IOC_ALLOCSP:
1053         case XFS_IOC_FREESP:
1054         case XFS_IOC_RESVSP:
1055         case XFS_IOC_UNRESVSP:
1056         case XFS_IOC_ALLOCSP64:
1057         case XFS_IOC_FREESP64:
1058         case XFS_IOC_RESVSP64:
1059         case XFS_IOC_UNRESVSP64:
1060                 /*
1061                  * Only allow the sys admin to reserve space unless
1062                  * unwritten extents are enabled.
1063                  */
1064                 if (!xfs_sb_version_hasextflgbit(&mp->m_sb) &&
1065                     !capable(CAP_SYS_ADMIN))
1066                         return -EPERM;
1067
1068                 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, arg);
1069
1070         case XFS_IOC_DIOINFO: {
1071                 struct dioattr  da;
1072                 xfs_buftarg_t   *target =
1073                         XFS_IS_REALTIME_INODE(ip) ?
1074                         mp->m_rtdev_targp : mp->m_ddev_targp;
1075
1076                 da.d_mem = da.d_miniosz = 1 << target->bt_sshift;
1077                 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1078
1079                 if (copy_to_user(arg, &da, sizeof(da)))
1080                         return -XFS_ERROR(EFAULT);
1081                 return 0;
1082         }
1083
1084         case XFS_IOC_FSBULKSTAT_SINGLE:
1085         case XFS_IOC_FSBULKSTAT:
1086         case XFS_IOC_FSINUMBERS:
1087                 return xfs_ioc_bulkstat(mp, cmd, arg);
1088
1089         case XFS_IOC_FSGEOMETRY_V1:
1090                 return xfs_ioc_fsgeometry_v1(mp, arg);
1091
1092         case XFS_IOC_FSGEOMETRY:
1093                 return xfs_ioc_fsgeometry(mp, arg);
1094
1095         case XFS_IOC_GETVERSION:
1096                 return put_user(inode->i_generation, (int __user *)arg);
1097
1098         case XFS_IOC_FSGETXATTR:
1099                 return xfs_ioc_fsgetxattr(ip, 0, arg);
1100         case XFS_IOC_FSGETXATTRA:
1101                 return xfs_ioc_fsgetxattr(ip, 1, arg);
1102         case XFS_IOC_FSSETXATTR:
1103                 return xfs_ioc_fssetxattr(ip, filp, arg);
1104         case XFS_IOC_GETXFLAGS:
1105                 return xfs_ioc_getxflags(ip, arg);
1106         case XFS_IOC_SETXFLAGS:
1107                 return xfs_ioc_setxflags(ip, filp, arg);
1108
1109         case XFS_IOC_FSSETDM: {
1110                 struct fsdmidata        dmi;
1111
1112                 if (copy_from_user(&dmi, arg, sizeof(dmi)))
1113                         return -XFS_ERROR(EFAULT);
1114
1115                 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1116                                 dmi.fsd_dmstate);
1117                 return -error;
1118         }
1119
1120         case XFS_IOC_GETBMAP:
1121         case XFS_IOC_GETBMAPA:
1122                 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1123
1124         case XFS_IOC_GETBMAPX:
1125                 return xfs_ioc_getbmapx(ip, arg);
1126
1127         case XFS_IOC_FD_TO_HANDLE:
1128         case XFS_IOC_PATH_TO_HANDLE:
1129         case XFS_IOC_PATH_TO_FSHANDLE:
1130                 return xfs_find_handle(cmd, arg);
1131
1132         case XFS_IOC_OPEN_BY_HANDLE:
1133                 return xfs_open_by_handle(mp, arg, filp, inode);
1134
1135         case XFS_IOC_FSSETDM_BY_HANDLE:
1136                 return xfs_fssetdm_by_handle(mp, arg, inode);
1137
1138         case XFS_IOC_READLINK_BY_HANDLE:
1139                 return xfs_readlink_by_handle(mp, arg, inode);
1140
1141         case XFS_IOC_ATTRLIST_BY_HANDLE:
1142                 return xfs_attrlist_by_handle(mp, arg, inode);
1143
1144         case XFS_IOC_ATTRMULTI_BY_HANDLE:
1145                 return xfs_attrmulti_by_handle(mp, arg, filp, inode);
1146
1147         case XFS_IOC_SWAPEXT: {
1148                 error = xfs_swapext((struct xfs_swapext __user *)arg);
1149                 return -error;
1150         }
1151
1152         case XFS_IOC_FSCOUNTS: {
1153                 xfs_fsop_counts_t out;
1154
1155                 error = xfs_fs_counts(mp, &out);
1156                 if (error)
1157                         return -error;
1158
1159                 if (copy_to_user(arg, &out, sizeof(out)))
1160                         return -XFS_ERROR(EFAULT);
1161                 return 0;
1162         }
1163
1164         case XFS_IOC_SET_RESBLKS: {
1165                 xfs_fsop_resblks_t inout;
1166                 __uint64_t         in;
1167
1168                 if (!capable(CAP_SYS_ADMIN))
1169                         return -EPERM;
1170
1171                 if (copy_from_user(&inout, arg, sizeof(inout)))
1172                         return -XFS_ERROR(EFAULT);
1173
1174                 /* input parameter is passed in resblks field of structure */
1175                 in = inout.resblks;
1176                 error = xfs_reserve_blocks(mp, &in, &inout);
1177                 if (error)
1178                         return -error;
1179
1180                 if (copy_to_user(arg, &inout, sizeof(inout)))
1181                         return -XFS_ERROR(EFAULT);
1182                 return 0;
1183         }
1184
1185         case XFS_IOC_GET_RESBLKS: {
1186                 xfs_fsop_resblks_t out;
1187
1188                 if (!capable(CAP_SYS_ADMIN))
1189                         return -EPERM;
1190
1191                 error = xfs_reserve_blocks(mp, NULL, &out);
1192                 if (error)
1193                         return -error;
1194
1195                 if (copy_to_user(arg, &out, sizeof(out)))
1196                         return -XFS_ERROR(EFAULT);
1197
1198                 return 0;
1199         }
1200
1201         case XFS_IOC_FSGROWFSDATA: {
1202                 xfs_growfs_data_t in;
1203
1204                 if (!capable(CAP_SYS_ADMIN))
1205                         return -EPERM;
1206
1207                 if (copy_from_user(&in, arg, sizeof(in)))
1208                         return -XFS_ERROR(EFAULT);
1209
1210                 error = xfs_growfs_data(mp, &in);
1211                 return -error;
1212         }
1213
1214         case XFS_IOC_FSGROWFSLOG: {
1215                 xfs_growfs_log_t in;
1216
1217                 if (!capable(CAP_SYS_ADMIN))
1218                         return -EPERM;
1219
1220                 if (copy_from_user(&in, arg, sizeof(in)))
1221                         return -XFS_ERROR(EFAULT);
1222
1223                 error = xfs_growfs_log(mp, &in);
1224                 return -error;
1225         }
1226
1227         case XFS_IOC_FSGROWFSRT: {
1228                 xfs_growfs_rt_t in;
1229
1230                 if (!capable(CAP_SYS_ADMIN))
1231                         return -EPERM;
1232
1233                 if (copy_from_user(&in, arg, sizeof(in)))
1234                         return -XFS_ERROR(EFAULT);
1235
1236                 error = xfs_growfs_rt(mp, &in);
1237                 return -error;
1238         }
1239
1240         case XFS_IOC_FREEZE:
1241                 if (!capable(CAP_SYS_ADMIN))
1242                         return -EPERM;
1243
1244                 if (inode->i_sb->s_frozen == SB_UNFROZEN)
1245                         freeze_bdev(inode->i_sb->s_bdev);
1246                 return 0;
1247
1248         case XFS_IOC_THAW:
1249                 if (!capable(CAP_SYS_ADMIN))
1250                         return -EPERM;
1251                 if (inode->i_sb->s_frozen != SB_UNFROZEN)
1252                         thaw_bdev(inode->i_sb->s_bdev, inode->i_sb);
1253                 return 0;
1254
1255         case XFS_IOC_GOINGDOWN: {
1256                 __uint32_t in;
1257
1258                 if (!capable(CAP_SYS_ADMIN))
1259                         return -EPERM;
1260
1261                 if (get_user(in, (__uint32_t __user *)arg))
1262                         return -XFS_ERROR(EFAULT);
1263
1264                 error = xfs_fs_goingdown(mp, in);
1265                 return -error;
1266         }
1267
1268         case XFS_IOC_ERROR_INJECTION: {
1269                 xfs_error_injection_t in;
1270
1271                 if (!capable(CAP_SYS_ADMIN))
1272                         return -EPERM;
1273
1274                 if (copy_from_user(&in, arg, sizeof(in)))
1275                         return -XFS_ERROR(EFAULT);
1276
1277                 error = xfs_errortag_add(in.errtag, mp);
1278                 return -error;
1279         }
1280
1281         case XFS_IOC_ERROR_CLEARALL:
1282                 if (!capable(CAP_SYS_ADMIN))
1283                         return -EPERM;
1284
1285                 error = xfs_errortag_clearall(mp, 1);
1286                 return -error;
1287
1288         default:
1289                 return -ENOTTY;
1290         }
1291 }