git.oblomov.eu Git - linux-2.6/blob - fs/xfs/linux-2.6/xfs_ioctl.c

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