fs/xfs/linux-2.6/xfs_ioctl.c

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