err.no Git - linux-2.6/blob - fs/xfs/linux-2.6/xfs_ioctl.c

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