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 uint16_t
 473 xfs_flags2diflags(
 474         struct xfs_inode        *ip,
 475         unsigned int            xflags)
 476 {
 477         /* can't set PREALLOC this way, just preserve it */
 478         uint16_t                di_flags =
 479                 (ip->i_diflags & XFS_DIFLAG_PREALLOC);
 480
 481         if (xflags & FS_XFLAG_IMMUTABLE)
 482                 di_flags |= XFS_DIFLAG_IMMUTABLE;
 483         if (xflags & FS_XFLAG_APPEND)
 484                 di_flags |= XFS_DIFLAG_APPEND;
 485         if (xflags & FS_XFLAG_SYNC)
 486                 di_flags |= XFS_DIFLAG_SYNC;
 487         if (xflags & FS_XFLAG_NOATIME)
 488                 di_flags |= XFS_DIFLAG_NOATIME;
 489         if (xflags & FS_XFLAG_NODUMP)
 490                 di_flags |= XFS_DIFLAG_NODUMP;
 491         if (xflags & FS_XFLAG_NODEFRAG)
 492                 di_flags |= XFS_DIFLAG_NODEFRAG;
 493         if (xflags & FS_XFLAG_FILESTREAM)
 494                 di_flags |= XFS_DIFLAG_FILESTREAM;
 495         if (S_ISDIR(VFS_I(ip)->i_mode)) {
 496                 if (xflags & FS_XFLAG_RTINHERIT)
 497                         di_flags |= XFS_DIFLAG_RTINHERIT;
 498                 if (xflags & FS_XFLAG_NOSYMLINKS)
 499                         di_flags |= XFS_DIFLAG_NOSYMLINKS;
 500                 if (xflags & FS_XFLAG_EXTSZINHERIT)
 501                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
 502                 if (xflags & FS_XFLAG_PROJINHERIT)
 503                         di_flags |= XFS_DIFLAG_PROJINHERIT;
 504         } else if (S_ISREG(VFS_I(ip)->i_mode)) {
 505                 if (xflags & FS_XFLAG_REALTIME)
 506                         di_flags |= XFS_DIFLAG_REALTIME;
 507                 if (xflags & FS_XFLAG_EXTSIZE)
 508                         di_flags |= XFS_DIFLAG_EXTSIZE;
 509         }
 510
 511         return di_flags;
 512 }
 513
 514 STATIC uint64_t
 515 xfs_flags2diflags2(
 516         struct xfs_inode        *ip,
 517         unsigned int            xflags)
 518 {
 519         uint64_t                di_flags2 =
 520                 (ip->i_diflags2 & (XFS_DIFLAG2_REFLINK |
 521                                    XFS_DIFLAG2_BIGTIME |
 522                                    XFS_DIFLAG2_NREXT64));
 523
 524         if (xflags & FS_XFLAG_DAX)
 525                 di_flags2 |= XFS_DIFLAG2_DAX;
 526         if (xflags & FS_XFLAG_COWEXTSIZE)
 527                 di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
 528
 529         return di_flags2;
 530 }
 531
 532 static int
 533 xfs_ioctl_setattr_xflags(
 534         struct xfs_trans        *tp,
 535         struct xfs_inode        *ip,
 536         struct fileattr         *fa)
 537 {
 538         struct xfs_mount        *mp = ip->i_mount;
 539         bool                    rtflag = (fa->fsx_xflags & FS_XFLAG_REALTIME);
 540         uint64_t                i_flags2;
 541
 542         if (rtflag != XFS_IS_REALTIME_INODE(ip)) {
 543                 /* Can't change realtime flag if any extents are allocated. */
 544                 if (ip->i_df.if_nextents || ip->i_delayed_blks)
 545                         return -EINVAL;
 546         }
 547
 548         if (rtflag) {
 549                 /* If realtime flag is set then must have realtime device */
 550                 if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
 551                     xfs_extlen_to_rtxmod(mp, ip->i_extsize))
 552                         return -EINVAL;
 553
 554                 /* Clear reflink if we are actually able to set the rt flag. */
 555                 if (xfs_is_reflink_inode(ip))
 556                         ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
 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) && ip->i_df.if_nextents &&
 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 STATIC int
 929 xfs_ioc_getfsmap(
 930         struct xfs_inode        *ip,
 931         struct fsmap_head       __user *arg)
 932 {
 933         struct xfs_fsmap_head   xhead = {0};
 934         struct fsmap_head       head;
 935         struct fsmap            *recs;
 936         unsigned int            count;
 937         __u32                   last_flags = 0;
 938         bool                    done = false;
 939         int                     error;
 940
 941         if (copy_from_user(&head, arg, sizeof(struct fsmap_head)))
 942                 return -EFAULT;
 943         if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) ||
 944             memchr_inv(head.fmh_keys[0].fmr_reserved, 0,
 945                        sizeof(head.fmh_keys[0].fmr_reserved)) ||
 946             memchr_inv(head.fmh_keys[1].fmr_reserved, 0,
 947                        sizeof(head.fmh_keys[1].fmr_reserved)))
 948                 return -EINVAL;
 949
 950         /*
 951          * Use an internal memory buffer so that we don't have to copy fsmap
 952          * data to userspace while holding locks.  Start by trying to allocate
 953          * up to 128k for the buffer, but fall back to a single page if needed.
 954          */
 955         count = min_t(unsigned int, head.fmh_count,
 956                         131072 / sizeof(struct fsmap));
 957         recs = kvcalloc(count, sizeof(struct fsmap), GFP_KERNEL);
 958         if (!recs) {
 959                 count = min_t(unsigned int, head.fmh_count,
 960                                 PAGE_SIZE / sizeof(struct fsmap));
 961                 recs = kvcalloc(count, sizeof(struct fsmap), GFP_KERNEL);
 962                 if (!recs)
 963                         return -ENOMEM;
 964         }
 965
 966         xhead.fmh_iflags = head.fmh_iflags;
 967         xfs_fsmap_to_internal(&xhead.fmh_keys[0], &head.fmh_keys[0]);
 968         xfs_fsmap_to_internal(&xhead.fmh_keys[1], &head.fmh_keys[1]);
 969
 970         trace_xfs_getfsmap_low_key(ip->i_mount, &xhead.fmh_keys[0]);
 971         trace_xfs_getfsmap_high_key(ip->i_mount, &xhead.fmh_keys[1]);
 972
 973         head.fmh_entries = 0;
 974         do {
 975                 struct fsmap __user     *user_recs;
 976                 struct fsmap            *last_rec;
 977
 978                 user_recs = &arg->fmh_recs[head.fmh_entries];
 979                 xhead.fmh_entries = 0;
 980                 xhead.fmh_count = min_t(unsigned int, count,
 981                                         head.fmh_count - head.fmh_entries);
 982
 983                 /* Run query, record how many entries we got. */
 984                 error = xfs_getfsmap(ip->i_mount, &xhead, recs);
 985                 switch (error) {
 986                 case 0:
 987                         /*
 988                          * There are no more records in the result set.  Copy
 989                          * whatever we got to userspace and break out.
 990                          */
 991                         done = true;
 992                         break;
 993                 case -ECANCELED:
 994                         /*
 995                          * The internal memory buffer is full.  Copy whatever
 996                          * records we got to userspace and go again if we have
 997                          * not yet filled the userspace buffer.
 998                          */
 999                         error = 0;
1000                         break;
1001                 default:
1002                         goto out_free;
1003                 }
1004                 head.fmh_entries += xhead.fmh_entries;
1005                 head.fmh_oflags = xhead.fmh_oflags;
1006
1007                 /*
1008                  * If the caller wanted a record count or there aren't any
1009                  * new records to return, we're done.
1010                  */
1011                 if (head.fmh_count == 0 || xhead.fmh_entries == 0)
1012                         break;
1013
1014                 /* Copy all the records we got out to userspace. */
1015                 if (copy_to_user(user_recs, recs,
1016                                  xhead.fmh_entries * sizeof(struct fsmap))) {
1017                         error = -EFAULT;
1018                         goto out_free;
1019                 }
1020
1021                 /* Remember the last record flags we copied to userspace. */
1022                 last_rec = &recs[xhead.fmh_entries - 1];
1023                 last_flags = last_rec->fmr_flags;
1024
1025                 /* Set up the low key for the next iteration. */
1026                 xfs_fsmap_to_internal(&xhead.fmh_keys[0], last_rec);
1027                 trace_xfs_getfsmap_low_key(ip->i_mount, &xhead.fmh_keys[0]);
1028         } while (!done && head.fmh_entries < head.fmh_count);
1029
1030         /*
1031          * If there are no more records in the query result set and we're not
1032          * in counting mode, mark the last record returned with the LAST flag.
1033          */
1034         if (done && head.fmh_count > 0 && head.fmh_entries > 0) {
1035                 struct fsmap __user     *user_rec;
1036
1037                 last_flags |= FMR_OF_LAST;
1038                 user_rec = &arg->fmh_recs[head.fmh_entries - 1];
1039
1040                 if (copy_to_user(&user_rec->fmr_flags, &last_flags,
1041                                         sizeof(last_flags))) {
1042                         error = -EFAULT;
1043                         goto out_free;
1044                 }
1045         }
1046
1047         /* copy back header */
1048         if (copy_to_user(arg, &head, sizeof(struct fsmap_head))) {
1049                 error = -EFAULT;
1050                 goto out_free;
1051         }
1052
1053 out_free:
1054         kvfree(recs);
1055         return error;
1056 }
1057
1058 int
1059 xfs_ioc_swapext(
1060         xfs_swapext_t   *sxp)
1061 {
1062         xfs_inode_t     *ip, *tip;
1063         struct fd       f, tmp;
1064         int             error = 0;
1065
1066         /* Pull information for the target fd */
1067         f = fdget((int)sxp->sx_fdtarget);
1068         if (!f.file) {
1069                 error = -EINVAL;
1070                 goto out;
1071         }
1072
1073         if (!(f.file->f_mode & FMODE_WRITE) ||
1074             !(f.file->f_mode & FMODE_READ) ||
1075             (f.file->f_flags & O_APPEND)) {
1076                 error = -EBADF;
1077                 goto out_put_file;
1078         }
1079
1080         tmp = fdget((int)sxp->sx_fdtmp);
1081         if (!tmp.file) {
1082                 error = -EINVAL;
1083                 goto out_put_file;
1084         }
1085
1086         if (!(tmp.file->f_mode & FMODE_WRITE) ||
1087             !(tmp.file->f_mode & FMODE_READ) ||
1088             (tmp.file->f_flags & O_APPEND)) {
1089                 error = -EBADF;
1090                 goto out_put_tmp_file;
1091         }
1092
1093         if (IS_SWAPFILE(file_inode(f.file)) ||
1094             IS_SWAPFILE(file_inode(tmp.file))) {
1095                 error = -EINVAL;
1096                 goto out_put_tmp_file;
1097         }
1098
1099         /*
1100          * We need to ensure that the fds passed in point to XFS inodes
1101          * before we cast and access them as XFS structures as we have no
1102          * control over what the user passes us here.
1103          */
1104         if (f.file->f_op != &xfs_file_operations ||
1105             tmp.file->f_op != &xfs_file_operations) {
1106                 error = -EINVAL;
1107                 goto out_put_tmp_file;
1108         }
1109
1110         ip = XFS_I(file_inode(f.file));
1111         tip = XFS_I(file_inode(tmp.file));
1112
1113         if (ip->i_mount != tip->i_mount) {
1114                 error = -EINVAL;
1115                 goto out_put_tmp_file;
1116         }
1117
1118         if (ip->i_ino == tip->i_ino) {
1119                 error = -EINVAL;
1120                 goto out_put_tmp_file;
1121         }
1122
1123         if (xfs_is_shutdown(ip->i_mount)) {
1124                 error = -EIO;
1125                 goto out_put_tmp_file;
1126         }
1127
1128         error = xfs_swap_extents(ip, tip, sxp);
1129
1130  out_put_tmp_file:
1131         fdput(tmp);
1132  out_put_file:
1133         fdput(f);
1134  out:
1135         return error;
1136 }
1137
1138 static int
1139 xfs_ioc_getlabel(
1140         struct xfs_mount        *mp,
1141         char                    __user *user_label)
1142 {
1143         struct xfs_sb           *sbp = &mp->m_sb;
1144         char                    label[XFSLABEL_MAX + 1];
1145
1146         /* Paranoia */
1147         BUILD_BUG_ON(sizeof(sbp->sb_fname) > FSLABEL_MAX);
1148
1149         /* 1 larger than sb_fname, so this ensures a trailing NUL char */
1150         memset(label, 0, sizeof(label));
1151         spin_lock(&mp->m_sb_lock);
1152         strncpy(label, sbp->sb_fname, XFSLABEL_MAX);
1153         spin_unlock(&mp->m_sb_lock);
1154
1155         if (copy_to_user(user_label, label, sizeof(label)))
1156                 return -EFAULT;
1157         return 0;
1158 }
1159
1160 static int
1161 xfs_ioc_setlabel(
1162         struct file             *filp,
1163         struct xfs_mount        *mp,
1164         char                    __user *newlabel)
1165 {
1166         struct xfs_sb           *sbp = &mp->m_sb;
1167         char                    label[XFSLABEL_MAX + 1];
1168         size_t                  len;
1169         int                     error;
1170
1171         if (!capable(CAP_SYS_ADMIN))
1172                 return -EPERM;
1173         /*
1174          * The generic ioctl allows up to FSLABEL_MAX chars, but XFS is much
1175          * smaller, at 12 bytes.  We copy one more to be sure we find the
1176          * (required) NULL character to test the incoming label length.
1177          * NB: The on disk label doesn't need to be null terminated.
1178          */
1179         if (copy_from_user(label, newlabel, XFSLABEL_MAX + 1))
1180                 return -EFAULT;
1181         len = strnlen(label, XFSLABEL_MAX + 1);
1182         if (len > sizeof(sbp->sb_fname))
1183                 return -EINVAL;
1184
1185         error = mnt_want_write_file(filp);
1186         if (error)
1187                 return error;
1188
1189         spin_lock(&mp->m_sb_lock);
1190         memset(sbp->sb_fname, 0, sizeof(sbp->sb_fname));
1191         memcpy(sbp->sb_fname, label, len);
1192         spin_unlock(&mp->m_sb_lock);
1193
1194         /*
1195          * Now we do several things to satisfy userspace.
1196          * In addition to normal logging of the primary superblock, we also
1197          * immediately write these changes to sector zero for the primary, then
1198          * update all backup supers (as xfs_db does for a label change), then
1199          * invalidate the block device page cache.  This is so that any prior
1200          * buffered reads from userspace (i.e. from blkid) are invalidated,
1201          * and userspace will see the newly-written label.
1202          */
1203         error = xfs_sync_sb_buf(mp);
1204         if (error)
1205                 goto out;
1206         /*
1207          * growfs also updates backup supers so lock against that.
1208          */
1209         mutex_lock(&mp->m_growlock);
1210         error = xfs_update_secondary_sbs(mp);
1211         mutex_unlock(&mp->m_growlock);
1212
1213         invalidate_bdev(mp->m_ddev_targp->bt_bdev);
1214
1215 out:
1216         mnt_drop_write_file(filp);
1217         return error;
1218 }
1219
1220 static inline int
1221 xfs_fs_eofblocks_from_user(
1222         struct xfs_fs_eofblocks         *src,
1223         struct xfs_icwalk               *dst)
1224 {
1225         if (src->eof_version != XFS_EOFBLOCKS_VERSION)
1226                 return -EINVAL;
1227
1228         if (src->eof_flags & ~XFS_EOF_FLAGS_VALID)
1229                 return -EINVAL;
1230
1231         if (memchr_inv(&src->pad32, 0, sizeof(src->pad32)) ||
1232             memchr_inv(src->pad64, 0, sizeof(src->pad64)))
1233                 return -EINVAL;
1234
1235         dst->icw_flags = 0;
1236         if (src->eof_flags & XFS_EOF_FLAGS_SYNC)
1237                 dst->icw_flags |= XFS_ICWALK_FLAG_SYNC;
1238         if (src->eof_flags & XFS_EOF_FLAGS_UID)
1239                 dst->icw_flags |= XFS_ICWALK_FLAG_UID;
1240         if (src->eof_flags & XFS_EOF_FLAGS_GID)
1241                 dst->icw_flags |= XFS_ICWALK_FLAG_GID;
1242         if (src->eof_flags & XFS_EOF_FLAGS_PRID)
1243                 dst->icw_flags |= XFS_ICWALK_FLAG_PRID;
1244         if (src->eof_flags & XFS_EOF_FLAGS_MINFILESIZE)
1245                 dst->icw_flags |= XFS_ICWALK_FLAG_MINFILESIZE;
1246
1247         dst->icw_prid = src->eof_prid;
1248         dst->icw_min_file_size = src->eof_min_file_size;
1249
1250         dst->icw_uid = INVALID_UID;
1251         if (src->eof_flags & XFS_EOF_FLAGS_UID) {
1252                 dst->icw_uid = make_kuid(current_user_ns(), src->eof_uid);
1253                 if (!uid_valid(dst->icw_uid))
1254                         return -EINVAL;
1255         }
1256
1257         dst->icw_gid = INVALID_GID;
1258         if (src->eof_flags & XFS_EOF_FLAGS_GID) {
1259                 dst->icw_gid = make_kgid(current_user_ns(), src->eof_gid);
1260                 if (!gid_valid(dst->icw_gid))
1261                         return -EINVAL;
1262         }
1263         return 0;
1264 }
1265
1266 static int
1267 xfs_ioctl_getset_resblocks(
1268         struct file             *filp,
1269         unsigned int            cmd,
1270         void __user             *arg)
1271 {
1272         struct xfs_mount        *mp = XFS_I(file_inode(filp))->i_mount;
1273         struct xfs_fsop_resblks fsop = { };
1274         int                     error;
1275
1276         if (!capable(CAP_SYS_ADMIN))
1277                 return -EPERM;
1278
1279         if (cmd == XFS_IOC_SET_RESBLKS) {
1280                 if (xfs_is_readonly(mp))
1281                         return -EROFS;
1282
1283                 if (copy_from_user(&fsop, arg, sizeof(fsop)))
1284                         return -EFAULT;
1285
1286                 error = mnt_want_write_file(filp);
1287                 if (error)
1288                         return error;
1289                 error = xfs_reserve_blocks(mp, fsop.resblks);
1290                 mnt_drop_write_file(filp);
1291                 if (error)
1292                         return error;
1293         }
1294
1295         spin_lock(&mp->m_sb_lock);
1296         fsop.resblks = mp->m_resblks;
1297         fsop.resblks_avail = mp->m_resblks_avail;
1298         spin_unlock(&mp->m_sb_lock);
1299
1300         if (copy_to_user(arg, &fsop, sizeof(fsop)))
1301                 return -EFAULT;
1302         return 0;
1303 }
1304
1305 static int
1306 xfs_ioctl_fs_counts(
1307         struct xfs_mount        *mp,
1308         struct xfs_fsop_counts __user   *uarg)
1309 {
1310         struct xfs_fsop_counts  out = {
1311                 .allocino = percpu_counter_read_positive(&mp->m_icount),
1312                 .freeino  = percpu_counter_read_positive(&mp->m_ifree),
1313                 .freedata = percpu_counter_read_positive(&mp->m_fdblocks) -
1314                                 xfs_fdblocks_unavailable(mp),
1315                 .freertx  = percpu_counter_read_positive(&mp->m_frextents),
1316         };
1317
1318         if (copy_to_user(uarg, &out, sizeof(out)))
1319                 return -EFAULT;
1320         return 0;
1321 }
1322
1323 /*
1324  * These long-unused ioctls were removed from the official ioctl API in 5.17,
1325  * but retain these definitions so that we can log warnings about them.
1326  */
1327 #define XFS_IOC_ALLOCSP         _IOW ('X', 10, struct xfs_flock64)
1328 #define XFS_IOC_FREESP          _IOW ('X', 11, struct xfs_flock64)
1329 #define XFS_IOC_ALLOCSP64       _IOW ('X', 36, struct xfs_flock64)
1330 #define XFS_IOC_FREESP64        _IOW ('X', 37, struct xfs_flock64)
1331
1332 /*
1333  * Note: some of the ioctl's return positive numbers as a
1334  * byte count indicating success, such as readlink_by_handle.
1335  * So we don't "sign flip" like most other routines.  This means
1336  * true errors need to be returned as a negative value.
1337  */
1338 long
1339 xfs_file_ioctl(
1340         struct file             *filp,
1341         unsigned int            cmd,
1342         unsigned long           p)
1343 {
1344         struct inode            *inode = file_inode(filp);
1345         struct xfs_inode        *ip = XFS_I(inode);
1346         struct xfs_mount        *mp = ip->i_mount;
1347         void                    __user *arg = (void __user *)p;
1348         int                     error;
1349
1350         trace_xfs_file_ioctl(ip);
1351
1352         switch (cmd) {
1353         case FITRIM:
1354                 return xfs_ioc_trim(mp, arg);
1355         case FS_IOC_GETFSLABEL:
1356                 return xfs_ioc_getlabel(mp, arg);
1357         case FS_IOC_SETFSLABEL:
1358                 return xfs_ioc_setlabel(filp, mp, arg);
1359         case XFS_IOC_ALLOCSP:
1360         case XFS_IOC_FREESP:
1361         case XFS_IOC_ALLOCSP64:
1362         case XFS_IOC_FREESP64:
1363                 xfs_warn_once(mp,
1364         "%s should use fallocate; XFS_IOC_{ALLOC,FREE}SP ioctl unsupported",
1365                                 current->comm);
1366                 return -ENOTTY;
1367         case XFS_IOC_DIOINFO: {
1368                 struct xfs_buftarg      *target = xfs_inode_buftarg(ip);
1369                 struct dioattr          da;
1370
1371                 da.d_mem =  da.d_miniosz = target->bt_logical_sectorsize;
1372                 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1373
1374                 if (copy_to_user(arg, &da, sizeof(da)))
1375                         return -EFAULT;
1376                 return 0;
1377         }
1378
1379         case XFS_IOC_FSBULKSTAT_SINGLE:
1380         case XFS_IOC_FSBULKSTAT:
1381         case XFS_IOC_FSINUMBERS:
1382                 return xfs_ioc_fsbulkstat(filp, cmd, arg);
1383
1384         case XFS_IOC_BULKSTAT:
1385                 return xfs_ioc_bulkstat(filp, cmd, arg);
1386         case XFS_IOC_INUMBERS:
1387                 return xfs_ioc_inumbers(mp, cmd, arg);
1388
1389         case XFS_IOC_FSGEOMETRY_V1:
1390                 return xfs_ioc_fsgeometry(mp, arg, 3);
1391         case XFS_IOC_FSGEOMETRY_V4:
1392                 return xfs_ioc_fsgeometry(mp, arg, 4);
1393         case XFS_IOC_FSGEOMETRY:
1394                 return xfs_ioc_fsgeometry(mp, arg, 5);
1395
1396         case XFS_IOC_AG_GEOMETRY:
1397                 return xfs_ioc_ag_geometry(mp, arg);
1398
1399         case XFS_IOC_GETVERSION:
1400                 return put_user(inode->i_generation, (int __user *)arg);
1401
1402         case XFS_IOC_FSGETXATTRA:
1403                 return xfs_ioc_fsgetxattra(ip, arg);
1404         case XFS_IOC_GETPARENTS:
1405                 return xfs_ioc_getparents(filp, arg);
1406         case XFS_IOC_GETPARENTS_BY_HANDLE:
1407                 return xfs_ioc_getparents_by_handle(filp, arg);
1408         case XFS_IOC_GETBMAP:
1409         case XFS_IOC_GETBMAPA:
1410         case XFS_IOC_GETBMAPX:
1411                 return xfs_ioc_getbmap(filp, cmd, arg);
1412
1413         case FS_IOC_GETFSMAP:
1414                 return xfs_ioc_getfsmap(ip, arg);
1415
1416         case XFS_IOC_SCRUBV_METADATA:
1417                 return xfs_ioc_scrubv_metadata(filp, arg);
1418         case XFS_IOC_SCRUB_METADATA:
1419                 return xfs_ioc_scrub_metadata(filp, arg);
1420
1421         case XFS_IOC_FD_TO_HANDLE:
1422         case XFS_IOC_PATH_TO_HANDLE:
1423         case XFS_IOC_PATH_TO_FSHANDLE: {
1424                 xfs_fsop_handlereq_t    hreq;
1425
1426                 if (copy_from_user(&hreq, arg, sizeof(hreq)))
1427                         return -EFAULT;
1428                 return xfs_find_handle(cmd, &hreq);
1429         }
1430         case XFS_IOC_OPEN_BY_HANDLE: {
1431                 xfs_fsop_handlereq_t    hreq;
1432
1433                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1434                         return -EFAULT;
1435                 return xfs_open_by_handle(filp, &hreq);
1436         }
1437
1438         case XFS_IOC_READLINK_BY_HANDLE: {
1439                 xfs_fsop_handlereq_t    hreq;
1440
1441                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1442                         return -EFAULT;
1443                 return xfs_readlink_by_handle(filp, &hreq);
1444         }
1445         case XFS_IOC_ATTRLIST_BY_HANDLE:
1446                 return xfs_attrlist_by_handle(filp, arg);
1447
1448         case XFS_IOC_ATTRMULTI_BY_HANDLE:
1449                 return xfs_attrmulti_by_handle(filp, arg);
1450
1451         case XFS_IOC_SWAPEXT: {
1452                 struct xfs_swapext      sxp;
1453
1454                 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
1455                         return -EFAULT;
1456                 error = mnt_want_write_file(filp);
1457                 if (error)
1458                         return error;
1459                 error = xfs_ioc_swapext(&sxp);
1460                 mnt_drop_write_file(filp);
1461                 return error;
1462         }
1463
1464         case XFS_IOC_FSCOUNTS:
1465                 return xfs_ioctl_fs_counts(mp, arg);
1466
1467         case XFS_IOC_SET_RESBLKS:
1468         case XFS_IOC_GET_RESBLKS:
1469                 return xfs_ioctl_getset_resblocks(filp, cmd, arg);
1470
1471         case XFS_IOC_FSGROWFSDATA: {
1472                 struct xfs_growfs_data in;
1473
1474                 if (copy_from_user(&in, arg, sizeof(in)))
1475                         return -EFAULT;
1476
1477                 error = mnt_want_write_file(filp);
1478                 if (error)
1479                         return error;
1480                 error = xfs_growfs_data(mp, &in);
1481                 mnt_drop_write_file(filp);
1482                 return error;
1483         }
1484
1485         case XFS_IOC_FSGROWFSLOG: {
1486                 struct xfs_growfs_log in;
1487
1488                 if (copy_from_user(&in, arg, sizeof(in)))
1489                         return -EFAULT;
1490
1491                 error = mnt_want_write_file(filp);
1492                 if (error)
1493                         return error;
1494                 error = xfs_growfs_log(mp, &in);
1495                 mnt_drop_write_file(filp);
1496                 return error;
1497         }
1498
1499         case XFS_IOC_FSGROWFSRT: {
1500                 xfs_growfs_rt_t in;
1501
1502                 if (copy_from_user(&in, arg, sizeof(in)))
1503                         return -EFAULT;
1504
1505                 error = mnt_want_write_file(filp);
1506                 if (error)
1507                         return error;
1508                 error = xfs_growfs_rt(mp, &in);
1509                 mnt_drop_write_file(filp);
1510                 return error;
1511         }
1512
1513         case XFS_IOC_GOINGDOWN: {
1514                 uint32_t in;
1515
1516                 if (!capable(CAP_SYS_ADMIN))
1517                         return -EPERM;
1518
1519                 if (get_user(in, (uint32_t __user *)arg))
1520                         return -EFAULT;
1521
1522                 return xfs_fs_goingdown(mp, in);
1523         }
1524
1525         case XFS_IOC_ERROR_INJECTION: {
1526                 xfs_error_injection_t in;
1527
1528                 if (!capable(CAP_SYS_ADMIN))
1529                         return -EPERM;
1530
1531                 if (copy_from_user(&in, arg, sizeof(in)))
1532                         return -EFAULT;
1533
1534                 return xfs_errortag_add(mp, in.errtag);
1535         }
1536
1537         case XFS_IOC_ERROR_CLEARALL:
1538                 if (!capable(CAP_SYS_ADMIN))
1539                         return -EPERM;
1540
1541                 return xfs_errortag_clearall(mp);
1542
1543         case XFS_IOC_FREE_EOFBLOCKS: {
1544                 struct xfs_fs_eofblocks eofb;
1545                 struct xfs_icwalk       icw;
1546
1547                 if (!capable(CAP_SYS_ADMIN))
1548                         return -EPERM;
1549
1550                 if (xfs_is_readonly(mp))
1551                         return -EROFS;
1552
1553                 if (copy_from_user(&eofb, arg, sizeof(eofb)))
1554                         return -EFAULT;
1555
1556                 error = xfs_fs_eofblocks_from_user(&eofb, &icw);
1557                 if (error)
1558                         return error;
1559
1560                 trace_xfs_ioc_free_eofblocks(mp, &icw, _RET_IP_);
1561
1562                 sb_start_write(mp->m_super);
1563                 error = xfs_blockgc_free_space(mp, &icw);
1564                 sb_end_write(mp->m_super);
1565                 return error;
1566         }
1567
1568         case XFS_IOC_EXCHANGE_RANGE:
1569                 return xfs_ioc_exchange_range(filp, arg);
1570
1571         default:
1572                 return -ENOTTY;
1573         }
1574 }