fs/xfs/xfs_ioctl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_log_format.h"
  11 #include "xfs_trans_resv.h"
  12 #include "xfs_mount.h"
  13 #include "xfs_inode.h"
  14 #include "xfs_rtalloc.h"
  15 #include "xfs_iwalk.h"
  16 #include "xfs_itable.h"
  17 #include "xfs_error.h"
  18 #include "xfs_da_format.h"
  19 #include "xfs_da_btree.h"
  20 #include "xfs_attr.h"
  21 #include "xfs_bmap.h"
  22 #include "xfs_bmap_util.h"
  23 #include "xfs_fsops.h"
  24 #include "xfs_discard.h"
  25 #include "xfs_quota.h"
  26 #include "xfs_trace.h"
  27 #include "xfs_icache.h"
  28 #include "xfs_trans.h"
  29 #include "xfs_btree.h"
  30 #include <linux/fsmap.h>
  31 #include "xfs_fsmap.h"
  32 #include "scrub/xfs_scrub.h"
  33 #include "xfs_sb.h"
  34 #include "xfs_ag.h"
  35 #include "xfs_health.h"
  36 #include "xfs_reflink.h"
  37 #include "xfs_ioctl.h"
  38 #include "xfs_xattr.h"
  39 #include "xfs_rtbitmap.h"
  40 #include "xfs_file.h"
  41 #include "xfs_exchrange.h"
  42 #include "xfs_handle.h"
  43 #include "xfs_rtgroup.h"
  44
  45 #include <linux/mount.h>
  46 #include <linux/fileattr.h>
  47
  48 /* Return 0 on success or positive error */
  49 int
  50 xfs_fsbulkstat_one_fmt(
  51         struct xfs_ibulk                *breq,
  52         const struct xfs_bulkstat       *bstat)
  53 {
  54         struct xfs_bstat                bs1;
  55
  56         xfs_bulkstat_to_bstat(breq->mp, &bs1, bstat);
  57         if (copy_to_user(breq->ubuffer, &bs1, sizeof(bs1)))
  58                 return -EFAULT;
  59         return xfs_ibulk_advance(breq, sizeof(struct xfs_bstat));
  60 }
  61
  62 int
  63 xfs_fsinumbers_fmt(
  64         struct xfs_ibulk                *breq,
  65         const struct xfs_inumbers       *igrp)
  66 {
  67         struct xfs_inogrp               ig1;
  68
  69         xfs_inumbers_to_inogrp(&ig1, igrp);
  70         if (copy_to_user(breq->ubuffer, &ig1, sizeof(struct xfs_inogrp)))
  71                 return -EFAULT;
  72         return xfs_ibulk_advance(breq, sizeof(struct xfs_inogrp));
  73 }
  74
  75 STATIC int
  76 xfs_ioc_fsbulkstat(
  77         struct file             *file,
  78         unsigned int            cmd,
  79         void                    __user *arg)
  80 {
  81         struct xfs_mount        *mp = XFS_I(file_inode(file))->i_mount;
  82         struct xfs_fsop_bulkreq bulkreq;
  83         struct xfs_ibulk        breq = {
  84                 .mp             = mp,
  85                 .idmap          = file_mnt_idmap(file),
  86                 .ocount         = 0,
  87         };
  88         xfs_ino_t               lastino;
  89         int                     error;
  90
  91         /* done = 1 if there are more stats to get and if bulkstat */
  92         /* should be called again (unused here, but used in dmapi) */
  93
  94         if (!capable(CAP_SYS_ADMIN))
  95                 return -EPERM;
  96
  97         if (xfs_is_shutdown(mp))
  98                 return -EIO;
  99
 100         if (copy_from_user(&bulkreq, arg, sizeof(struct xfs_fsop_bulkreq)))
 101                 return -EFAULT;
 102
 103         if (copy_from_user(&lastino, bulkreq.lastip, sizeof(__s64)))
 104                 return -EFAULT;
 105
 106         if (bulkreq.icount <= 0)
 107                 return -EINVAL;
 108
 109         if (bulkreq.ubuffer == NULL)
 110                 return -EINVAL;
 111
 112         breq.ubuffer = bulkreq.ubuffer;
 113         breq.icount = bulkreq.icount;
 114
 115         /*
 116          * FSBULKSTAT_SINGLE expects that *lastip contains the inode number
 117          * that we want to stat.  However, FSINUMBERS and FSBULKSTAT expect
 118          * that *lastip contains either zero or the number of the last inode to
 119          * be examined by the previous call and return results starting with
 120          * the next inode after that.  The new bulk request back end functions
 121          * take the inode to start with, so we have to compute the startino
 122          * parameter from lastino to maintain correct function.  lastino == 0
 123          * is a special case because it has traditionally meant "first inode
 124          * in filesystem".
 125          */
 126         if (cmd == XFS_IOC_FSINUMBERS) {
 127                 breq.startino = lastino ? lastino + 1 : 0;
 128                 error = xfs_inumbers(&breq, xfs_fsinumbers_fmt);
 129                 lastino = breq.startino - 1;
 130         } else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE) {
 131                 breq.startino = lastino;
 132                 breq.icount = 1;
 133                 error = xfs_bulkstat_one(&breq, xfs_fsbulkstat_one_fmt);
 134         } else {        /* XFS_IOC_FSBULKSTAT */
 135                 breq.startino = lastino ? lastino + 1 : 0;
 136                 error = xfs_bulkstat(&breq, xfs_fsbulkstat_one_fmt);
 137                 lastino = breq.startino - 1;
 138         }
 139
 140         if (error)
 141                 return error;
 142
 143         if (bulkreq.lastip != NULL &&
 144             copy_to_user(bulkreq.lastip, &lastino, sizeof(xfs_ino_t)))
 145                 return -EFAULT;
 146
 147         if (bulkreq.ocount != NULL &&
 148             copy_to_user(bulkreq.ocount, &breq.ocount, sizeof(__s32)))
 149                 return -EFAULT;
 150
 151         return 0;
 152 }
 153
 154 /* Return 0 on success or positive error */
 155 static int
 156 xfs_bulkstat_fmt(
 157         struct xfs_ibulk                *breq,
 158         const struct xfs_bulkstat       *bstat)
 159 {
 160         if (copy_to_user(breq->ubuffer, bstat, sizeof(struct xfs_bulkstat)))
 161                 return -EFAULT;
 162         return xfs_ibulk_advance(breq, sizeof(struct xfs_bulkstat));
 163 }
 164
 165 /*
 166  * Check the incoming bulk request @hdr from userspace and initialize the
 167  * internal @breq bulk request appropriately.  Returns 0 if the bulk request
 168  * should proceed; -ECANCELED if there's nothing to do; or the usual
 169  * negative error code.
 170  */
 171 static int
 172 xfs_bulk_ireq_setup(
 173         struct xfs_mount        *mp,
 174         const struct xfs_bulk_ireq *hdr,
 175         struct xfs_ibulk        *breq,
 176         void __user             *ubuffer)
 177 {
 178         if (hdr->icount == 0 ||
 179             (hdr->flags & ~XFS_BULK_IREQ_FLAGS_ALL) ||
 180             memchr_inv(hdr->reserved, 0, sizeof(hdr->reserved)))
 181                 return -EINVAL;
 182
 183         breq->startino = hdr->ino;
 184         breq->ubuffer = ubuffer;
 185         breq->icount = hdr->icount;
 186         breq->ocount = 0;
 187         breq->flags = 0;
 188
 189         /*
 190          * The @ino parameter is a special value, so we must look it up here.
 191          * We're not allowed to have IREQ_AGNO, and we only return one inode
 192          * worth of data.
 193          */
 194         if (hdr->flags & XFS_BULK_IREQ_SPECIAL) {
 195                 if (hdr->flags & XFS_BULK_IREQ_AGNO)
 196                         return -EINVAL;
 197
 198                 switch (hdr->ino) {
 199                 case XFS_BULK_IREQ_SPECIAL_ROOT:
 200                         breq->startino = mp->m_sb.sb_rootino;
 201                         break;
 202                 default:
 203                         return -EINVAL;
 204                 }
 205                 breq->icount = 1;
 206         }
 207
 208         /*
 209          * The IREQ_AGNO flag means that we only want results from a given AG.
 210          * If @hdr->ino is zero, we start iterating in that AG.  If @hdr->ino is
 211          * beyond the specified AG then we return no results.
 212          */
 213         if (hdr->flags & XFS_BULK_IREQ_AGNO) {
 214                 if (hdr->agno >= mp->m_sb.sb_agcount)
 215                         return -EINVAL;
 216
 217                 if (breq->startino == 0)
 218                         breq->startino = XFS_AGINO_TO_INO(mp, hdr->agno, 0);
 219                 else if (XFS_INO_TO_AGNO(mp, breq->startino) < hdr->agno)
 220                         return -EINVAL;
 221
 222                 breq->flags |= XFS_IBULK_SAME_AG;
 223
 224                 /* Asking for an inode past the end of the AG?  We're done! */
 225                 if (XFS_INO_TO_AGNO(mp, breq->startino) > hdr->agno)
 226                         return -ECANCELED;
 227         } else if (hdr->agno)
 228                 return -EINVAL;
 229
 230         /* Asking for an inode past the end of the FS?  We're done! */
 231         if (XFS_INO_TO_AGNO(mp, breq->startino) >= mp->m_sb.sb_agcount)
 232                 return -ECANCELED;
 233
 234         if (hdr->flags & XFS_BULK_IREQ_NREXT64)
 235                 breq->flags |= XFS_IBULK_NREXT64;
 236
 237         /* Caller wants to see metadata directories in bulkstat output. */
 238         if (hdr->flags & XFS_BULK_IREQ_METADIR)
 239                 breq->flags |= XFS_IBULK_METADIR;
 240
 241         return 0;
 242 }
 243
 244 /*
 245  * Update the userspace bulk request @hdr to reflect the end state of the
 246  * internal bulk request @breq.
 247  */
 248 static void
 249 xfs_bulk_ireq_teardown(
 250         struct xfs_bulk_ireq    *hdr,
 251         struct xfs_ibulk        *breq)
 252 {
 253         hdr->ino = breq->startino;
 254         hdr->ocount = breq->ocount;
 255 }
 256
 257 /* Handle the v5 bulkstat ioctl. */
 258 STATIC int
 259 xfs_ioc_bulkstat(
 260         struct file                     *file,
 261         unsigned int                    cmd,
 262         struct xfs_bulkstat_req __user  *arg)
 263 {
 264         struct xfs_mount                *mp = XFS_I(file_inode(file))->i_mount;
 265         struct xfs_bulk_ireq            hdr;
 266         struct xfs_ibulk                breq = {
 267                 .mp                     = mp,
 268                 .idmap                  = file_mnt_idmap(file),
 269         };
 270         int                             error;
 271
 272         if (!capable(CAP_SYS_ADMIN))
 273                 return -EPERM;
 274
 275         if (xfs_is_shutdown(mp))
 276                 return -EIO;
 277
 278         if (copy_from_user(&hdr, &arg->hdr, sizeof(hdr)))
 279                 return -EFAULT;
 280
 281         error = xfs_bulk_ireq_setup(mp, &hdr, &breq, arg->bulkstat);
 282         if (error == -ECANCELED)
 283                 goto out_teardown;
 284         if (error < 0)
 285                 return error;
 286
 287         error = xfs_bulkstat(&breq, xfs_bulkstat_fmt);
 288         if (error)
 289                 return error;
 290
 291 out_teardown:
 292         xfs_bulk_ireq_teardown(&hdr, &breq);
 293         if (copy_to_user(&arg->hdr, &hdr, sizeof(hdr)))
 294                 return -EFAULT;
 295
 296         return 0;
 297 }
 298
 299 STATIC int
 300 xfs_inumbers_fmt(
 301         struct xfs_ibulk                *breq,
 302         const struct xfs_inumbers       *igrp)
 303 {
 304         if (copy_to_user(breq->ubuffer, igrp, sizeof(struct xfs_inumbers)))
 305                 return -EFAULT;
 306         return xfs_ibulk_advance(breq, sizeof(struct xfs_inumbers));
 307 }
 308
 309 /* Handle the v5 inumbers ioctl. */
 310 STATIC int
 311 xfs_ioc_inumbers(
 312         struct xfs_mount                *mp,
 313         unsigned int                    cmd,
 314         struct xfs_inumbers_req __user  *arg)
 315 {
 316         struct xfs_bulk_ireq            hdr;
 317         struct xfs_ibulk                breq = {
 318                 .mp                     = mp,
 319         };
 320         int                             error;
 321
 322         if (!capable(CAP_SYS_ADMIN))
 323                 return -EPERM;
 324
 325         if (xfs_is_shutdown(mp))
 326                 return -EIO;
 327
 328         if (copy_from_user(&hdr, &arg->hdr, sizeof(hdr)))
 329                 return -EFAULT;
 330
 331         if (hdr.flags & XFS_BULK_IREQ_METADIR)
 332                 return -EINVAL;
 333
 334         error = xfs_bulk_ireq_setup(mp, &hdr, &breq, arg->inumbers);
 335         if (error == -ECANCELED)
 336                 goto out_teardown;
 337         if (error < 0)
 338                 return error;
 339
 340         error = xfs_inumbers(&breq, xfs_inumbers_fmt);
 341         if (error)
 342                 return error;
 343
 344 out_teardown:
 345         xfs_bulk_ireq_teardown(&hdr, &breq);
 346         if (copy_to_user(&arg->hdr, &hdr, sizeof(hdr)))
 347                 return -EFAULT;
 348
 349         return 0;
 350 }
 351
 352 STATIC int
 353 xfs_ioc_fsgeometry(
 354         struct xfs_mount        *mp,
 355         void                    __user *arg,
 356         int                     struct_version)
 357 {
 358         struct xfs_fsop_geom    fsgeo;
 359         size_t                  len;
 360
 361         xfs_fs_geometry(mp, &fsgeo, struct_version);
 362
 363         if (struct_version <= 3)
 364                 len = sizeof(struct xfs_fsop_geom_v1);
 365         else if (struct_version == 4)
 366                 len = sizeof(struct xfs_fsop_geom_v4);
 367         else {
 368                 xfs_fsop_geom_health(mp, &fsgeo);
 369                 len = sizeof(fsgeo);
 370         }
 371
 372         if (copy_to_user(arg, &fsgeo, len))
 373                 return -EFAULT;
 374         return 0;
 375 }
 376
 377 STATIC int
 378 xfs_ioc_ag_geometry(
 379         struct xfs_mount        *mp,
 380         void                    __user *arg)
 381 {
 382         struct xfs_perag        *pag;
 383         struct xfs_ag_geometry  ageo;
 384         int                     error;
 385
 386         if (copy_from_user(&ageo, arg, sizeof(ageo)))
 387                 return -EFAULT;
 388         if (ageo.ag_flags)
 389                 return -EINVAL;
 390         if (memchr_inv(&ageo.ag_reserved, 0, sizeof(ageo.ag_reserved)))
 391                 return -EINVAL;
 392
 393         pag = xfs_perag_get(mp, ageo.ag_number);
 394         if (!pag)
 395                 return -EINVAL;
 396
 397         error = xfs_ag_get_geometry(pag, &ageo);
 398         xfs_perag_put(pag);
 399         if (error)
 400                 return error;
 401
 402         if (copy_to_user(arg, &ageo, sizeof(ageo)))
 403                 return -EFAULT;
 404         return 0;
 405 }
 406
 407 STATIC int
 408 xfs_ioc_rtgroup_geometry(
 409         struct xfs_mount        *mp,
 410         void                    __user *arg)
 411 {
 412         struct xfs_rtgroup      *rtg;
 413         struct xfs_rtgroup_geometry rgeo;
 414         int                     error;
 415
 416         if (copy_from_user(&rgeo, arg, sizeof(rgeo)))
 417                 return -EFAULT;
 418         if (rgeo.rg_flags)
 419                 return -EINVAL;
 420         if (memchr_inv(&rgeo.rg_reserved, 0, sizeof(rgeo.rg_reserved)))
 421                 return -EINVAL;
 422         if (!xfs_has_rtgroups(mp))
 423                 return -EINVAL;
 424
 425         rtg = xfs_rtgroup_get(mp, rgeo.rg_number);
 426         if (!rtg)
 427                 return -EINVAL;
 428
 429         error = xfs_rtgroup_get_geometry(rtg, &rgeo);
 430         xfs_rtgroup_put(rtg);
 431         if (error)
 432                 return error;
 433
 434         if (copy_to_user(arg, &rgeo, sizeof(rgeo)))
 435                 return -EFAULT;
 436         return 0;
 437 }
 438
 439 /*
 440  * Linux extended inode flags interface.
 441  */
 442
 443 static void
 444 xfs_fill_fsxattr(
 445         struct xfs_inode        *ip,
 446         int                     whichfork,
 447         struct fileattr         *fa)
 448 {
 449         struct xfs_mount        *mp = ip->i_mount;
 450         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
 451
 452         fileattr_fill_xflags(fa, xfs_ip2xflags(ip));
 453
 454         if (ip->i_diflags & XFS_DIFLAG_EXTSIZE) {
 455                 fa->fsx_extsize = XFS_FSB_TO_B(mp, ip->i_extsize);
 456         } else if (ip->i_diflags & XFS_DIFLAG_EXTSZINHERIT) {
 457                 /*
 458                  * Don't let a misaligned extent size hint on a directory
 459                  * escape to userspace if it won't pass the setattr checks
 460                  * later.
 461                  */
 462                 if ((ip->i_diflags & XFS_DIFLAG_RTINHERIT) &&
 463                     xfs_extlen_to_rtxmod(mp, ip->i_extsize) > 0) {
 464                         fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE |
 465                                             FS_XFLAG_EXTSZINHERIT);
 466                         fa->fsx_extsize = 0;
 467                 } else {
 468                         fa->fsx_extsize = XFS_FSB_TO_B(mp, ip->i_extsize);
 469                 }
 470         }
 471
 472         if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
 473                 fa->fsx_cowextsize = XFS_FSB_TO_B(mp, ip->i_cowextsize);
 474         fa->fsx_projid = ip->i_projid;
 475         if (ifp && !xfs_need_iread_extents(ifp))
 476                 fa->fsx_nextents = xfs_iext_count(ifp);
 477         else
 478                 fa->fsx_nextents = xfs_ifork_nextents(ifp);
 479 }
 480
 481 STATIC int
 482 xfs_ioc_fsgetxattra(
 483         xfs_inode_t             *ip,
 484         void                    __user *arg)
 485 {
 486         struct fileattr         fa;
 487
 488         xfs_ilock(ip, XFS_ILOCK_SHARED);
 489         xfs_fill_fsxattr(ip, XFS_ATTR_FORK, &fa);
 490         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 491
 492         return copy_fsxattr_to_user(&fa, arg);
 493 }
 494
 495 int
 496 xfs_fileattr_get(
 497         struct dentry           *dentry,
 498         struct fileattr         *fa)
 499 {
 500         struct xfs_inode        *ip = XFS_I(d_inode(dentry));
 501
 502         if (d_is_special(dentry))
 503                 return -ENOTTY;
 504
 505         xfs_ilock(ip, XFS_ILOCK_SHARED);
 506         xfs_fill_fsxattr(ip, XFS_DATA_FORK, fa);
 507         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 508
 509         return 0;
 510 }
 511
 512 static int
 513 xfs_ioctl_setattr_xflags(
 514         struct xfs_trans        *tp,
 515         struct xfs_inode        *ip,
 516         struct fileattr         *fa)
 517 {
 518         struct xfs_mount        *mp = ip->i_mount;
 519         bool                    rtflag = (fa->fsx_xflags & FS_XFLAG_REALTIME);
 520         uint64_t                i_flags2;
 521
 522         if (rtflag != XFS_IS_REALTIME_INODE(ip)) {
 523                 /* Can't change realtime flag if any extents are allocated. */
 524                 if (xfs_inode_has_filedata(ip))
 525                         return -EINVAL;
 526
 527                 /*
 528                  * If S_DAX is enabled on this file, we can only switch the
 529                  * device if both support fsdax.  We can't update S_DAX because
 530                  * there might be other threads walking down the access paths.
 531                  */
 532                 if (IS_DAX(VFS_I(ip)) &&
 533                     (mp->m_ddev_targp->bt_daxdev == NULL ||
 534                      (mp->m_rtdev_targp &&
 535                       mp->m_rtdev_targp->bt_daxdev == NULL)))
 536                         return -EINVAL;
 537         }
 538
 539         if (rtflag) {
 540                 /* If realtime flag is set then must have realtime device */
 541                 if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
 542                     xfs_extlen_to_rtxmod(mp, ip->i_extsize))
 543                         return -EINVAL;
 544
 545                 /* Clear reflink if we are actually able to set the rt flag. */
 546                 if (xfs_is_reflink_inode(ip))
 547                         ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
 548         }
 549
 550         /* diflags2 only valid for v3 inodes. */
 551         i_flags2 = xfs_flags2diflags2(ip, fa->fsx_xflags);
 552         if (i_flags2 && !xfs_has_v3inodes(mp))
 553                 return -EINVAL;
 554
 555         ip->i_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
 556         ip->i_diflags2 = i_flags2;
 557
 558         xfs_diflags_to_iflags(ip, false);
 559
 560         /*
 561          * Make the stable writes flag match that of the device the inode
 562          * resides on when flipping the RT flag.
 563          */
 564         if (rtflag != XFS_IS_REALTIME_INODE(ip) && S_ISREG(VFS_I(ip)->i_mode))
 565                 xfs_update_stable_writes(ip);
 566
 567         xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
 568         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 569         XFS_STATS_INC(mp, xs_ig_attrchg);
 570         return 0;
 571 }
 572
 573 static void
 574 xfs_ioctl_setattr_prepare_dax(
 575         struct xfs_inode        *ip,
 576         struct fileattr         *fa)
 577 {
 578         struct xfs_mount        *mp = ip->i_mount;
 579         struct inode            *inode = VFS_I(ip);
 580
 581         if (S_ISDIR(inode->i_mode))
 582                 return;
 583
 584         if (xfs_has_dax_always(mp) || xfs_has_dax_never(mp))
 585                 return;
 586
 587         if (((fa->fsx_xflags & FS_XFLAG_DAX) &&
 588             !(ip->i_diflags2 & XFS_DIFLAG2_DAX)) ||
 589             (!(fa->fsx_xflags & FS_XFLAG_DAX) &&
 590              (ip->i_diflags2 & XFS_DIFLAG2_DAX)))
 591                 d_mark_dontcache(inode);
 592 }
 593
 594 /*
 595  * Set up the transaction structure for the setattr operation, checking that we
 596  * have permission to do so. On success, return a clean transaction and the
 597  * inode locked exclusively ready for further operation specific checks. On
 598  * failure, return an error without modifying or locking the inode.
 599  */
 600 static struct xfs_trans *
 601 xfs_ioctl_setattr_get_trans(
 602         struct xfs_inode        *ip,
 603         struct xfs_dquot        *pdqp)
 604 {
 605         struct xfs_mount        *mp = ip->i_mount;
 606         struct xfs_trans        *tp;
 607         int                     error = -EROFS;
 608
 609         if (xfs_is_readonly(mp))
 610                 goto out_error;
 611         error = -EIO;
 612         if (xfs_is_shutdown(mp))
 613                 goto out_error;
 614
 615         error = xfs_trans_alloc_ichange(ip, NULL, NULL, pdqp,
 616                         has_capability_noaudit(current, CAP_FOWNER), &tp);
 617         if (error)
 618                 goto out_error;
 619
 620         if (xfs_has_wsync(mp))
 621                 xfs_trans_set_sync(tp);
 622
 623         return tp;
 624
 625 out_error:
 626         return ERR_PTR(error);
 627 }
 628
 629 /*
 630  * Validate a proposed extent size hint.  For regular files, the hint can only
 631  * be changed if no extents are allocated.
 632  */
 633 static int
 634 xfs_ioctl_setattr_check_extsize(
 635         struct xfs_inode        *ip,
 636         struct fileattr         *fa)
 637 {
 638         struct xfs_mount        *mp = ip->i_mount;
 639         xfs_failaddr_t          failaddr;
 640         uint16_t                new_diflags;
 641
 642         if (!fa->fsx_valid)
 643                 return 0;
 644
 645         if (S_ISREG(VFS_I(ip)->i_mode) && xfs_inode_has_filedata(ip) &&
 646             XFS_FSB_TO_B(mp, ip->i_extsize) != fa->fsx_extsize)
 647                 return -EINVAL;
 648
 649         if (fa->fsx_extsize & mp->m_blockmask)
 650                 return -EINVAL;
 651
 652         new_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
 653
 654         /*
 655          * Inode verifiers do not check that the extent size hint is an integer
 656          * multiple of the rt extent size on a directory with both rtinherit
 657          * and extszinherit flags set.  Don't let sysadmins misconfigure
 658          * directories.
 659          */
 660         if ((new_diflags & XFS_DIFLAG_RTINHERIT) &&
 661             (new_diflags & XFS_DIFLAG_EXTSZINHERIT)) {
 662                 unsigned int    rtextsize_bytes;
 663
 664                 rtextsize_bytes = XFS_FSB_TO_B(mp, mp->m_sb.sb_rextsize);
 665                 if (fa->fsx_extsize % rtextsize_bytes)
 666                         return -EINVAL;
 667         }
 668
 669         failaddr = xfs_inode_validate_extsize(ip->i_mount,
 670                         XFS_B_TO_FSB(mp, fa->fsx_extsize),
 671                         VFS_I(ip)->i_mode, new_diflags);
 672         return failaddr != NULL ? -EINVAL : 0;
 673 }
 674
 675 static int
 676 xfs_ioctl_setattr_check_cowextsize(
 677         struct xfs_inode        *ip,
 678         struct fileattr         *fa)
 679 {
 680         struct xfs_mount        *mp = ip->i_mount;
 681         xfs_failaddr_t          failaddr;
 682         uint64_t                new_diflags2;
 683         uint16_t                new_diflags;
 684
 685         if (!fa->fsx_valid)
 686                 return 0;
 687
 688         if (fa->fsx_cowextsize & mp->m_blockmask)
 689                 return -EINVAL;
 690
 691         new_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
 692         new_diflags2 = xfs_flags2diflags2(ip, fa->fsx_xflags);
 693
 694         failaddr = xfs_inode_validate_cowextsize(ip->i_mount,
 695                         XFS_B_TO_FSB(mp, fa->fsx_cowextsize),
 696                         VFS_I(ip)->i_mode, new_diflags, new_diflags2);
 697         return failaddr != NULL ? -EINVAL : 0;
 698 }
 699
 700 static int
 701 xfs_ioctl_setattr_check_projid(
 702         struct xfs_inode        *ip,
 703         struct fileattr         *fa)
 704 {
 705         if (!fa->fsx_valid)
 706                 return 0;
 707
 708         /* Disallow 32bit project ids if 32bit IDs are not enabled. */
 709         if (fa->fsx_projid > (uint16_t)-1 &&
 710             !xfs_has_projid32(ip->i_mount))
 711                 return -EINVAL;
 712         return 0;
 713 }
 714
 715 int
 716 xfs_fileattr_set(
 717         struct mnt_idmap        *idmap,
 718         struct dentry           *dentry,
 719         struct fileattr         *fa)
 720 {
 721         struct xfs_inode        *ip = XFS_I(d_inode(dentry));
 722         struct xfs_mount        *mp = ip->i_mount;
 723         struct xfs_trans        *tp;
 724         struct xfs_dquot        *pdqp = NULL;
 725         struct xfs_dquot        *olddquot = NULL;
 726         int                     error;
 727
 728         trace_xfs_ioctl_setattr(ip);
 729
 730         if (d_is_special(dentry))
 731                 return -ENOTTY;
 732
 733         if (!fa->fsx_valid) {
 734                 if (fa->flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL |
 735                                   FS_NOATIME_FL | FS_NODUMP_FL |
 736                                   FS_SYNC_FL | FS_DAX_FL | FS_PROJINHERIT_FL))
 737                         return -EOPNOTSUPP;
 738         }
 739
 740         error = xfs_ioctl_setattr_check_projid(ip, fa);
 741         if (error)
 742                 return error;
 743
 744         /*
 745          * If disk quotas is on, we make sure that the dquots do exist on disk,
 746          * before we start any other transactions. Trying to do this later
 747          * is messy. We don't care to take a readlock to look at the ids
 748          * in inode here, because we can't hold it across the trans_reserve.
 749          * If the IDs do change before we take the ilock, we're covered
 750          * because the i_*dquot fields will get updated anyway.
 751          */
 752         if (fa->fsx_valid && XFS_IS_QUOTA_ON(mp)) {
 753                 error = xfs_qm_vop_dqalloc(ip, VFS_I(ip)->i_uid,
 754                                 VFS_I(ip)->i_gid, fa->fsx_projid,
 755                                 XFS_QMOPT_PQUOTA, NULL, NULL, &pdqp);
 756                 if (error)
 757                         return error;
 758         }
 759
 760         xfs_ioctl_setattr_prepare_dax(ip, fa);
 761
 762         tp = xfs_ioctl_setattr_get_trans(ip, pdqp);
 763         if (IS_ERR(tp)) {
 764                 error = PTR_ERR(tp);
 765                 goto error_free_dquots;
 766         }
 767
 768         error = xfs_ioctl_setattr_check_extsize(ip, fa);
 769         if (error)
 770                 goto error_trans_cancel;
 771
 772         error = xfs_ioctl_setattr_check_cowextsize(ip, fa);
 773         if (error)
 774                 goto error_trans_cancel;
 775
 776         error = xfs_ioctl_setattr_xflags(tp, ip, fa);
 777         if (error)
 778                 goto error_trans_cancel;
 779
 780         if (!fa->fsx_valid)
 781                 goto skip_xattr;
 782         /*
 783          * Change file ownership.  Must be the owner or privileged.  CAP_FSETID
 784          * overrides the following restrictions:
 785          *
 786          * The set-user-ID and set-group-ID bits of a file will be cleared upon
 787          * successful return from chown()
 788          */
 789
 790         if ((VFS_I(ip)->i_mode & (S_ISUID|S_ISGID)) &&
 791             !capable_wrt_inode_uidgid(idmap, VFS_I(ip), CAP_FSETID))
 792                 VFS_I(ip)->i_mode &= ~(S_ISUID|S_ISGID);
 793
 794         /* Change the ownerships and register project quota modifications */
 795         if (ip->i_projid != fa->fsx_projid) {
 796                 if (XFS_IS_PQUOTA_ON(mp)) {
 797                         olddquot = xfs_qm_vop_chown(tp, ip,
 798                                                 &ip->i_pdquot, pdqp);
 799                 }
 800                 ip->i_projid = fa->fsx_projid;
 801         }
 802
 803         /*
 804          * Only set the extent size hint if we've already determined that the
 805          * extent size hint should be set on the inode. If no extent size flags
 806          * are set on the inode then unconditionally clear the extent size hint.
 807          */
 808         if (ip->i_diflags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
 809                 ip->i_extsize = XFS_B_TO_FSB(mp, fa->fsx_extsize);
 810         else
 811                 ip->i_extsize = 0;
 812
 813         if (xfs_has_v3inodes(mp)) {
 814                 if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
 815                         ip->i_cowextsize = XFS_B_TO_FSB(mp, fa->fsx_cowextsize);
 816                 else
 817                         ip->i_cowextsize = 0;
 818         }
 819
 820 skip_xattr:
 821         error = xfs_trans_commit(tp);
 822
 823         /*
 824          * Release any dquot(s) the inode had kept before chown.
 825          */
 826         xfs_qm_dqrele(olddquot);
 827         xfs_qm_dqrele(pdqp);
 828
 829         return error;
 830
 831 error_trans_cancel:
 832         xfs_trans_cancel(tp);
 833 error_free_dquots:
 834         xfs_qm_dqrele(pdqp);
 835         return error;
 836 }
 837
 838 static bool
 839 xfs_getbmap_format(
 840         struct kgetbmap         *p,
 841         struct getbmapx __user  *u,
 842         size_t                  recsize)
 843 {
 844         if (put_user(p->bmv_offset, &u->bmv_offset) ||
 845             put_user(p->bmv_block, &u->bmv_block) ||
 846             put_user(p->bmv_length, &u->bmv_length) ||
 847             put_user(0, &u->bmv_count) ||
 848             put_user(0, &u->bmv_entries))
 849                 return false;
 850         if (recsize < sizeof(struct getbmapx))
 851                 return true;
 852         if (put_user(0, &u->bmv_iflags) ||
 853             put_user(p->bmv_oflags, &u->bmv_oflags) ||
 854             put_user(0, &u->bmv_unused1) ||
 855             put_user(0, &u->bmv_unused2))
 856                 return false;
 857         return true;
 858 }
 859
 860 STATIC int
 861 xfs_ioc_getbmap(
 862         struct file             *file,
 863         unsigned int            cmd,
 864         void                    __user *arg)
 865 {
 866         struct getbmapx         bmx = { 0 };
 867         struct kgetbmap         *buf;
 868         size_t                  recsize;
 869         int                     error, i;
 870
 871         switch (cmd) {
 872         case XFS_IOC_GETBMAPA:
 873                 bmx.bmv_iflags = BMV_IF_ATTRFORK;
 874                 fallthrough;
 875         case XFS_IOC_GETBMAP:
 876                 /* struct getbmap is a strict subset of struct getbmapx. */
 877                 recsize = sizeof(struct getbmap);
 878                 break;
 879         case XFS_IOC_GETBMAPX:
 880                 recsize = sizeof(struct getbmapx);
 881                 break;
 882         default:
 883                 return -EINVAL;
 884         }
 885
 886         if (copy_from_user(&bmx, arg, recsize))
 887                 return -EFAULT;
 888
 889         if (bmx.bmv_count < 2)
 890                 return -EINVAL;
 891         if (bmx.bmv_count >= INT_MAX / recsize)
 892                 return -ENOMEM;
 893
 894         buf = kvcalloc(bmx.bmv_count, sizeof(*buf), GFP_KERNEL);
 895         if (!buf)
 896                 return -ENOMEM;
 897
 898         error = xfs_getbmap(XFS_I(file_inode(file)), &bmx, buf);
 899         if (error)
 900                 goto out_free_buf;
 901
 902         error = -EFAULT;
 903         if (copy_to_user(arg, &bmx, recsize))
 904                 goto out_free_buf;
 905         arg += recsize;
 906
 907         for (i = 0; i < bmx.bmv_entries; i++) {
 908                 if (!xfs_getbmap_format(buf + i, arg, recsize))
 909                         goto out_free_buf;
 910                 arg += recsize;
 911         }
 912
 913         error = 0;
 914 out_free_buf:
 915         kvfree(buf);
 916         return error;
 917 }
 918
 919 int
 920 xfs_ioc_swapext(
 921         xfs_swapext_t   *sxp)
 922 {
 923         xfs_inode_t     *ip, *tip;
 924
 925         /* Pull information for the target fd */
 926         CLASS(fd, f)((int)sxp->sx_fdtarget);
 927         if (fd_empty(f))
 928                 return -EINVAL;
 929
 930         if (!(fd_file(f)->f_mode & FMODE_WRITE) ||
 931             !(fd_file(f)->f_mode & FMODE_READ) ||
 932             (fd_file(f)->f_flags & O_APPEND))
 933                 return -EBADF;
 934
 935         CLASS(fd, tmp)((int)sxp->sx_fdtmp);
 936         if (fd_empty(tmp))
 937                 return -EINVAL;
 938
 939         if (!(fd_file(tmp)->f_mode & FMODE_WRITE) ||
 940             !(fd_file(tmp)->f_mode & FMODE_READ) ||
 941             (fd_file(tmp)->f_flags & O_APPEND))
 942                 return -EBADF;
 943
 944         if (IS_SWAPFILE(file_inode(fd_file(f))) ||
 945             IS_SWAPFILE(file_inode(fd_file(tmp))))
 946                 return -EINVAL;
 947
 948         /*
 949          * We need to ensure that the fds passed in point to XFS inodes
 950          * before we cast and access them as XFS structures as we have no
 951          * control over what the user passes us here.
 952          */
 953         if (fd_file(f)->f_op != &xfs_file_operations ||
 954             fd_file(tmp)->f_op != &xfs_file_operations)
 955                 return -EINVAL;
 956
 957         ip = XFS_I(file_inode(fd_file(f)));
 958         tip = XFS_I(file_inode(fd_file(tmp)));
 959
 960         if (ip->i_mount != tip->i_mount)
 961                 return -EINVAL;
 962
 963         if (ip->i_ino == tip->i_ino)
 964                 return -EINVAL;
 965
 966         if (xfs_is_shutdown(ip->i_mount))
 967                 return -EIO;
 968
 969         return xfs_swap_extents(ip, tip, sxp);
 970 }
 971
 972 static int
 973 xfs_ioc_getlabel(
 974         struct xfs_mount        *mp,
 975         char                    __user *user_label)
 976 {
 977         struct xfs_sb           *sbp = &mp->m_sb;
 978         char                    label[XFSLABEL_MAX + 1];
 979
 980         /* Paranoia */
 981         BUILD_BUG_ON(sizeof(sbp->sb_fname) > FSLABEL_MAX);
 982
 983         /* 1 larger than sb_fname, so this ensures a trailing NUL char */
 984         memset(label, 0, sizeof(label));
 985         spin_lock(&mp->m_sb_lock);
 986         strncpy(label, sbp->sb_fname, XFSLABEL_MAX);
 987         spin_unlock(&mp->m_sb_lock);
 988
 989         if (copy_to_user(user_label, label, sizeof(label)))
 990                 return -EFAULT;
 991         return 0;
 992 }
 993
 994 static int
 995 xfs_ioc_setlabel(
 996         struct file             *filp,
 997         struct xfs_mount        *mp,
 998         char                    __user *newlabel)
 999 {
1000         struct xfs_sb           *sbp = &mp->m_sb;
1001         char                    label[XFSLABEL_MAX + 1];
1002         size_t                  len;
1003         int                     error;
1004
1005         if (!capable(CAP_SYS_ADMIN))
1006                 return -EPERM;
1007         /*
1008          * The generic ioctl allows up to FSLABEL_MAX chars, but XFS is much
1009          * smaller, at 12 bytes.  We copy one more to be sure we find the
1010          * (required) NULL character to test the incoming label length.
1011          * NB: The on disk label doesn't need to be null terminated.
1012          */
1013         if (copy_from_user(label, newlabel, XFSLABEL_MAX + 1))
1014                 return -EFAULT;
1015         len = strnlen(label, XFSLABEL_MAX + 1);
1016         if (len > sizeof(sbp->sb_fname))
1017                 return -EINVAL;
1018
1019         error = mnt_want_write_file(filp);
1020         if (error)
1021                 return error;
1022
1023         spin_lock(&mp->m_sb_lock);
1024         memset(sbp->sb_fname, 0, sizeof(sbp->sb_fname));
1025         memcpy(sbp->sb_fname, label, len);
1026         spin_unlock(&mp->m_sb_lock);
1027
1028         /*
1029          * Now we do several things to satisfy userspace.
1030          * In addition to normal logging of the primary superblock, we also
1031          * immediately write these changes to sector zero for the primary, then
1032          * update all backup supers (as xfs_db does for a label change), then
1033          * invalidate the block device page cache.  This is so that any prior
1034          * buffered reads from userspace (i.e. from blkid) are invalidated,
1035          * and userspace will see the newly-written label.
1036          */
1037         error = xfs_sync_sb_buf(mp, true);
1038         if (error)
1039                 goto out;
1040         /*
1041          * growfs also updates backup supers so lock against that.
1042          */
1043         mutex_lock(&mp->m_growlock);
1044         error = xfs_update_secondary_sbs(mp);
1045         mutex_unlock(&mp->m_growlock);
1046
1047         invalidate_bdev(mp->m_ddev_targp->bt_bdev);
1048         if (xfs_has_rtsb(mp) && mp->m_rtdev_targp)
1049                 invalidate_bdev(mp->m_rtdev_targp->bt_bdev);
1050
1051 out:
1052         mnt_drop_write_file(filp);
1053         return error;
1054 }
1055
1056 static inline int
1057 xfs_fs_eofblocks_from_user(
1058         struct xfs_fs_eofblocks         *src,
1059         struct xfs_icwalk               *dst)
1060 {
1061         if (src->eof_version != XFS_EOFBLOCKS_VERSION)
1062                 return -EINVAL;
1063
1064         if (src->eof_flags & ~XFS_EOF_FLAGS_VALID)
1065                 return -EINVAL;
1066
1067         if (memchr_inv(&src->pad32, 0, sizeof(src->pad32)) ||
1068             memchr_inv(src->pad64, 0, sizeof(src->pad64)))
1069                 return -EINVAL;
1070
1071         dst->icw_flags = 0;
1072         if (src->eof_flags & XFS_EOF_FLAGS_SYNC)
1073                 dst->icw_flags |= XFS_ICWALK_FLAG_SYNC;
1074         if (src->eof_flags & XFS_EOF_FLAGS_UID)
1075                 dst->icw_flags |= XFS_ICWALK_FLAG_UID;
1076         if (src->eof_flags & XFS_EOF_FLAGS_GID)
1077                 dst->icw_flags |= XFS_ICWALK_FLAG_GID;
1078         if (src->eof_flags & XFS_EOF_FLAGS_PRID)
1079                 dst->icw_flags |= XFS_ICWALK_FLAG_PRID;
1080         if (src->eof_flags & XFS_EOF_FLAGS_MINFILESIZE)
1081                 dst->icw_flags |= XFS_ICWALK_FLAG_MINFILESIZE;
1082
1083         dst->icw_prid = src->eof_prid;
1084         dst->icw_min_file_size = src->eof_min_file_size;
1085
1086         dst->icw_uid = INVALID_UID;
1087         if (src->eof_flags & XFS_EOF_FLAGS_UID) {
1088                 dst->icw_uid = make_kuid(current_user_ns(), src->eof_uid);
1089                 if (!uid_valid(dst->icw_uid))
1090                         return -EINVAL;
1091         }
1092
1093         dst->icw_gid = INVALID_GID;
1094         if (src->eof_flags & XFS_EOF_FLAGS_GID) {
1095                 dst->icw_gid = make_kgid(current_user_ns(), src->eof_gid);
1096                 if (!gid_valid(dst->icw_gid))
1097                         return -EINVAL;
1098         }
1099         return 0;
1100 }
1101
1102 static int
1103 xfs_ioctl_getset_resblocks(
1104         struct file             *filp,
1105         unsigned int            cmd,
1106         void __user             *arg)
1107 {
1108         struct xfs_mount        *mp = XFS_I(file_inode(filp))->i_mount;
1109         struct xfs_fsop_resblks fsop = { };
1110         int                     error;
1111
1112         if (!capable(CAP_SYS_ADMIN))
1113                 return -EPERM;
1114
1115         if (cmd == XFS_IOC_SET_RESBLKS) {
1116                 if (xfs_is_readonly(mp))
1117                         return -EROFS;
1118
1119                 if (copy_from_user(&fsop, arg, sizeof(fsop)))
1120                         return -EFAULT;
1121
1122                 error = mnt_want_write_file(filp);
1123                 if (error)
1124                         return error;
1125                 error = xfs_reserve_blocks(mp, fsop.resblks);
1126                 mnt_drop_write_file(filp);
1127                 if (error)
1128                         return error;
1129         }
1130
1131         spin_lock(&mp->m_sb_lock);
1132         fsop.resblks = mp->m_resblks;
1133         fsop.resblks_avail = mp->m_resblks_avail;
1134         spin_unlock(&mp->m_sb_lock);
1135
1136         if (copy_to_user(arg, &fsop, sizeof(fsop)))
1137                 return -EFAULT;
1138         return 0;
1139 }
1140
1141 static int
1142 xfs_ioctl_fs_counts(
1143         struct xfs_mount        *mp,
1144         struct xfs_fsop_counts __user   *uarg)
1145 {
1146         struct xfs_fsop_counts  out = {
1147                 .allocino = percpu_counter_read_positive(&mp->m_icount),
1148                 .freeino  = percpu_counter_read_positive(&mp->m_ifree),
1149                 .freedata = percpu_counter_read_positive(&mp->m_fdblocks) -
1150                                 xfs_fdblocks_unavailable(mp),
1151                 .freertx  = percpu_counter_read_positive(&mp->m_frextents),
1152         };
1153
1154         if (copy_to_user(uarg, &out, sizeof(out)))
1155                 return -EFAULT;
1156         return 0;
1157 }
1158
1159 /*
1160  * These long-unused ioctls were removed from the official ioctl API in 5.17,
1161  * but retain these definitions so that we can log warnings about them.
1162  */
1163 #define XFS_IOC_ALLOCSP         _IOW ('X', 10, struct xfs_flock64)
1164 #define XFS_IOC_FREESP          _IOW ('X', 11, struct xfs_flock64)
1165 #define XFS_IOC_ALLOCSP64       _IOW ('X', 36, struct xfs_flock64)
1166 #define XFS_IOC_FREESP64        _IOW ('X', 37, struct xfs_flock64)
1167
1168 /*
1169  * Note: some of the ioctl's return positive numbers as a
1170  * byte count indicating success, such as readlink_by_handle.
1171  * So we don't "sign flip" like most other routines.  This means
1172  * true errors need to be returned as a negative value.
1173  */
1174 long
1175 xfs_file_ioctl(
1176         struct file             *filp,
1177         unsigned int            cmd,
1178         unsigned long           p)
1179 {
1180         struct inode            *inode = file_inode(filp);
1181         struct xfs_inode        *ip = XFS_I(inode);
1182         struct xfs_mount        *mp = ip->i_mount;
1183         void                    __user *arg = (void __user *)p;
1184         int                     error;
1185
1186         trace_xfs_file_ioctl(ip);
1187
1188         switch (cmd) {
1189         case FITRIM:
1190                 return xfs_ioc_trim(mp, arg);
1191         case FS_IOC_GETFSLABEL:
1192                 return xfs_ioc_getlabel(mp, arg);
1193         case FS_IOC_SETFSLABEL:
1194                 return xfs_ioc_setlabel(filp, mp, arg);
1195         case XFS_IOC_ALLOCSP:
1196         case XFS_IOC_FREESP:
1197         case XFS_IOC_ALLOCSP64:
1198         case XFS_IOC_FREESP64:
1199                 xfs_warn_once(mp,
1200         "%s should use fallocate; XFS_IOC_{ALLOC,FREE}SP ioctl unsupported",
1201                                 current->comm);
1202                 return -ENOTTY;
1203         case XFS_IOC_DIOINFO: {
1204                 struct xfs_buftarg      *target = xfs_inode_buftarg(ip);
1205                 struct dioattr          da;
1206
1207                 da.d_mem =  da.d_miniosz = target->bt_logical_sectorsize;
1208                 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1209
1210                 if (copy_to_user(arg, &da, sizeof(da)))
1211                         return -EFAULT;
1212                 return 0;
1213         }
1214
1215         case XFS_IOC_FSBULKSTAT_SINGLE:
1216         case XFS_IOC_FSBULKSTAT:
1217         case XFS_IOC_FSINUMBERS:
1218                 return xfs_ioc_fsbulkstat(filp, cmd, arg);
1219
1220         case XFS_IOC_BULKSTAT:
1221                 return xfs_ioc_bulkstat(filp, cmd, arg);
1222         case XFS_IOC_INUMBERS:
1223                 return xfs_ioc_inumbers(mp, cmd, arg);
1224
1225         case XFS_IOC_FSGEOMETRY_V1:
1226                 return xfs_ioc_fsgeometry(mp, arg, 3);
1227         case XFS_IOC_FSGEOMETRY_V4:
1228                 return xfs_ioc_fsgeometry(mp, arg, 4);
1229         case XFS_IOC_FSGEOMETRY:
1230                 return xfs_ioc_fsgeometry(mp, arg, 5);
1231
1232         case XFS_IOC_AG_GEOMETRY:
1233                 return xfs_ioc_ag_geometry(mp, arg);
1234         case XFS_IOC_RTGROUP_GEOMETRY:
1235                 return xfs_ioc_rtgroup_geometry(mp, arg);
1236
1237         case XFS_IOC_GETVERSION:
1238                 return put_user(inode->i_generation, (int __user *)arg);
1239
1240         case XFS_IOC_FSGETXATTRA:
1241                 return xfs_ioc_fsgetxattra(ip, arg);
1242         case XFS_IOC_GETPARENTS:
1243                 return xfs_ioc_getparents(filp, arg);
1244         case XFS_IOC_GETPARENTS_BY_HANDLE:
1245                 return xfs_ioc_getparents_by_handle(filp, arg);
1246         case XFS_IOC_GETBMAP:
1247         case XFS_IOC_GETBMAPA:
1248         case XFS_IOC_GETBMAPX:
1249                 return xfs_ioc_getbmap(filp, cmd, arg);
1250
1251         case FS_IOC_GETFSMAP:
1252                 return xfs_ioc_getfsmap(ip, arg);
1253
1254         case XFS_IOC_SCRUBV_METADATA:
1255                 return xfs_ioc_scrubv_metadata(filp, arg);
1256         case XFS_IOC_SCRUB_METADATA:
1257                 return xfs_ioc_scrub_metadata(filp, arg);
1258
1259         case XFS_IOC_FD_TO_HANDLE:
1260         case XFS_IOC_PATH_TO_HANDLE:
1261         case XFS_IOC_PATH_TO_FSHANDLE: {
1262                 xfs_fsop_handlereq_t    hreq;
1263
1264                 if (copy_from_user(&hreq, arg, sizeof(hreq)))
1265                         return -EFAULT;
1266                 return xfs_find_handle(cmd, &hreq);
1267         }
1268         case XFS_IOC_OPEN_BY_HANDLE: {
1269                 xfs_fsop_handlereq_t    hreq;
1270
1271                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1272                         return -EFAULT;
1273                 return xfs_open_by_handle(filp, &hreq);
1274         }
1275
1276         case XFS_IOC_READLINK_BY_HANDLE: {
1277                 xfs_fsop_handlereq_t    hreq;
1278
1279                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1280                         return -EFAULT;
1281                 return xfs_readlink_by_handle(filp, &hreq);
1282         }
1283         case XFS_IOC_ATTRLIST_BY_HANDLE:
1284                 return xfs_attrlist_by_handle(filp, arg);
1285
1286         case XFS_IOC_ATTRMULTI_BY_HANDLE:
1287                 return xfs_attrmulti_by_handle(filp, arg);
1288
1289         case XFS_IOC_SWAPEXT: {
1290                 struct xfs_swapext      sxp;
1291
1292                 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
1293                         return -EFAULT;
1294                 error = mnt_want_write_file(filp);
1295                 if (error)
1296                         return error;
1297                 error = xfs_ioc_swapext(&sxp);
1298                 mnt_drop_write_file(filp);
1299                 return error;
1300         }
1301
1302         case XFS_IOC_FSCOUNTS:
1303                 return xfs_ioctl_fs_counts(mp, arg);
1304
1305         case XFS_IOC_SET_RESBLKS:
1306         case XFS_IOC_GET_RESBLKS:
1307                 return xfs_ioctl_getset_resblocks(filp, cmd, arg);
1308
1309         case XFS_IOC_FSGROWFSDATA: {
1310                 struct xfs_growfs_data in;
1311
1312                 if (copy_from_user(&in, arg, sizeof(in)))
1313                         return -EFAULT;
1314
1315                 error = mnt_want_write_file(filp);
1316                 if (error)
1317                         return error;
1318                 error = xfs_growfs_data(mp, &in);
1319                 mnt_drop_write_file(filp);
1320                 return error;
1321         }
1322
1323         case XFS_IOC_FSGROWFSLOG: {
1324                 struct xfs_growfs_log in;
1325
1326                 if (copy_from_user(&in, arg, sizeof(in)))
1327                         return -EFAULT;
1328
1329                 error = mnt_want_write_file(filp);
1330                 if (error)
1331                         return error;
1332                 error = xfs_growfs_log(mp, &in);
1333                 mnt_drop_write_file(filp);
1334                 return error;
1335         }
1336
1337         case XFS_IOC_FSGROWFSRT: {
1338                 xfs_growfs_rt_t in;
1339
1340                 if (copy_from_user(&in, arg, sizeof(in)))
1341                         return -EFAULT;
1342
1343                 error = mnt_want_write_file(filp);
1344                 if (error)
1345                         return error;
1346                 error = xfs_growfs_rt(mp, &in);
1347                 mnt_drop_write_file(filp);
1348                 return error;
1349         }
1350
1351         case XFS_IOC_GOINGDOWN: {
1352                 uint32_t in;
1353
1354                 if (!capable(CAP_SYS_ADMIN))
1355                         return -EPERM;
1356
1357                 if (get_user(in, (uint32_t __user *)arg))
1358                         return -EFAULT;
1359
1360                 return xfs_fs_goingdown(mp, in);
1361         }
1362
1363         case XFS_IOC_ERROR_INJECTION: {
1364                 xfs_error_injection_t in;
1365
1366                 if (!capable(CAP_SYS_ADMIN))
1367                         return -EPERM;
1368
1369                 if (copy_from_user(&in, arg, sizeof(in)))
1370                         return -EFAULT;
1371
1372                 return xfs_errortag_add(mp, in.errtag);
1373         }
1374
1375         case XFS_IOC_ERROR_CLEARALL:
1376                 if (!capable(CAP_SYS_ADMIN))
1377                         return -EPERM;
1378
1379                 return xfs_errortag_clearall(mp);
1380
1381         case XFS_IOC_FREE_EOFBLOCKS: {
1382                 struct xfs_fs_eofblocks eofb;
1383                 struct xfs_icwalk       icw;
1384
1385                 if (!capable(CAP_SYS_ADMIN))
1386                         return -EPERM;
1387
1388                 if (xfs_is_readonly(mp))
1389                         return -EROFS;
1390
1391                 if (copy_from_user(&eofb, arg, sizeof(eofb)))
1392                         return -EFAULT;
1393
1394                 error = xfs_fs_eofblocks_from_user(&eofb, &icw);
1395                 if (error)
1396                         return error;
1397
1398                 trace_xfs_ioc_free_eofblocks(mp, &icw, _RET_IP_);
1399
1400                 sb_start_write(mp->m_super);
1401                 error = xfs_blockgc_free_space(mp, &icw);
1402                 sb_end_write(mp->m_super);
1403                 return error;
1404         }
1405
1406         case XFS_IOC_EXCHANGE_RANGE:
1407                 return xfs_ioc_exchange_range(filp, arg);
1408         case XFS_IOC_START_COMMIT:
1409                 return xfs_ioc_start_commit(filp, arg);
1410         case XFS_IOC_COMMIT_RANGE:
1411                 return xfs_ioc_commit_range(filp, arg);
1412
1413         default:
1414                 return -ENOTTY;
1415         }
1416 }