SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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_RDONLY(&vp->v_inode))
 534                 return -EROFS;
 535         if (IS_IMMUTABLE(&vp->v_inode) || IS_APPEND(&vp->v_inode))
 536                 return EPERM;
 537         if (len > XATTR_SIZE_MAX)
 538                 return EINVAL;
 539
 540         kbuf = kmalloc(len, GFP_KERNEL);
 541         if (!kbuf)
 542                 return ENOMEM;
 543
 544         if (copy_from_user(kbuf, ubuf, len))
 545                 goto out_kfree;
 546
 547         VOP_ATTR_SET(vp, name, kbuf, len, flags, NULL, error);
 548
 549  out_kfree:
 550         kfree(kbuf);
 551         return error;
 552 }
 553
 554 STATIC int
 555 xfs_attrmulti_attr_remove(
 556         struct vnode            *vp,
 557         char                    *name,
 558         __uint32_t              flags)
 559 {
 560         int                     error;
 561
 562
 563         if (IS_RDONLY(&vp->v_inode))
 564                 return -EROFS;
 565         if (IS_IMMUTABLE(&vp->v_inode) || IS_APPEND(&vp->v_inode))
 566                 return EPERM;
 567
 568         VOP_ATTR_REMOVE(vp, name, flags, NULL, error);
 569         return error;
 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         vnode_t                 *vp;
 584         unsigned int            i, size;
 585         char                    *attr_name;
 586
 587         if (!capable(CAP_SYS_ADMIN))
 588                 return -XFS_ERROR(EPERM);
 589         if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
 590                 return -XFS_ERROR(EFAULT);
 591
 592         error = xfs_vget_fsop_handlereq(mp, parinode, &am_hreq.hreq, &vp, &inode);
 593         if (error)
 594                 goto out;
 595
 596         error = E2BIG;
 597         size = am_hreq.opcount * sizeof(attr_multiop_t);
 598         if (!size || size > 16 * PAGE_SIZE)
 599                 goto out_vn_rele;
 600
 601         error = ENOMEM;
 602         ops = kmalloc(size, GFP_KERNEL);
 603         if (!ops)
 604                 goto out_vn_rele;
 605
 606         error = EFAULT;
 607         if (copy_from_user(ops, am_hreq.ops, size))
 608                 goto out_kfree_ops;
 609
 610         attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
 611         if (!attr_name)
 612                 goto out_kfree_ops;
 613
 614
 615         error = 0;
 616         for (i = 0; i < am_hreq.opcount; i++) {
 617                 ops[i].am_error = strncpy_from_user(attr_name,
 618                                 ops[i].am_attrname, MAXNAMELEN);
 619                 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
 620                         error = -ERANGE;
 621                 if (ops[i].am_error < 0)
 622                         break;
 623
 624                 switch (ops[i].am_opcode) {
 625                 case ATTR_OP_GET:
 626                         ops[i].am_error = xfs_attrmulti_attr_get(vp,
 627                                         attr_name, ops[i].am_attrvalue,
 628                                         &ops[i].am_length, ops[i].am_flags);
 629                         break;
 630                 case ATTR_OP_SET:
 631                         ops[i].am_error = xfs_attrmulti_attr_set(vp,
 632                                         attr_name, ops[i].am_attrvalue,
 633                                         ops[i].am_length, ops[i].am_flags);
 634                         break;
 635                 case ATTR_OP_REMOVE:
 636                         ops[i].am_error = xfs_attrmulti_attr_remove(vp,
 637                                         attr_name, ops[i].am_flags);
 638                         break;
 639                 default:
 640                         ops[i].am_error = EINVAL;
 641                 }
 642         }
 643
 644         if (copy_to_user(am_hreq.ops, ops, size))
 645                 error = XFS_ERROR(EFAULT);
 646
 647         kfree(attr_name);
 648  out_kfree_ops:
 649         kfree(ops);
 650  out_vn_rele:
 651         VN_RELE(vp);
 652  out:
 653         return -error;
 654 }
 655
 656 /* prototypes for a few of the stack-hungry cases that have
 657  * their own functions.  Functions are defined after their use
 658  * so gcc doesn't get fancy and inline them with -03 */
 659
 660 STATIC int
 661 xfs_ioc_space(
 662         bhv_desc_t              *bdp,
 663         vnode_t                 *vp,
 664         struct file             *filp,
 665         int                     flags,
 666         unsigned int            cmd,
 667         void                    __user *arg);
 668
 669 STATIC int
 670 xfs_ioc_bulkstat(
 671         xfs_mount_t             *mp,
 672         unsigned int            cmd,
 673         void                    __user *arg);
 674
 675 STATIC int
 676 xfs_ioc_fsgeometry_v1(
 677         xfs_mount_t             *mp,
 678         void                    __user *arg);
 679
 680 STATIC int
 681 xfs_ioc_fsgeometry(
 682         xfs_mount_t             *mp,
 683         void                    __user *arg);
 684
 685 STATIC int
 686 xfs_ioc_xattr(
 687         vnode_t                 *vp,
 688         xfs_inode_t             *ip,
 689         struct file             *filp,
 690         unsigned int            cmd,
 691         void                    __user *arg);
 692
 693 STATIC int
 694 xfs_ioc_getbmap(
 695         bhv_desc_t              *bdp,
 696         struct file             *filp,
 697         int                     flags,
 698         unsigned int            cmd,
 699         void                    __user *arg);
 700
 701 STATIC int
 702 xfs_ioc_getbmapx(
 703         bhv_desc_t              *bdp,
 704         void                    __user *arg);
 705
 706 int
 707 xfs_ioctl(
 708         bhv_desc_t              *bdp,
 709         struct inode            *inode,
 710         struct file             *filp,
 711         int                     ioflags,
 712         unsigned int            cmd,
 713         void                    __user *arg)
 714 {
 715         int                     error;
 716         vnode_t                 *vp;
 717         xfs_inode_t             *ip;
 718         xfs_mount_t             *mp;
 719
 720         vp = LINVFS_GET_VP(inode);
 721
 722         vn_trace_entry(vp, "xfs_ioctl", (inst_t *)__return_address);
 723
 724         ip = XFS_BHVTOI(bdp);
 725         mp = ip->i_mount;
 726
 727         switch (cmd) {
 728
 729         case XFS_IOC_ALLOCSP:
 730         case XFS_IOC_FREESP:
 731         case XFS_IOC_RESVSP:
 732         case XFS_IOC_UNRESVSP:
 733         case XFS_IOC_ALLOCSP64:
 734         case XFS_IOC_FREESP64:
 735         case XFS_IOC_RESVSP64:
 736         case XFS_IOC_UNRESVSP64:
 737                 /*
 738                  * Only allow the sys admin to reserve space unless
 739                  * unwritten extents are enabled.
 740                  */
 741                 if (!XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb) &&
 742                     !capable(CAP_SYS_ADMIN))
 743                         return -EPERM;
 744
 745                 return xfs_ioc_space(bdp, vp, filp, ioflags, cmd, arg);
 746
 747         case XFS_IOC_DIOINFO: {
 748                 struct dioattr  da;
 749                 xfs_buftarg_t   *target =
 750                         (ip->i_d.di_flags & XFS_DIFLAG_REALTIME) ?
 751                         mp->m_rtdev_targp : mp->m_ddev_targp;
 752
 753                 da.d_mem = da.d_miniosz = 1 << target->pbr_sshift;
 754                 /* The size dio will do in one go */
 755                 da.d_maxiosz = 64 * PAGE_CACHE_SIZE;
 756
 757                 if (copy_to_user(arg, &da, sizeof(da)))
 758                         return -XFS_ERROR(EFAULT);
 759                 return 0;
 760         }
 761
 762         case XFS_IOC_FSBULKSTAT_SINGLE:
 763         case XFS_IOC_FSBULKSTAT:
 764         case XFS_IOC_FSINUMBERS:
 765                 return xfs_ioc_bulkstat(mp, cmd, arg);
 766
 767         case XFS_IOC_FSGEOMETRY_V1:
 768                 return xfs_ioc_fsgeometry_v1(mp, arg);
 769
 770         case XFS_IOC_FSGEOMETRY:
 771                 return xfs_ioc_fsgeometry(mp, arg);
 772
 773         case XFS_IOC_GETVERSION:
 774         case XFS_IOC_GETXFLAGS:
 775         case XFS_IOC_SETXFLAGS:
 776         case XFS_IOC_FSGETXATTR:
 777         case XFS_IOC_FSSETXATTR:
 778         case XFS_IOC_FSGETXATTRA:
 779                 return xfs_ioc_xattr(vp, ip, filp, cmd, arg);
 780
 781         case XFS_IOC_FSSETDM: {
 782                 struct fsdmidata        dmi;
 783
 784                 if (copy_from_user(&dmi, arg, sizeof(dmi)))
 785                         return -XFS_ERROR(EFAULT);
 786
 787                 error = xfs_set_dmattrs(bdp, dmi.fsd_dmevmask, dmi.fsd_dmstate,
 788                                                         NULL);
 789                 return -error;
 790         }
 791
 792         case XFS_IOC_GETBMAP:
 793         case XFS_IOC_GETBMAPA:
 794                 return xfs_ioc_getbmap(bdp, filp, ioflags, cmd, arg);
 795
 796         case XFS_IOC_GETBMAPX:
 797                 return xfs_ioc_getbmapx(bdp, arg);
 798
 799         case XFS_IOC_FD_TO_HANDLE:
 800         case XFS_IOC_PATH_TO_HANDLE:
 801         case XFS_IOC_PATH_TO_FSHANDLE:
 802                 return xfs_find_handle(cmd, arg);
 803
 804         case XFS_IOC_OPEN_BY_HANDLE:
 805                 return xfs_open_by_handle(mp, arg, filp, inode);
 806
 807         case XFS_IOC_FSSETDM_BY_HANDLE:
 808                 return xfs_fssetdm_by_handle(mp, arg, filp, inode);
 809
 810         case XFS_IOC_READLINK_BY_HANDLE:
 811                 return xfs_readlink_by_handle(mp, arg, filp, inode);
 812
 813         case XFS_IOC_ATTRLIST_BY_HANDLE:
 814                 return xfs_attrlist_by_handle(mp, arg, filp, inode);
 815
 816         case XFS_IOC_ATTRMULTI_BY_HANDLE:
 817                 return xfs_attrmulti_by_handle(mp, arg, filp, inode);
 818
 819         case XFS_IOC_SWAPEXT: {
 820                 error = xfs_swapext((struct xfs_swapext __user *)arg);
 821                 return -error;
 822         }
 823
 824         case XFS_IOC_FSCOUNTS: {
 825                 xfs_fsop_counts_t out;
 826
 827                 error = xfs_fs_counts(mp, &out);
 828                 if (error)
 829                         return -error;
 830
 831                 if (copy_to_user(arg, &out, sizeof(out)))
 832                         return -XFS_ERROR(EFAULT);
 833                 return 0;
 834         }
 835
 836         case XFS_IOC_SET_RESBLKS: {
 837                 xfs_fsop_resblks_t inout;
 838                 __uint64_t         in;
 839
 840                 if (!capable(CAP_SYS_ADMIN))
 841                         return -EPERM;
 842
 843                 if (copy_from_user(&inout, arg, sizeof(inout)))
 844                         return -XFS_ERROR(EFAULT);
 845
 846                 /* input parameter is passed in resblks field of structure */
 847                 in = inout.resblks;
 848                 error = xfs_reserve_blocks(mp, &in, &inout);
 849                 if (error)
 850                         return -error;
 851
 852                 if (copy_to_user(arg, &inout, sizeof(inout)))
 853                         return -XFS_ERROR(EFAULT);
 854                 return 0;
 855         }
 856
 857         case XFS_IOC_GET_RESBLKS: {
 858                 xfs_fsop_resblks_t out;
 859
 860                 if (!capable(CAP_SYS_ADMIN))
 861                         return -EPERM;
 862
 863                 error = xfs_reserve_blocks(mp, NULL, &out);
 864                 if (error)
 865                         return -error;
 866
 867                 if (copy_to_user(arg, &out, sizeof(out)))
 868                         return -XFS_ERROR(EFAULT);
 869
 870                 return 0;
 871         }
 872
 873         case XFS_IOC_FSGROWFSDATA: {
 874                 xfs_growfs_data_t in;
 875
 876                 if (!capable(CAP_SYS_ADMIN))
 877                         return -EPERM;
 878
 879                 if (copy_from_user(&in, arg, sizeof(in)))
 880                         return -XFS_ERROR(EFAULT);
 881
 882                 error = xfs_growfs_data(mp, &in);
 883                 return -error;
 884         }
 885
 886         case XFS_IOC_FSGROWFSLOG: {
 887                 xfs_growfs_log_t in;
 888
 889                 if (!capable(CAP_SYS_ADMIN))
 890                         return -EPERM;
 891
 892                 if (copy_from_user(&in, arg, sizeof(in)))
 893                         return -XFS_ERROR(EFAULT);
 894
 895                 error = xfs_growfs_log(mp, &in);
 896                 return -error;
 897         }
 898
 899         case XFS_IOC_FSGROWFSRT: {
 900                 xfs_growfs_rt_t in;
 901
 902                 if (!capable(CAP_SYS_ADMIN))
 903                         return -EPERM;
 904
 905                 if (copy_from_user(&in, arg, sizeof(in)))
 906                         return -XFS_ERROR(EFAULT);
 907
 908                 error = xfs_growfs_rt(mp, &in);
 909                 return -error;
 910         }
 911
 912         case XFS_IOC_FREEZE:
 913                 if (!capable(CAP_SYS_ADMIN))
 914                         return -EPERM;
 915
 916                 if (inode->i_sb->s_frozen == SB_UNFROZEN)
 917                         freeze_bdev(inode->i_sb->s_bdev);
 918                 return 0;
 919
 920         case XFS_IOC_THAW:
 921                 if (!capable(CAP_SYS_ADMIN))
 922                         return -EPERM;
 923                 if (inode->i_sb->s_frozen != SB_UNFROZEN)
 924                         thaw_bdev(inode->i_sb->s_bdev, inode->i_sb);
 925                 return 0;
 926
 927         case XFS_IOC_GOINGDOWN: {
 928                 __uint32_t in;
 929
 930                 if (!capable(CAP_SYS_ADMIN))
 931                         return -EPERM;
 932
 933                 if (get_user(in, (__uint32_t __user *)arg))
 934                         return -XFS_ERROR(EFAULT);
 935
 936                 error = xfs_fs_goingdown(mp, in);
 937                 return -error;
 938         }
 939
 940         case XFS_IOC_ERROR_INJECTION: {
 941                 xfs_error_injection_t in;
 942
 943                 if (!capable(CAP_SYS_ADMIN))
 944                         return -EPERM;
 945
 946                 if (copy_from_user(&in, arg, sizeof(in)))
 947                         return -XFS_ERROR(EFAULT);
 948
 949                 error = xfs_errortag_add(in.errtag, mp);
 950                 return -error;
 951         }
 952
 953         case XFS_IOC_ERROR_CLEARALL:
 954                 if (!capable(CAP_SYS_ADMIN))
 955                         return -EPERM;
 956
 957                 error = xfs_errortag_clearall(mp);
 958                 return -error;
 959
 960         default:
 961                 return -ENOTTY;
 962         }
 963 }
 964
 965 STATIC int
 966 xfs_ioc_space(
 967         bhv_desc_t              *bdp,
 968         vnode_t                 *vp,
 969         struct file             *filp,
 970         int                     ioflags,
 971         unsigned int            cmd,
 972         void                    __user *arg)
 973 {
 974         xfs_flock64_t           bf;
 975         int                     attr_flags = 0;
 976         int                     error;
 977
 978         if (vp->v_inode.i_flags & (S_IMMUTABLE|S_APPEND))
 979                 return -XFS_ERROR(EPERM);
 980
 981         if (!(filp->f_mode & FMODE_WRITE))
 982                 return -XFS_ERROR(EBADF);
 983
 984         if (!VN_ISREG(vp))
 985                 return -XFS_ERROR(EINVAL);
 986
 987         if (copy_from_user(&bf, arg, sizeof(bf)))
 988                 return -XFS_ERROR(EFAULT);
 989
 990         if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
 991                 attr_flags |= ATTR_NONBLOCK;
 992         if (ioflags & IO_INVIS)
 993                 attr_flags |= ATTR_DMI;
 994
 995         error = xfs_change_file_space(bdp, cmd, &bf, filp->f_pos,
 996                                               NULL, attr_flags);
 997         return -error;
 998 }
 999
1000 STATIC int
1001 xfs_ioc_bulkstat(
1002         xfs_mount_t             *mp,
1003         unsigned int            cmd,
1004         void                    __user *arg)
1005 {
1006         xfs_fsop_bulkreq_t      bulkreq;
1007         int                     count;  /* # of records returned */
1008         xfs_ino_t               inlast; /* last inode number */
1009         int                     done;
1010         int                     error;
1011
1012         /* done = 1 if there are more stats to get and if bulkstat */
1013         /* should be called again (unused here, but used in dmapi) */
1014
1015         if (!capable(CAP_SYS_ADMIN))
1016                 return -EPERM;
1017
1018         if (XFS_FORCED_SHUTDOWN(mp))
1019                 return -XFS_ERROR(EIO);
1020
1021         if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
1022                 return -XFS_ERROR(EFAULT);
1023
1024         if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
1025                 return -XFS_ERROR(EFAULT);
1026
1027         if ((count = bulkreq.icount) <= 0)
1028                 return -XFS_ERROR(EINVAL);
1029
1030         if (cmd == XFS_IOC_FSINUMBERS)
1031                 error = xfs_inumbers(mp, &inlast, &count,
1032                                                 bulkreq.ubuffer);
1033         else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
1034                 error = xfs_bulkstat_single(mp, &inlast,
1035                                                 bulkreq.ubuffer, &done);
1036         else {  /* XFS_IOC_FSBULKSTAT */
1037                 if (count == 1 && inlast != 0) {
1038                         inlast++;
1039                         error = xfs_bulkstat_single(mp, &inlast,
1040                                         bulkreq.ubuffer, &done);
1041                 } else {
1042                         error = xfs_bulkstat(mp, &inlast, &count,
1043                                 (bulkstat_one_pf)xfs_bulkstat_one, NULL,
1044                                 sizeof(xfs_bstat_t), bulkreq.ubuffer,
1045                                 BULKSTAT_FG_QUICK, &done);
1046                 }
1047         }
1048
1049         if (error)
1050                 return -error;
1051
1052         if (bulkreq.ocount != NULL) {
1053                 if (copy_to_user(bulkreq.lastip, &inlast,
1054                                                 sizeof(xfs_ino_t)))
1055                         return -XFS_ERROR(EFAULT);
1056
1057                 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
1058                         return -XFS_ERROR(EFAULT);
1059         }
1060
1061         return 0;
1062 }
1063
1064 STATIC int
1065 xfs_ioc_fsgeometry_v1(
1066         xfs_mount_t             *mp,
1067         void                    __user *arg)
1068 {
1069         xfs_fsop_geom_v1_t      fsgeo;
1070         int                     error;
1071
1072         error = xfs_fs_geometry(mp, (xfs_fsop_geom_t *)&fsgeo, 3);
1073         if (error)
1074                 return -error;
1075
1076         if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
1077                 return -XFS_ERROR(EFAULT);
1078         return 0;
1079 }
1080
1081 STATIC int
1082 xfs_ioc_fsgeometry(
1083         xfs_mount_t             *mp,
1084         void                    __user *arg)
1085 {
1086         xfs_fsop_geom_t         fsgeo;
1087         int                     error;
1088
1089         error = xfs_fs_geometry(mp, &fsgeo, 4);
1090         if (error)
1091                 return -error;
1092
1093         if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
1094                 return -XFS_ERROR(EFAULT);
1095         return 0;
1096 }
1097
1098 /*
1099  * Linux extended inode flags interface.
1100  */
1101 #define LINUX_XFLAG_SYNC        0x00000008 /* Synchronous updates */
1102 #define LINUX_XFLAG_IMMUTABLE   0x00000010 /* Immutable file */
1103 #define LINUX_XFLAG_APPEND      0x00000020 /* writes to file may only append */
1104 #define LINUX_XFLAG_NODUMP      0x00000040 /* do not dump file */
1105 #define LINUX_XFLAG_NOATIME     0x00000080 /* do not update atime */
1106
1107 STATIC unsigned int
1108 xfs_merge_ioc_xflags(
1109         unsigned int    flags,
1110         unsigned int    start)
1111 {
1112         unsigned int    xflags = start;
1113
1114         if (flags & LINUX_XFLAG_IMMUTABLE)
1115                 xflags |= XFS_XFLAG_IMMUTABLE;
1116         else
1117                 xflags &= ~XFS_XFLAG_IMMUTABLE;
1118         if (flags & LINUX_XFLAG_APPEND)
1119                 xflags |= XFS_XFLAG_APPEND;
1120         else
1121                 xflags &= ~XFS_XFLAG_APPEND;
1122         if (flags & LINUX_XFLAG_SYNC)
1123                 xflags |= XFS_XFLAG_SYNC;
1124         else
1125                 xflags &= ~XFS_XFLAG_SYNC;
1126         if (flags & LINUX_XFLAG_NOATIME)
1127                 xflags |= XFS_XFLAG_NOATIME;
1128         else
1129                 xflags &= ~XFS_XFLAG_NOATIME;
1130         if (flags & LINUX_XFLAG_NODUMP)
1131                 xflags |= XFS_XFLAG_NODUMP;
1132         else
1133                 xflags &= ~XFS_XFLAG_NODUMP;
1134
1135         return xflags;
1136 }
1137
1138 STATIC unsigned int
1139 xfs_di2lxflags(
1140         __uint16_t      di_flags)
1141 {
1142         unsigned int    flags = 0;
1143
1144         if (di_flags & XFS_DIFLAG_IMMUTABLE)
1145                 flags |= LINUX_XFLAG_IMMUTABLE;
1146         if (di_flags & XFS_DIFLAG_APPEND)
1147                 flags |= LINUX_XFLAG_APPEND;
1148         if (di_flags & XFS_DIFLAG_SYNC)
1149                 flags |= LINUX_XFLAG_SYNC;
1150         if (di_flags & XFS_DIFLAG_NOATIME)
1151                 flags |= LINUX_XFLAG_NOATIME;
1152         if (di_flags & XFS_DIFLAG_NODUMP)
1153                 flags |= LINUX_XFLAG_NODUMP;
1154         return flags;
1155 }
1156
1157 STATIC int
1158 xfs_ioc_xattr(
1159         vnode_t                 *vp,
1160         xfs_inode_t             *ip,
1161         struct file             *filp,
1162         unsigned int            cmd,
1163         void                    __user *arg)
1164 {
1165         struct fsxattr          fa;
1166         vattr_t                 va;
1167         int                     error;
1168         int                     attr_flags;
1169         unsigned int            flags;
1170
1171         switch (cmd) {
1172         case XFS_IOC_FSGETXATTR: {
1173                 va.va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
1174                              XFS_AT_NEXTENTS | XFS_AT_PROJID;
1175                 VOP_GETATTR(vp, &va, 0, NULL, error);
1176                 if (error)
1177                         return -error;
1178
1179                 fa.fsx_xflags   = va.va_xflags;
1180                 fa.fsx_extsize  = va.va_extsize;
1181                 fa.fsx_nextents = va.va_nextents;
1182                 fa.fsx_projid   = va.va_projid;
1183
1184                 if (copy_to_user(arg, &fa, sizeof(fa)))
1185                         return -XFS_ERROR(EFAULT);
1186                 return 0;
1187         }
1188
1189         case XFS_IOC_FSSETXATTR: {
1190                 if (copy_from_user(&fa, arg, sizeof(fa)))
1191                         return -XFS_ERROR(EFAULT);
1192
1193                 attr_flags = 0;
1194                 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1195                         attr_flags |= ATTR_NONBLOCK;
1196
1197                 va.va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | XFS_AT_PROJID;
1198                 va.va_xflags  = fa.fsx_xflags;
1199                 va.va_extsize = fa.fsx_extsize;
1200                 va.va_projid  = fa.fsx_projid;
1201
1202                 VOP_SETATTR(vp, &va, attr_flags, NULL, error);
1203                 if (!error)
1204                         vn_revalidate(vp);      /* update Linux inode flags */
1205                 return -error;
1206         }
1207
1208         case XFS_IOC_FSGETXATTRA: {
1209                 va.va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
1210                              XFS_AT_ANEXTENTS | XFS_AT_PROJID;
1211                 VOP_GETATTR(vp, &va, 0, NULL, error);
1212                 if (error)
1213                         return -error;
1214
1215                 fa.fsx_xflags   = va.va_xflags;
1216                 fa.fsx_extsize  = va.va_extsize;
1217                 fa.fsx_nextents = va.va_anextents;
1218                 fa.fsx_projid   = va.va_projid;
1219
1220                 if (copy_to_user(arg, &fa, sizeof(fa)))
1221                         return -XFS_ERROR(EFAULT);
1222                 return 0;
1223         }
1224
1225         case XFS_IOC_GETXFLAGS: {
1226                 flags = xfs_di2lxflags(ip->i_d.di_flags);
1227                 if (copy_to_user(arg, &flags, sizeof(flags)))
1228                         return -XFS_ERROR(EFAULT);
1229                 return 0;
1230         }
1231
1232         case XFS_IOC_SETXFLAGS: {
1233                 if (copy_from_user(&flags, arg, sizeof(flags)))
1234                         return -XFS_ERROR(EFAULT);
1235
1236                 if (flags & ~(LINUX_XFLAG_IMMUTABLE | LINUX_XFLAG_APPEND | \
1237                               LINUX_XFLAG_NOATIME | LINUX_XFLAG_NODUMP | \
1238                               LINUX_XFLAG_SYNC))
1239                         return -XFS_ERROR(EOPNOTSUPP);
1240
1241                 attr_flags = 0;
1242                 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1243                         attr_flags |= ATTR_NONBLOCK;
1244
1245                 va.va_mask = XFS_AT_XFLAGS;
1246                 va.va_xflags = xfs_merge_ioc_xflags(flags,
1247                                 xfs_ip2xflags(ip));
1248
1249                 VOP_SETATTR(vp, &va, attr_flags, NULL, error);
1250                 if (!error)
1251                         vn_revalidate(vp);      /* update Linux inode flags */
1252                 return -error;
1253         }
1254
1255         case XFS_IOC_GETVERSION: {
1256                 flags = LINVFS_GET_IP(vp)->i_generation;
1257                 if (copy_to_user(arg, &flags, sizeof(flags)))
1258                         return -XFS_ERROR(EFAULT);
1259                 return 0;
1260         }
1261
1262         default:
1263                 return -ENOTTY;
1264         }
1265 }
1266
1267 STATIC int
1268 xfs_ioc_getbmap(
1269         bhv_desc_t              *bdp,
1270         struct file             *filp,
1271         int                     ioflags,
1272         unsigned int            cmd,
1273         void                    __user *arg)
1274 {
1275         struct getbmap          bm;
1276         int                     iflags;
1277         int                     error;
1278
1279         if (copy_from_user(&bm, arg, sizeof(bm)))
1280                 return -XFS_ERROR(EFAULT);
1281
1282         if (bm.bmv_count < 2)
1283                 return -XFS_ERROR(EINVAL);
1284
1285         iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1286         if (ioflags & IO_INVIS)
1287                 iflags |= BMV_IF_NO_DMAPI_READ;
1288
1289         error = xfs_getbmap(bdp, &bm, (struct getbmap __user *)arg+1, iflags);
1290         if (error)
1291                 return -error;
1292
1293         if (copy_to_user(arg, &bm, sizeof(bm)))
1294                 return -XFS_ERROR(EFAULT);
1295         return 0;
1296 }
1297
1298 STATIC int
1299 xfs_ioc_getbmapx(
1300         bhv_desc_t              *bdp,
1301         void                    __user *arg)
1302 {
1303         struct getbmapx         bmx;
1304         struct getbmap          bm;
1305         int                     iflags;
1306         int                     error;
1307
1308         if (copy_from_user(&bmx, arg, sizeof(bmx)))
1309                 return -XFS_ERROR(EFAULT);
1310
1311         if (bmx.bmv_count < 2)
1312                 return -XFS_ERROR(EINVAL);
1313
1314         /*
1315          * Map input getbmapx structure to a getbmap
1316          * structure for xfs_getbmap.
1317          */
1318         GETBMAP_CONVERT(bmx, bm);
1319
1320         iflags = bmx.bmv_iflags;
1321
1322         if (iflags & (~BMV_IF_VALID))
1323                 return -XFS_ERROR(EINVAL);
1324
1325         iflags |= BMV_IF_EXTENDED;
1326
1327         error = xfs_getbmap(bdp, &bm, (struct getbmapx __user *)arg+1, iflags);
1328         if (error)
1329                 return -error;
1330
1331         GETBMAP_CONVERT(bm, bmx);
1332
1333         if (copy_to_user(arg, &bmx, sizeof(bmx)))
1334                 return -XFS_ERROR(EFAULT);
1335
1336         return 0;
1337 }