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