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