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                 /*
 474                  * Don't let a misaligned CoW extent size hint on a directory
 475                  * escape to userspace if it won't pass the setattr checks
 476                  * later.
 477                  */
 478                 if ((ip->i_diflags & XFS_DIFLAG_RTINHERIT) &&
 479                     ip->i_cowextsize % mp->m_sb.sb_rextsize > 0) {
 480                         fa->fsx_xflags &= ~FS_XFLAG_COWEXTSIZE;
 481                         fa->fsx_cowextsize = 0;
 482                 } else {
 483                         fa->fsx_cowextsize = XFS_FSB_TO_B(mp, ip->i_cowextsize);
 484                 }
 485         }
 486
 487         fa->fsx_projid = ip->i_projid;
 488         if (ifp && !xfs_need_iread_extents(ifp))
 489                 fa->fsx_nextents = xfs_iext_count(ifp);
 490         else
 491                 fa->fsx_nextents = xfs_ifork_nextents(ifp);
 492 }
 493
 494 STATIC int
 495 xfs_ioc_fsgetxattra(
 496         xfs_inode_t             *ip,
 497         void                    __user *arg)
 498 {
 499         struct fileattr         fa;
 500
 501         xfs_ilock(ip, XFS_ILOCK_SHARED);
 502         xfs_fill_fsxattr(ip, XFS_ATTR_FORK, &fa);
 503         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 504
 505         return copy_fsxattr_to_user(&fa, arg);
 506 }
 507
 508 int
 509 xfs_fileattr_get(
 510         struct dentry           *dentry,
 511         struct fileattr         *fa)
 512 {
 513         struct xfs_inode        *ip = XFS_I(d_inode(dentry));
 514
 515         if (d_is_special(dentry))
 516                 return -ENOTTY;
 517
 518         xfs_ilock(ip, XFS_ILOCK_SHARED);
 519         xfs_fill_fsxattr(ip, XFS_DATA_FORK, fa);
 520         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 521
 522         return 0;
 523 }
 524
 525 static int
 526 xfs_ioctl_setattr_xflags(
 527         struct xfs_trans        *tp,
 528         struct xfs_inode        *ip,
 529         struct fileattr         *fa)
 530 {
 531         struct xfs_mount        *mp = ip->i_mount;
 532         bool                    rtflag = (fa->fsx_xflags & FS_XFLAG_REALTIME);
 533         uint64_t                i_flags2;
 534
 535         if (rtflag != XFS_IS_REALTIME_INODE(ip)) {
 536                 /* Can't change realtime flag if any extents are allocated. */
 537                 if (xfs_inode_has_filedata(ip))
 538                         return -EINVAL;
 539
 540                 /*
 541                  * If S_DAX is enabled on this file, we can only switch the
 542                  * device if both support fsdax.  We can't update S_DAX because
 543                  * there might be other threads walking down the access paths.
 544                  */
 545                 if (IS_DAX(VFS_I(ip)) &&
 546                     (mp->m_ddev_targp->bt_daxdev == NULL ||
 547                      (mp->m_rtdev_targp &&
 548                       mp->m_rtdev_targp->bt_daxdev == NULL)))
 549                         return -EINVAL;
 550         }
 551
 552         if (rtflag) {
 553                 /* If realtime flag is set then must have realtime device */
 554                 if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
 555                     xfs_extlen_to_rtxmod(mp, ip->i_extsize))
 556                         return -EINVAL;
 557         }
 558
 559         /* diflags2 only valid for v3 inodes. */
 560         i_flags2 = xfs_flags2diflags2(ip, fa->fsx_xflags);
 561         if (i_flags2 && !xfs_has_v3inodes(mp))
 562                 return -EINVAL;
 563
 564         ip->i_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
 565         ip->i_diflags2 = i_flags2;
 566
 567         xfs_diflags_to_iflags(ip, false);
 568
 569         /*
 570          * Make the stable writes flag match that of the device the inode
 571          * resides on when flipping the RT flag.
 572          */
 573         if (rtflag != XFS_IS_REALTIME_INODE(ip) && S_ISREG(VFS_I(ip)->i_mode))
 574                 xfs_update_stable_writes(ip);
 575
 576         xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
 577         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 578         XFS_STATS_INC(mp, xs_ig_attrchg);
 579         return 0;
 580 }
 581
 582 static void
 583 xfs_ioctl_setattr_prepare_dax(
 584         struct xfs_inode        *ip,
 585         struct fileattr         *fa)
 586 {
 587         struct xfs_mount        *mp = ip->i_mount;
 588         struct inode            *inode = VFS_I(ip);
 589
 590         if (S_ISDIR(inode->i_mode))
 591                 return;
 592
 593         if (xfs_has_dax_always(mp) || xfs_has_dax_never(mp))
 594                 return;
 595
 596         if (((fa->fsx_xflags & FS_XFLAG_DAX) &&
 597             !(ip->i_diflags2 & XFS_DIFLAG2_DAX)) ||
 598             (!(fa->fsx_xflags & FS_XFLAG_DAX) &&
 599              (ip->i_diflags2 & XFS_DIFLAG2_DAX)))
 600                 d_mark_dontcache(inode);
 601 }
 602
 603 /*
 604  * Set up the transaction structure for the setattr operation, checking that we
 605  * have permission to do so. On success, return a clean transaction and the
 606  * inode locked exclusively ready for further operation specific checks. On
 607  * failure, return an error without modifying or locking the inode.
 608  */
 609 static struct xfs_trans *
 610 xfs_ioctl_setattr_get_trans(
 611         struct xfs_inode        *ip,
 612         struct xfs_dquot        *pdqp)
 613 {
 614         struct xfs_mount        *mp = ip->i_mount;
 615         struct xfs_trans        *tp;
 616         int                     error = -EROFS;
 617
 618         if (xfs_is_readonly(mp))
 619                 goto out_error;
 620         error = -EIO;
 621         if (xfs_is_shutdown(mp))
 622                 goto out_error;
 623
 624         error = xfs_trans_alloc_ichange(ip, NULL, NULL, pdqp,
 625                         has_capability_noaudit(current, CAP_FOWNER), &tp);
 626         if (error)
 627                 goto out_error;
 628
 629         if (xfs_has_wsync(mp))
 630                 xfs_trans_set_sync(tp);
 631
 632         return tp;
 633
 634 out_error:
 635         return ERR_PTR(error);
 636 }
 637
 638 /*
 639  * Validate a proposed extent size hint.  For regular files, the hint can only
 640  * be changed if no extents are allocated.
 641  */
 642 static int
 643 xfs_ioctl_setattr_check_extsize(
 644         struct xfs_inode        *ip,
 645         struct fileattr         *fa)
 646 {
 647         struct xfs_mount        *mp = ip->i_mount;
 648         xfs_failaddr_t          failaddr;
 649         uint16_t                new_diflags;
 650
 651         if (!fa->fsx_valid)
 652                 return 0;
 653
 654         if (S_ISREG(VFS_I(ip)->i_mode) && xfs_inode_has_filedata(ip) &&
 655             XFS_FSB_TO_B(mp, ip->i_extsize) != fa->fsx_extsize)
 656                 return -EINVAL;
 657
 658         if (fa->fsx_extsize & mp->m_blockmask)
 659                 return -EINVAL;
 660
 661         new_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
 662
 663         /*
 664          * Inode verifiers do not check that the extent size hint is an integer
 665          * multiple of the rt extent size on a directory with both rtinherit
 666          * and extszinherit flags set.  Don't let sysadmins misconfigure
 667          * directories.
 668          */
 669         if ((new_diflags & XFS_DIFLAG_RTINHERIT) &&
 670             (new_diflags & XFS_DIFLAG_EXTSZINHERIT)) {
 671                 unsigned int    rtextsize_bytes;
 672
 673                 rtextsize_bytes = XFS_FSB_TO_B(mp, mp->m_sb.sb_rextsize);
 674                 if (fa->fsx_extsize % rtextsize_bytes)
 675                         return -EINVAL;
 676         }
 677
 678         failaddr = xfs_inode_validate_extsize(ip->i_mount,
 679                         XFS_B_TO_FSB(mp, fa->fsx_extsize),
 680                         VFS_I(ip)->i_mode, new_diflags);
 681         return failaddr != NULL ? -EINVAL : 0;
 682 }
 683
 684 static int
 685 xfs_ioctl_setattr_check_cowextsize(
 686         struct xfs_inode        *ip,
 687         struct fileattr         *fa)
 688 {
 689         struct xfs_mount        *mp = ip->i_mount;
 690         xfs_failaddr_t          failaddr;
 691         uint64_t                new_diflags2;
 692         uint16_t                new_diflags;
 693
 694         if (!fa->fsx_valid)
 695                 return 0;
 696
 697         if (fa->fsx_cowextsize & mp->m_blockmask)
 698                 return -EINVAL;
 699
 700         new_diflags = xfs_flags2diflags(ip, fa->fsx_xflags);
 701         new_diflags2 = xfs_flags2diflags2(ip, fa->fsx_xflags);
 702
 703         failaddr = xfs_inode_validate_cowextsize(ip->i_mount,
 704                         XFS_B_TO_FSB(mp, fa->fsx_cowextsize),
 705                         VFS_I(ip)->i_mode, new_diflags, new_diflags2);
 706         return failaddr != NULL ? -EINVAL : 0;
 707 }
 708
 709 static int
 710 xfs_ioctl_setattr_check_projid(
 711         struct xfs_inode        *ip,
 712         struct fileattr         *fa)
 713 {
 714         if (!fa->fsx_valid)
 715                 return 0;
 716
 717         /* Disallow 32bit project ids if 32bit IDs are not enabled. */
 718         if (fa->fsx_projid > (uint16_t)-1 &&
 719             !xfs_has_projid32(ip->i_mount))
 720                 return -EINVAL;
 721         return 0;
 722 }
 723
 724 int
 725 xfs_fileattr_set(
 726         struct mnt_idmap        *idmap,
 727         struct dentry           *dentry,
 728         struct fileattr         *fa)
 729 {
 730         struct xfs_inode        *ip = XFS_I(d_inode(dentry));
 731         struct xfs_mount        *mp = ip->i_mount;
 732         struct xfs_trans        *tp;
 733         struct xfs_dquot        *pdqp = NULL;
 734         struct xfs_dquot        *olddquot = NULL;
 735         int                     error;
 736
 737         trace_xfs_ioctl_setattr(ip);
 738
 739         if (d_is_special(dentry))
 740                 return -ENOTTY;
 741
 742         if (!fa->fsx_valid) {
 743                 if (fa->flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL |
 744                                   FS_NOATIME_FL | FS_NODUMP_FL |
 745                                   FS_SYNC_FL | FS_DAX_FL | FS_PROJINHERIT_FL))
 746                         return -EOPNOTSUPP;
 747         }
 748
 749         error = xfs_ioctl_setattr_check_projid(ip, fa);
 750         if (error)
 751                 return error;
 752
 753         /*
 754          * If disk quotas is on, we make sure that the dquots do exist on disk,
 755          * before we start any other transactions. Trying to do this later
 756          * is messy. We don't care to take a readlock to look at the ids
 757          * in inode here, because we can't hold it across the trans_reserve.
 758          * If the IDs do change before we take the ilock, we're covered
 759          * because the i_*dquot fields will get updated anyway.
 760          */
 761         if (fa->fsx_valid && XFS_IS_QUOTA_ON(mp)) {
 762                 error = xfs_qm_vop_dqalloc(ip, VFS_I(ip)->i_uid,
 763                                 VFS_I(ip)->i_gid, fa->fsx_projid,
 764                                 XFS_QMOPT_PQUOTA, NULL, NULL, &pdqp);
 765                 if (error)
 766                         return error;
 767         }
 768
 769         xfs_ioctl_setattr_prepare_dax(ip, fa);
 770
 771         tp = xfs_ioctl_setattr_get_trans(ip, pdqp);
 772         if (IS_ERR(tp)) {
 773                 error = PTR_ERR(tp);
 774                 goto error_free_dquots;
 775         }
 776
 777         error = xfs_ioctl_setattr_check_extsize(ip, fa);
 778         if (error)
 779                 goto error_trans_cancel;
 780
 781         error = xfs_ioctl_setattr_check_cowextsize(ip, fa);
 782         if (error)
 783                 goto error_trans_cancel;
 784
 785         error = xfs_ioctl_setattr_xflags(tp, ip, fa);
 786         if (error)
 787                 goto error_trans_cancel;
 788
 789         if (!fa->fsx_valid)
 790                 goto skip_xattr;
 791         /*
 792          * Change file ownership.  Must be the owner or privileged.  CAP_FSETID
 793          * overrides the following restrictions:
 794          *
 795          * The set-user-ID and set-group-ID bits of a file will be cleared upon
 796          * successful return from chown()
 797          */
 798
 799         if ((VFS_I(ip)->i_mode & (S_ISUID|S_ISGID)) &&
 800             !capable_wrt_inode_uidgid(idmap, VFS_I(ip), CAP_FSETID))
 801                 VFS_I(ip)->i_mode &= ~(S_ISUID|S_ISGID);
 802
 803         /* Change the ownerships and register project quota modifications */
 804         if (ip->i_projid != fa->fsx_projid) {
 805                 if (XFS_IS_PQUOTA_ON(mp)) {
 806                         olddquot = xfs_qm_vop_chown(tp, ip,
 807                                                 &ip->i_pdquot, pdqp);
 808                 }
 809                 ip->i_projid = fa->fsx_projid;
 810         }
 811
 812         /*
 813          * Only set the extent size hint if we've already determined that the
 814          * extent size hint should be set on the inode. If no extent size flags
 815          * are set on the inode then unconditionally clear the extent size hint.
 816          */
 817         if (ip->i_diflags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
 818                 ip->i_extsize = XFS_B_TO_FSB(mp, fa->fsx_extsize);
 819         else
 820                 ip->i_extsize = 0;
 821
 822         if (xfs_has_v3inodes(mp)) {
 823                 if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
 824                         ip->i_cowextsize = XFS_B_TO_FSB(mp, fa->fsx_cowextsize);
 825                 else
 826                         ip->i_cowextsize = 0;
 827         }
 828
 829 skip_xattr:
 830         error = xfs_trans_commit(tp);
 831
 832         /*
 833          * Release any dquot(s) the inode had kept before chown.
 834          */
 835         xfs_qm_dqrele(olddquot);
 836         xfs_qm_dqrele(pdqp);
 837
 838         return error;
 839
 840 error_trans_cancel:
 841         xfs_trans_cancel(tp);
 842 error_free_dquots:
 843         xfs_qm_dqrele(pdqp);
 844         return error;
 845 }
 846
 847 static bool
 848 xfs_getbmap_format(
 849         struct kgetbmap         *p,
 850         struct getbmapx __user  *u,
 851         size_t                  recsize)
 852 {
 853         if (put_user(p->bmv_offset, &u->bmv_offset) ||
 854             put_user(p->bmv_block, &u->bmv_block) ||
 855             put_user(p->bmv_length, &u->bmv_length) ||
 856             put_user(0, &u->bmv_count) ||
 857             put_user(0, &u->bmv_entries))
 858                 return false;
 859         if (recsize < sizeof(struct getbmapx))
 860                 return true;
 861         if (put_user(0, &u->bmv_iflags) ||
 862             put_user(p->bmv_oflags, &u->bmv_oflags) ||
 863             put_user(0, &u->bmv_unused1) ||
 864             put_user(0, &u->bmv_unused2))
 865                 return false;
 866         return true;
 867 }
 868
 869 STATIC int
 870 xfs_ioc_getbmap(
 871         struct file             *file,
 872         unsigned int            cmd,
 873         void                    __user *arg)
 874 {
 875         struct getbmapx         bmx = { 0 };
 876         struct kgetbmap         *buf;
 877         size_t                  recsize;
 878         int                     error, i;
 879
 880         switch (cmd) {
 881         case XFS_IOC_GETBMAPA:
 882                 bmx.bmv_iflags = BMV_IF_ATTRFORK;
 883                 fallthrough;
 884         case XFS_IOC_GETBMAP:
 885                 /* struct getbmap is a strict subset of struct getbmapx. */
 886                 recsize = sizeof(struct getbmap);
 887                 break;
 888         case XFS_IOC_GETBMAPX:
 889                 recsize = sizeof(struct getbmapx);
 890                 break;
 891         default:
 892                 return -EINVAL;
 893         }
 894
 895         if (copy_from_user(&bmx, arg, recsize))
 896                 return -EFAULT;
 897
 898         if (bmx.bmv_count < 2)
 899                 return -EINVAL;
 900         if (bmx.bmv_count >= INT_MAX / recsize)
 901                 return -ENOMEM;
 902
 903         buf = kvcalloc(bmx.bmv_count, sizeof(*buf), GFP_KERNEL);
 904         if (!buf)
 905                 return -ENOMEM;
 906
 907         error = xfs_getbmap(XFS_I(file_inode(file)), &bmx, buf);
 908         if (error)
 909                 goto out_free_buf;
 910
 911         error = -EFAULT;
 912         if (copy_to_user(arg, &bmx, recsize))
 913                 goto out_free_buf;
 914         arg += recsize;
 915
 916         for (i = 0; i < bmx.bmv_entries; i++) {
 917                 if (!xfs_getbmap_format(buf + i, arg, recsize))
 918                         goto out_free_buf;
 919                 arg += recsize;
 920         }
 921
 922         error = 0;
 923 out_free_buf:
 924         kvfree(buf);
 925         return error;
 926 }
 927
 928 int
 929 xfs_ioc_swapext(
 930         xfs_swapext_t   *sxp)
 931 {
 932         xfs_inode_t     *ip, *tip;
 933
 934         /* Pull information for the target fd */
 935         CLASS(fd, f)((int)sxp->sx_fdtarget);
 936         if (fd_empty(f))
 937                 return -EINVAL;
 938
 939         if (!(fd_file(f)->f_mode & FMODE_WRITE) ||
 940             !(fd_file(f)->f_mode & FMODE_READ) ||
 941             (fd_file(f)->f_flags & O_APPEND))
 942                 return -EBADF;
 943
 944         CLASS(fd, tmp)((int)sxp->sx_fdtmp);
 945         if (fd_empty(tmp))
 946                 return -EINVAL;
 947
 948         if (!(fd_file(tmp)->f_mode & FMODE_WRITE) ||
 949             !(fd_file(tmp)->f_mode & FMODE_READ) ||
 950             (fd_file(tmp)->f_flags & O_APPEND))
 951                 return -EBADF;
 952
 953         if (IS_SWAPFILE(file_inode(fd_file(f))) ||
 954             IS_SWAPFILE(file_inode(fd_file(tmp))))
 955                 return -EINVAL;
 956
 957         /*
 958          * We need to ensure that the fds passed in point to XFS inodes
 959          * before we cast and access them as XFS structures as we have no
 960          * control over what the user passes us here.
 961          */
 962         if (fd_file(f)->f_op != &xfs_file_operations ||
 963             fd_file(tmp)->f_op != &xfs_file_operations)
 964                 return -EINVAL;
 965
 966         ip = XFS_I(file_inode(fd_file(f)));
 967         tip = XFS_I(file_inode(fd_file(tmp)));
 968
 969         if (ip->i_mount != tip->i_mount)
 970                 return -EINVAL;
 971
 972         if (ip->i_ino == tip->i_ino)
 973                 return -EINVAL;
 974
 975         if (xfs_is_shutdown(ip->i_mount))
 976                 return -EIO;
 977
 978         return xfs_swap_extents(ip, tip, sxp);
 979 }
 980
 981 static int
 982 xfs_ioc_getlabel(
 983         struct xfs_mount        *mp,
 984         char                    __user *user_label)
 985 {
 986         struct xfs_sb           *sbp = &mp->m_sb;
 987         char                    label[XFSLABEL_MAX + 1];
 988
 989         /* Paranoia */
 990         BUILD_BUG_ON(sizeof(sbp->sb_fname) > FSLABEL_MAX);
 991
 992         /* 1 larger than sb_fname, so this ensures a trailing NUL char */
 993         memset(label, 0, sizeof(label));
 994         spin_lock(&mp->m_sb_lock);
 995         strncpy(label, sbp->sb_fname, XFSLABEL_MAX);
 996         spin_unlock(&mp->m_sb_lock);
 997
 998         if (copy_to_user(user_label, label, sizeof(label)))
 999                 return -EFAULT;
1000         return 0;
1001 }
1002
1003 static int
1004 xfs_ioc_setlabel(
1005         struct file             *filp,
1006         struct xfs_mount        *mp,
1007         char                    __user *newlabel)
1008 {
1009         struct xfs_sb           *sbp = &mp->m_sb;
1010         char                    label[XFSLABEL_MAX + 1];
1011         size_t                  len;
1012         int                     error;
1013
1014         if (!capable(CAP_SYS_ADMIN))
1015                 return -EPERM;
1016         /*
1017          * The generic ioctl allows up to FSLABEL_MAX chars, but XFS is much
1018          * smaller, at 12 bytes.  We copy one more to be sure we find the
1019          * (required) NULL character to test the incoming label length.
1020          * NB: The on disk label doesn't need to be null terminated.
1021          */
1022         if (copy_from_user(label, newlabel, XFSLABEL_MAX + 1))
1023                 return -EFAULT;
1024         len = strnlen(label, XFSLABEL_MAX + 1);
1025         if (len > sizeof(sbp->sb_fname))
1026                 return -EINVAL;
1027
1028         error = mnt_want_write_file(filp);
1029         if (error)
1030                 return error;
1031
1032         spin_lock(&mp->m_sb_lock);
1033         memset(sbp->sb_fname, 0, sizeof(sbp->sb_fname));
1034         memcpy(sbp->sb_fname, label, len);
1035         spin_unlock(&mp->m_sb_lock);
1036
1037         /*
1038          * Now we do several things to satisfy userspace.
1039          * In addition to normal logging of the primary superblock, we also
1040          * immediately write these changes to sector zero for the primary, then
1041          * update all backup supers (as xfs_db does for a label change), then
1042          * invalidate the block device page cache.  This is so that any prior
1043          * buffered reads from userspace (i.e. from blkid) are invalidated,
1044          * and userspace will see the newly-written label.
1045          */
1046         error = xfs_sync_sb_buf(mp, true);
1047         if (error)
1048                 goto out;
1049         /*
1050          * growfs also updates backup supers so lock against that.
1051          */
1052         mutex_lock(&mp->m_growlock);
1053         error = xfs_update_secondary_sbs(mp);
1054         mutex_unlock(&mp->m_growlock);
1055
1056         invalidate_bdev(mp->m_ddev_targp->bt_bdev);
1057         if (xfs_has_rtsb(mp) && mp->m_rtdev_targp)
1058                 invalidate_bdev(mp->m_rtdev_targp->bt_bdev);
1059
1060 out:
1061         mnt_drop_write_file(filp);
1062         return error;
1063 }
1064
1065 static inline int
1066 xfs_fs_eofblocks_from_user(
1067         struct xfs_fs_eofblocks         *src,
1068         struct xfs_icwalk               *dst)
1069 {
1070         if (src->eof_version != XFS_EOFBLOCKS_VERSION)
1071                 return -EINVAL;
1072
1073         if (src->eof_flags & ~XFS_EOF_FLAGS_VALID)
1074                 return -EINVAL;
1075
1076         if (memchr_inv(&src->pad32, 0, sizeof(src->pad32)) ||
1077             memchr_inv(src->pad64, 0, sizeof(src->pad64)))
1078                 return -EINVAL;
1079
1080         dst->icw_flags = 0;
1081         if (src->eof_flags & XFS_EOF_FLAGS_SYNC)
1082                 dst->icw_flags |= XFS_ICWALK_FLAG_SYNC;
1083         if (src->eof_flags & XFS_EOF_FLAGS_UID)
1084                 dst->icw_flags |= XFS_ICWALK_FLAG_UID;
1085         if (src->eof_flags & XFS_EOF_FLAGS_GID)
1086                 dst->icw_flags |= XFS_ICWALK_FLAG_GID;
1087         if (src->eof_flags & XFS_EOF_FLAGS_PRID)
1088                 dst->icw_flags |= XFS_ICWALK_FLAG_PRID;
1089         if (src->eof_flags & XFS_EOF_FLAGS_MINFILESIZE)
1090                 dst->icw_flags |= XFS_ICWALK_FLAG_MINFILESIZE;
1091
1092         dst->icw_prid = src->eof_prid;
1093         dst->icw_min_file_size = src->eof_min_file_size;
1094
1095         dst->icw_uid = INVALID_UID;
1096         if (src->eof_flags & XFS_EOF_FLAGS_UID) {
1097                 dst->icw_uid = make_kuid(current_user_ns(), src->eof_uid);
1098                 if (!uid_valid(dst->icw_uid))
1099                         return -EINVAL;
1100         }
1101
1102         dst->icw_gid = INVALID_GID;
1103         if (src->eof_flags & XFS_EOF_FLAGS_GID) {
1104                 dst->icw_gid = make_kgid(current_user_ns(), src->eof_gid);
1105                 if (!gid_valid(dst->icw_gid))
1106                         return -EINVAL;
1107         }
1108         return 0;
1109 }
1110
1111 static int
1112 xfs_ioctl_getset_resblocks(
1113         struct file             *filp,
1114         unsigned int            cmd,
1115         void __user             *arg)
1116 {
1117         struct xfs_mount        *mp = XFS_I(file_inode(filp))->i_mount;
1118         struct xfs_fsop_resblks fsop = { };
1119         int                     error;
1120
1121         if (!capable(CAP_SYS_ADMIN))
1122                 return -EPERM;
1123
1124         if (cmd == XFS_IOC_SET_RESBLKS) {
1125                 if (xfs_is_readonly(mp))
1126                         return -EROFS;
1127
1128                 if (copy_from_user(&fsop, arg, sizeof(fsop)))
1129                         return -EFAULT;
1130
1131                 error = mnt_want_write_file(filp);
1132                 if (error)
1133                         return error;
1134                 error = xfs_reserve_blocks(mp, XC_FREE_BLOCKS, fsop.resblks);
1135                 mnt_drop_write_file(filp);
1136                 if (error)
1137                         return error;
1138         }
1139
1140         spin_lock(&mp->m_sb_lock);
1141         fsop.resblks = mp->m_free[XC_FREE_BLOCKS].res_total;
1142         fsop.resblks_avail = mp->m_free[XC_FREE_BLOCKS].res_avail;
1143         spin_unlock(&mp->m_sb_lock);
1144
1145         if (copy_to_user(arg, &fsop, sizeof(fsop)))
1146                 return -EFAULT;
1147         return 0;
1148 }
1149
1150 static int
1151 xfs_ioctl_fs_counts(
1152         struct xfs_mount        *mp,
1153         struct xfs_fsop_counts __user   *uarg)
1154 {
1155         struct xfs_fsop_counts  out = {
1156                 .allocino = percpu_counter_read_positive(&mp->m_icount),
1157                 .freeino  = percpu_counter_read_positive(&mp->m_ifree),
1158                 .freedata = xfs_estimate_freecounter(mp, XC_FREE_BLOCKS) -
1159                                 xfs_freecounter_unavailable(mp, XC_FREE_BLOCKS),
1160                 .freertx  = xfs_estimate_freecounter(mp, XC_FREE_RTEXTENTS),
1161         };
1162
1163         if (copy_to_user(uarg, &out, sizeof(out)))
1164                 return -EFAULT;
1165         return 0;
1166 }
1167
1168 /*
1169  * These long-unused ioctls were removed from the official ioctl API in 5.17,
1170  * but retain these definitions so that we can log warnings about them.
1171  */
1172 #define XFS_IOC_ALLOCSP         _IOW ('X', 10, struct xfs_flock64)
1173 #define XFS_IOC_FREESP          _IOW ('X', 11, struct xfs_flock64)
1174 #define XFS_IOC_ALLOCSP64       _IOW ('X', 36, struct xfs_flock64)
1175 #define XFS_IOC_FREESP64        _IOW ('X', 37, struct xfs_flock64)
1176
1177 /*
1178  * Note: some of the ioctl's return positive numbers as a
1179  * byte count indicating success, such as readlink_by_handle.
1180  * So we don't "sign flip" like most other routines.  This means
1181  * true errors need to be returned as a negative value.
1182  */
1183 long
1184 xfs_file_ioctl(
1185         struct file             *filp,
1186         unsigned int            cmd,
1187         unsigned long           p)
1188 {
1189         struct inode            *inode = file_inode(filp);
1190         struct xfs_inode        *ip = XFS_I(inode);
1191         struct xfs_mount        *mp = ip->i_mount;
1192         void                    __user *arg = (void __user *)p;
1193         int                     error;
1194
1195         trace_xfs_file_ioctl(ip);
1196
1197         switch (cmd) {
1198         case FITRIM:
1199                 return xfs_ioc_trim(mp, arg);
1200         case FS_IOC_GETFSLABEL:
1201                 return xfs_ioc_getlabel(mp, arg);
1202         case FS_IOC_SETFSLABEL:
1203                 return xfs_ioc_setlabel(filp, mp, arg);
1204         case XFS_IOC_ALLOCSP:
1205         case XFS_IOC_FREESP:
1206         case XFS_IOC_ALLOCSP64:
1207         case XFS_IOC_FREESP64:
1208                 xfs_warn_once(mp,
1209         "%s should use fallocate; XFS_IOC_{ALLOC,FREE}SP ioctl unsupported",
1210                                 current->comm);
1211                 return -ENOTTY;
1212         case XFS_IOC_DIOINFO: {
1213                 struct xfs_buftarg      *target = xfs_inode_buftarg(ip);
1214                 struct dioattr          da;
1215
1216                 da.d_mem = target->bt_logical_sectorsize;
1217
1218                 /*
1219                  * See xfs_report_dioalign() for an explanation about why this
1220                  * reports a value larger than the sector size for COW inodes.
1221                  */
1222                 if (xfs_is_cow_inode(ip))
1223                         da.d_miniosz = xfs_inode_alloc_unitsize(ip);
1224                 else
1225                         da.d_miniosz = target->bt_logical_sectorsize;
1226                 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1227
1228                 if (copy_to_user(arg, &da, sizeof(da)))
1229                         return -EFAULT;
1230                 return 0;
1231         }
1232
1233         case XFS_IOC_FSBULKSTAT_SINGLE:
1234         case XFS_IOC_FSBULKSTAT:
1235         case XFS_IOC_FSINUMBERS:
1236                 return xfs_ioc_fsbulkstat(filp, cmd, arg);
1237
1238         case XFS_IOC_BULKSTAT:
1239                 return xfs_ioc_bulkstat(filp, cmd, arg);
1240         case XFS_IOC_INUMBERS:
1241                 return xfs_ioc_inumbers(mp, cmd, arg);
1242
1243         case XFS_IOC_FSGEOMETRY_V1:
1244                 return xfs_ioc_fsgeometry(mp, arg, 3);
1245         case XFS_IOC_FSGEOMETRY_V4:
1246                 return xfs_ioc_fsgeometry(mp, arg, 4);
1247         case XFS_IOC_FSGEOMETRY:
1248                 return xfs_ioc_fsgeometry(mp, arg, 5);
1249
1250         case XFS_IOC_AG_GEOMETRY:
1251                 return xfs_ioc_ag_geometry(mp, arg);
1252         case XFS_IOC_RTGROUP_GEOMETRY:
1253                 return xfs_ioc_rtgroup_geometry(mp, arg);
1254
1255         case XFS_IOC_GETVERSION:
1256                 return put_user(inode->i_generation, (int __user *)arg);
1257
1258         case XFS_IOC_FSGETXATTRA:
1259                 return xfs_ioc_fsgetxattra(ip, arg);
1260         case XFS_IOC_GETPARENTS:
1261                 return xfs_ioc_getparents(filp, arg);
1262         case XFS_IOC_GETPARENTS_BY_HANDLE:
1263                 return xfs_ioc_getparents_by_handle(filp, arg);
1264         case XFS_IOC_GETBMAP:
1265         case XFS_IOC_GETBMAPA:
1266         case XFS_IOC_GETBMAPX:
1267                 return xfs_ioc_getbmap(filp, cmd, arg);
1268
1269         case FS_IOC_GETFSMAP:
1270                 return xfs_ioc_getfsmap(ip, arg);
1271
1272         case XFS_IOC_SCRUBV_METADATA:
1273                 return xfs_ioc_scrubv_metadata(filp, arg);
1274         case XFS_IOC_SCRUB_METADATA:
1275                 return xfs_ioc_scrub_metadata(filp, arg);
1276
1277         case XFS_IOC_FD_TO_HANDLE:
1278         case XFS_IOC_PATH_TO_HANDLE:
1279         case XFS_IOC_PATH_TO_FSHANDLE: {
1280                 xfs_fsop_handlereq_t    hreq;
1281
1282                 if (copy_from_user(&hreq, arg, sizeof(hreq)))
1283                         return -EFAULT;
1284                 return xfs_find_handle(cmd, &hreq);
1285         }
1286         case XFS_IOC_OPEN_BY_HANDLE: {
1287                 xfs_fsop_handlereq_t    hreq;
1288
1289                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1290                         return -EFAULT;
1291                 return xfs_open_by_handle(filp, &hreq);
1292         }
1293
1294         case XFS_IOC_READLINK_BY_HANDLE: {
1295                 xfs_fsop_handlereq_t    hreq;
1296
1297                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1298                         return -EFAULT;
1299                 return xfs_readlink_by_handle(filp, &hreq);
1300         }
1301         case XFS_IOC_ATTRLIST_BY_HANDLE:
1302                 return xfs_attrlist_by_handle(filp, arg);
1303
1304         case XFS_IOC_ATTRMULTI_BY_HANDLE:
1305                 return xfs_attrmulti_by_handle(filp, arg);
1306
1307         case XFS_IOC_SWAPEXT: {
1308                 struct xfs_swapext      sxp;
1309
1310                 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
1311                         return -EFAULT;
1312                 error = mnt_want_write_file(filp);
1313                 if (error)
1314                         return error;
1315                 error = xfs_ioc_swapext(&sxp);
1316                 mnt_drop_write_file(filp);
1317                 return error;
1318         }
1319
1320         case XFS_IOC_FSCOUNTS:
1321                 return xfs_ioctl_fs_counts(mp, arg);
1322
1323         case XFS_IOC_SET_RESBLKS:
1324         case XFS_IOC_GET_RESBLKS:
1325                 return xfs_ioctl_getset_resblocks(filp, cmd, arg);
1326
1327         case XFS_IOC_FSGROWFSDATA: {
1328                 struct xfs_growfs_data in;
1329
1330                 if (copy_from_user(&in, arg, sizeof(in)))
1331                         return -EFAULT;
1332
1333                 error = mnt_want_write_file(filp);
1334                 if (error)
1335                         return error;
1336                 error = xfs_growfs_data(mp, &in);
1337                 mnt_drop_write_file(filp);
1338                 return error;
1339         }
1340
1341         case XFS_IOC_FSGROWFSLOG: {
1342                 struct xfs_growfs_log in;
1343
1344                 if (copy_from_user(&in, arg, sizeof(in)))
1345                         return -EFAULT;
1346
1347                 error = mnt_want_write_file(filp);
1348                 if (error)
1349                         return error;
1350                 error = xfs_growfs_log(mp, &in);
1351                 mnt_drop_write_file(filp);
1352                 return error;
1353         }
1354
1355         case XFS_IOC_FSGROWFSRT: {
1356                 xfs_growfs_rt_t in;
1357
1358                 if (copy_from_user(&in, arg, sizeof(in)))
1359                         return -EFAULT;
1360
1361                 error = mnt_want_write_file(filp);
1362                 if (error)
1363                         return error;
1364                 error = xfs_growfs_rt(mp, &in);
1365                 mnt_drop_write_file(filp);
1366                 return error;
1367         }
1368
1369         case XFS_IOC_GOINGDOWN: {
1370                 uint32_t in;
1371
1372                 if (!capable(CAP_SYS_ADMIN))
1373                         return -EPERM;
1374
1375                 if (get_user(in, (uint32_t __user *)arg))
1376                         return -EFAULT;
1377
1378                 return xfs_fs_goingdown(mp, in);
1379         }
1380
1381         case XFS_IOC_ERROR_INJECTION: {
1382                 xfs_error_injection_t in;
1383
1384                 if (!capable(CAP_SYS_ADMIN))
1385                         return -EPERM;
1386
1387                 if (copy_from_user(&in, arg, sizeof(in)))
1388                         return -EFAULT;
1389
1390                 return xfs_errortag_add(mp, in.errtag);
1391         }
1392
1393         case XFS_IOC_ERROR_CLEARALL:
1394                 if (!capable(CAP_SYS_ADMIN))
1395                         return -EPERM;
1396
1397                 return xfs_errortag_clearall(mp);
1398
1399         case XFS_IOC_FREE_EOFBLOCKS: {
1400                 struct xfs_fs_eofblocks eofb;
1401                 struct xfs_icwalk       icw;
1402
1403                 if (!capable(CAP_SYS_ADMIN))
1404                         return -EPERM;
1405
1406                 if (xfs_is_readonly(mp))
1407                         return -EROFS;
1408
1409                 if (copy_from_user(&eofb, arg, sizeof(eofb)))
1410                         return -EFAULT;
1411
1412                 error = xfs_fs_eofblocks_from_user(&eofb, &icw);
1413                 if (error)
1414                         return error;
1415
1416                 trace_xfs_ioc_free_eofblocks(mp, &icw, _RET_IP_);
1417
1418                 sb_start_write(mp->m_super);
1419                 error = xfs_blockgc_free_space(mp, &icw);
1420                 sb_end_write(mp->m_super);
1421                 return error;
1422         }
1423
1424         case XFS_IOC_EXCHANGE_RANGE:
1425                 return xfs_ioc_exchange_range(filp, arg);
1426         case XFS_IOC_START_COMMIT:
1427                 return xfs_ioc_start_commit(filp, arg);
1428         case XFS_IOC_COMMIT_RANGE:
1429                 return xfs_ioc_commit_range(filp, arg);
1430
1431         default:
1432                 return -ENOTTY;
1433         }
1434 }