fs/xfs/xfs_fsops.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_sb.h"
  13 #include "xfs_mount.h"
  14 #include "xfs_trans.h"
  15 #include "xfs_error.h"
  16 #include "xfs_alloc.h"
  17 #include "xfs_fsops.h"
  18 #include "xfs_trans_space.h"
  19 #include "xfs_log.h"
  20 #include "xfs_log_priv.h"
  21 #include "xfs_ag.h"
  22 #include "xfs_ag_resv.h"
  23 #include "xfs_trace.h"
  24
  25 /*
  26  * Write new AG headers to disk. Non-transactional, but need to be
  27  * written and completed prior to the growfs transaction being logged.
  28  * To do this, we use a delayed write buffer list and wait for
  29  * submission and IO completion of the list as a whole. This allows the
  30  * IO subsystem to merge all the AG headers in a single AG into a single
  31  * IO and hide most of the latency of the IO from us.
  32  *
  33  * This also means that if we get an error whilst building the buffer
  34  * list to write, we can cancel the entire list without having written
  35  * anything.
  36  */
  37 static int
  38 xfs_resizefs_init_new_ags(
  39         struct xfs_trans        *tp,
  40         struct aghdr_init_data  *id,
  41         xfs_agnumber_t          oagcount,
  42         xfs_agnumber_t          nagcount,
  43         xfs_rfsblock_t          delta,
  44         bool                    *lastag_extended)
  45 {
  46         struct xfs_mount        *mp = tp->t_mountp;
  47         xfs_rfsblock_t          nb = mp->m_sb.sb_dblocks + delta;
  48         int                     error;
  49
  50         *lastag_extended = false;
  51
  52         INIT_LIST_HEAD(&id->buffer_list);
  53         for (id->agno = nagcount - 1;
  54              id->agno >= oagcount;
  55              id->agno--, delta -= id->agsize) {
  56
  57                 if (id->agno == nagcount - 1)
  58                         id->agsize = nb - (id->agno *
  59                                         (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
  60                 else
  61                         id->agsize = mp->m_sb.sb_agblocks;
  62
  63                 error = xfs_ag_init_headers(mp, id);
  64                 if (error) {
  65                         xfs_buf_delwri_cancel(&id->buffer_list);
  66                         return error;
  67                 }
  68         }
  69
  70         error = xfs_buf_delwri_submit(&id->buffer_list);
  71         if (error)
  72                 return error;
  73
  74         if (delta) {
  75                 *lastag_extended = true;
  76                 error = xfs_ag_extend_space(mp, tp, id, delta);
  77         }
  78         return error;
  79 }
  80
  81 /*
  82  * growfs operations
  83  */
  84 static int
  85 xfs_growfs_data_private(
  86         struct xfs_mount        *mp,            /* mount point for filesystem */
  87         struct xfs_growfs_data  *in)            /* growfs data input struct */
  88 {
  89         struct xfs_buf          *bp;
  90         int                     error;
  91         xfs_agnumber_t          nagcount;
  92         xfs_agnumber_t          nagimax = 0;
  93         xfs_rfsblock_t          nb, nb_div, nb_mod;
  94         int64_t                 delta;
  95         bool                    lastag_extended;
  96         xfs_agnumber_t          oagcount;
  97         struct xfs_trans        *tp;
  98         struct aghdr_init_data  id = {};
  99
 100         nb = in->newblocks;
 101         error = xfs_sb_validate_fsb_count(&mp->m_sb, nb);
 102         if (error)
 103                 return error;
 104
 105         if (nb > mp->m_sb.sb_dblocks) {
 106                 error = xfs_buf_read_uncached(mp->m_ddev_targp,
 107                                 XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
 108                                 XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
 109                 if (error)
 110                         return error;
 111                 xfs_buf_relse(bp);
 112         }
 113
 114         nb_div = nb;
 115         nb_mod = do_div(nb_div, mp->m_sb.sb_agblocks);
 116         nagcount = nb_div + (nb_mod != 0);
 117         if (nb_mod && nb_mod < XFS_MIN_AG_BLOCKS) {
 118                 nagcount--;
 119                 nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
 120         }
 121         delta = nb - mp->m_sb.sb_dblocks;
 122         /*
 123          * Reject filesystems with a single AG because they are not
 124          * supported, and reject a shrink operation that would cause a
 125          * filesystem to become unsupported.
 126          */
 127         if (delta < 0 && nagcount < 2)
 128                 return -EINVAL;
 129
 130         oagcount = mp->m_sb.sb_agcount;
 131
 132         /* allocate the new per-ag structures */
 133         if (nagcount > oagcount) {
 134                 error = xfs_initialize_perag(mp, nagcount, &nagimax);
 135                 if (error)
 136                         return error;
 137         } else if (nagcount < oagcount) {
 138                 /* TODO: shrinking the entire AGs hasn't yet completed */
 139                 return -EINVAL;
 140         }
 141
 142         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
 143                         (delta > 0 ? XFS_GROWFS_SPACE_RES(mp) : -delta), 0,
 144                         XFS_TRANS_RESERVE, &tp);
 145         if (error)
 146                 return error;
 147
 148         if (delta > 0) {
 149                 error = xfs_resizefs_init_new_ags(tp, &id, oagcount, nagcount,
 150                                                   delta, &lastag_extended);
 151         } else {
 152                 static struct ratelimit_state shrink_warning = \
 153                         RATELIMIT_STATE_INIT("shrink_warning", 86400 * HZ, 1);
 154                 ratelimit_set_flags(&shrink_warning, RATELIMIT_MSG_ON_RELEASE);
 155
 156                 if (__ratelimit(&shrink_warning))
 157                         xfs_alert(mp,
 158         "EXPERIMENTAL online shrink feature in use. Use at your own risk!");
 159
 160                 error = xfs_ag_shrink_space(mp, &tp, nagcount - 1, -delta);
 161         }
 162         if (error)
 163                 goto out_trans_cancel;
 164
 165         /*
 166          * Update changed superblock fields transactionally. These are not
 167          * seen by the rest of the world until the transaction commit applies
 168          * them atomically to the superblock.
 169          */
 170         if (nagcount > oagcount)
 171                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
 172         if (delta)
 173                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS, delta);
 174         if (id.nfree)
 175                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, id.nfree);
 176
 177         /*
 178          * Sync sb counters now to reflect the updated values. This is
 179          * particularly important for shrink because the write verifier
 180          * will fail if sb_fdblocks is ever larger than sb_dblocks.
 181          */
 182         if (xfs_has_lazysbcount(mp))
 183                 xfs_log_sb(tp);
 184
 185         xfs_trans_set_sync(tp);
 186         error = xfs_trans_commit(tp);
 187         if (error)
 188                 return error;
 189
 190         /* New allocation groups fully initialized, so update mount struct */
 191         if (nagimax)
 192                 mp->m_maxagi = nagimax;
 193         xfs_set_low_space_thresholds(mp);
 194         mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
 195
 196         if (delta > 0) {
 197                 /*
 198                  * If we expanded the last AG, free the per-AG reservation
 199                  * so we can reinitialize it with the new size.
 200                  */
 201                 if (lastag_extended) {
 202                         struct xfs_perag        *pag;
 203
 204                         pag = xfs_perag_get(mp, id.agno);
 205                         error = xfs_ag_resv_free(pag);
 206                         xfs_perag_put(pag);
 207                         if (error)
 208                                 return error;
 209                 }
 210                 /*
 211                  * Reserve AG metadata blocks. ENOSPC here does not mean there
 212                  * was a growfs failure, just that there still isn't space for
 213                  * new user data after the grow has been run.
 214                  */
 215                 error = xfs_fs_reserve_ag_blocks(mp);
 216                 if (error == -ENOSPC)
 217                         error = 0;
 218         }
 219         return error;
 220
 221 out_trans_cancel:
 222         xfs_trans_cancel(tp);
 223         return error;
 224 }
 225
 226 static int
 227 xfs_growfs_log_private(
 228         struct xfs_mount        *mp,    /* mount point for filesystem */
 229         struct xfs_growfs_log   *in)    /* growfs log input struct */
 230 {
 231         xfs_extlen_t            nb;
 232
 233         nb = in->newblocks;
 234         if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
 235                 return -EINVAL;
 236         if (nb == mp->m_sb.sb_logblocks &&
 237             in->isint == (mp->m_sb.sb_logstart != 0))
 238                 return -EINVAL;
 239         /*
 240          * Moving the log is hard, need new interfaces to sync
 241          * the log first, hold off all activity while moving it.
 242          * Can have shorter or longer log in the same space,
 243          * or transform internal to external log or vice versa.
 244          */
 245         return -ENOSYS;
 246 }
 247
 248 static int
 249 xfs_growfs_imaxpct(
 250         struct xfs_mount        *mp,
 251         __u32                   imaxpct)
 252 {
 253         struct xfs_trans        *tp;
 254         int                     dpct;
 255         int                     error;
 256
 257         if (imaxpct > 100)
 258                 return -EINVAL;
 259
 260         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
 261                         XFS_GROWFS_SPACE_RES(mp), 0, XFS_TRANS_RESERVE, &tp);
 262         if (error)
 263                 return error;
 264
 265         dpct = imaxpct - mp->m_sb.sb_imax_pct;
 266         xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
 267         xfs_trans_set_sync(tp);
 268         return xfs_trans_commit(tp);
 269 }
 270
 271 /*
 272  * protected versions of growfs function acquire and release locks on the mount
 273  * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
 274  * XFS_IOC_FSGROWFSRT
 275  */
 276 int
 277 xfs_growfs_data(
 278         struct xfs_mount        *mp,
 279         struct xfs_growfs_data  *in)
 280 {
 281         int                     error = 0;
 282
 283         if (!capable(CAP_SYS_ADMIN))
 284                 return -EPERM;
 285         if (!mutex_trylock(&mp->m_growlock))
 286                 return -EWOULDBLOCK;
 287
 288         /* update imaxpct separately to the physical grow of the filesystem */
 289         if (in->imaxpct != mp->m_sb.sb_imax_pct) {
 290                 error = xfs_growfs_imaxpct(mp, in->imaxpct);
 291                 if (error)
 292                         goto out_error;
 293         }
 294
 295         if (in->newblocks != mp->m_sb.sb_dblocks) {
 296                 error = xfs_growfs_data_private(mp, in);
 297                 if (error)
 298                         goto out_error;
 299         }
 300
 301         /* Post growfs calculations needed to reflect new state in operations */
 302         if (mp->m_sb.sb_imax_pct) {
 303                 uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
 304                 do_div(icount, 100);
 305                 M_IGEO(mp)->maxicount = XFS_FSB_TO_INO(mp, icount);
 306         } else
 307                 M_IGEO(mp)->maxicount = 0;
 308
 309         /* Update secondary superblocks now the physical grow has completed */
 310         error = xfs_update_secondary_sbs(mp);
 311
 312 out_error:
 313         /*
 314          * Increment the generation unconditionally, the error could be from
 315          * updating the secondary superblocks, in which case the new size
 316          * is live already.
 317          */
 318         mp->m_generation++;
 319         mutex_unlock(&mp->m_growlock);
 320         return error;
 321 }
 322
 323 int
 324 xfs_growfs_log(
 325         xfs_mount_t             *mp,
 326         struct xfs_growfs_log   *in)
 327 {
 328         int error;
 329
 330         if (!capable(CAP_SYS_ADMIN))
 331                 return -EPERM;
 332         if (!mutex_trylock(&mp->m_growlock))
 333                 return -EWOULDBLOCK;
 334         error = xfs_growfs_log_private(mp, in);
 335         mutex_unlock(&mp->m_growlock);
 336         return error;
 337 }
 338
 339 /*
 340  * exported through ioctl XFS_IOC_FSCOUNTS
 341  */
 342
 343 void
 344 xfs_fs_counts(
 345         xfs_mount_t             *mp,
 346         xfs_fsop_counts_t       *cnt)
 347 {
 348         cnt->allocino = percpu_counter_read_positive(&mp->m_icount);
 349         cnt->freeino = percpu_counter_read_positive(&mp->m_ifree);
 350         cnt->freedata = percpu_counter_read_positive(&mp->m_fdblocks) -
 351                                                 xfs_fdblocks_unavailable(mp);
 352
 353         spin_lock(&mp->m_sb_lock);
 354         cnt->freertx = mp->m_sb.sb_frextents;
 355         spin_unlock(&mp->m_sb_lock);
 356 }
 357
 358 /*
 359  * exported through ioctl XFS_IOC_SET_RESBLKS & XFS_IOC_GET_RESBLKS
 360  *
 361  * xfs_reserve_blocks is called to set m_resblks
 362  * in the in-core mount table. The number of unused reserved blocks
 363  * is kept in m_resblks_avail.
 364  *
 365  * Reserve the requested number of blocks if available. Otherwise return
 366  * as many as possible to satisfy the request. The actual number
 367  * reserved are returned in outval
 368  *
 369  * A null inval pointer indicates that only the current reserved blocks
 370  * available  should  be returned no settings are changed.
 371  */
 372
 373 int
 374 xfs_reserve_blocks(
 375         xfs_mount_t             *mp,
 376         uint64_t              *inval,
 377         xfs_fsop_resblks_t      *outval)
 378 {
 379         int64_t                 lcounter, delta;
 380         int64_t                 fdblks_delta = 0;
 381         uint64_t                request;
 382         int64_t                 free;
 383         int                     error = 0;
 384
 385         /* If inval is null, report current values and return */
 386         if (inval == (uint64_t *)NULL) {
 387                 if (!outval)
 388                         return -EINVAL;
 389                 outval->resblks = mp->m_resblks;
 390                 outval->resblks_avail = mp->m_resblks_avail;
 391                 return 0;
 392         }
 393
 394         request = *inval;
 395
 396         /*
 397          * With per-cpu counters, this becomes an interesting problem. we need
 398          * to work out if we are freeing or allocation blocks first, then we can
 399          * do the modification as necessary.
 400          *
 401          * We do this under the m_sb_lock so that if we are near ENOSPC, we will
 402          * hold out any changes while we work out what to do. This means that
 403          * the amount of free space can change while we do this, so we need to
 404          * retry if we end up trying to reserve more space than is available.
 405          */
 406         spin_lock(&mp->m_sb_lock);
 407
 408         /*
 409          * If our previous reservation was larger than the current value,
 410          * then move any unused blocks back to the free pool. Modify the resblks
 411          * counters directly since we shouldn't have any problems unreserving
 412          * space.
 413          */
 414         if (mp->m_resblks > request) {
 415                 lcounter = mp->m_resblks_avail - request;
 416                 if (lcounter  > 0) {            /* release unused blocks */
 417                         fdblks_delta = lcounter;
 418                         mp->m_resblks_avail -= lcounter;
 419                 }
 420                 mp->m_resblks = request;
 421                 if (fdblks_delta) {
 422                         spin_unlock(&mp->m_sb_lock);
 423                         error = xfs_mod_fdblocks(mp, fdblks_delta, 0);
 424                         spin_lock(&mp->m_sb_lock);
 425                 }
 426
 427                 goto out;
 428         }
 429
 430         /*
 431          * If the request is larger than the current reservation, reserve the
 432          * blocks before we update the reserve counters. Sample m_fdblocks and
 433          * perform a partial reservation if the request exceeds free space.
 434          *
 435          * The code below estimates how many blocks it can request from
 436          * fdblocks to stash in the reserve pool.  This is a classic TOCTOU
 437          * race since fdblocks updates are not always coordinated via
 438          * m_sb_lock.  Set the reserve size even if there's not enough free
 439          * space to fill it because mod_fdblocks will refill an undersized
 440          * reserve when it can.
 441          */
 442         free = percpu_counter_sum(&mp->m_fdblocks) -
 443                                                 xfs_fdblocks_unavailable(mp);
 444         delta = request - mp->m_resblks;
 445         mp->m_resblks = request;
 446         if (delta > 0 && free > 0) {
 447                 /*
 448                  * We'll either succeed in getting space from the free block
 449                  * count or we'll get an ENOSPC.  Don't set the reserved flag
 450                  * here - we don't want to reserve the extra reserve blocks
 451                  * from the reserve.
 452                  *
 453                  * The desired reserve size can change after we drop the lock.
 454                  * Use mod_fdblocks to put the space into the reserve or into
 455                  * fdblocks as appropriate.
 456                  */
 457                 fdblks_delta = min(free, delta);
 458                 spin_unlock(&mp->m_sb_lock);
 459                 error = xfs_mod_fdblocks(mp, -fdblks_delta, 0);
 460                 if (!error)
 461                         xfs_mod_fdblocks(mp, fdblks_delta, 0);
 462                 spin_lock(&mp->m_sb_lock);
 463         }
 464 out:
 465         if (outval) {
 466                 outval->resblks = mp->m_resblks;
 467                 outval->resblks_avail = mp->m_resblks_avail;
 468         }
 469
 470         spin_unlock(&mp->m_sb_lock);
 471         return error;
 472 }
 473
 474 int
 475 xfs_fs_goingdown(
 476         xfs_mount_t     *mp,
 477         uint32_t        inflags)
 478 {
 479         switch (inflags) {
 480         case XFS_FSOP_GOING_FLAGS_DEFAULT: {
 481                 if (!freeze_bdev(mp->m_super->s_bdev)) {
 482                         xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
 483                         thaw_bdev(mp->m_super->s_bdev);
 484                 }
 485                 break;
 486         }
 487         case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
 488                 xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
 489                 break;
 490         case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
 491                 xfs_force_shutdown(mp,
 492                                 SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
 493                 break;
 494         default:
 495                 return -EINVAL;
 496         }
 497
 498         return 0;
 499 }
 500
 501 /*
 502  * Force a shutdown of the filesystem instantly while keeping the filesystem
 503  * consistent. We don't do an unmount here; just shutdown the shop, make sure
 504  * that absolutely nothing persistent happens to this filesystem after this
 505  * point.
 506  *
 507  * The shutdown state change is atomic, resulting in the first and only the
 508  * first shutdown call processing the shutdown. This means we only shutdown the
 509  * log once as it requires, and we don't spam the logs when multiple concurrent
 510  * shutdowns race to set the shutdown flags.
 511  */
 512 void
 513 xfs_do_force_shutdown(
 514         struct xfs_mount *mp,
 515         int             flags,
 516         char            *fname,
 517         int             lnnum)
 518 {
 519         int             tag;
 520         const char      *why;
 521
 522
 523         if (test_and_set_bit(XFS_OPSTATE_SHUTDOWN, &mp->m_opstate)) {
 524                 xlog_shutdown_wait(mp->m_log);
 525                 return;
 526         }
 527         if (mp->m_sb_bp)
 528                 mp->m_sb_bp->b_flags |= XBF_DONE;
 529
 530         if (flags & SHUTDOWN_FORCE_UMOUNT)
 531                 xfs_alert(mp, "User initiated shutdown received.");
 532
 533         if (xlog_force_shutdown(mp->m_log, flags)) {
 534                 tag = XFS_PTAG_SHUTDOWN_LOGERROR;
 535                 why = "Log I/O Error";
 536         } else if (flags & SHUTDOWN_CORRUPT_INCORE) {
 537                 tag = XFS_PTAG_SHUTDOWN_CORRUPT;
 538                 why = "Corruption of in-memory data";
 539         } else {
 540                 tag = XFS_PTAG_SHUTDOWN_IOERROR;
 541                 why = "Metadata I/O Error";
 542         }
 543
 544         trace_xfs_force_shutdown(mp, tag, flags, fname, lnnum);
 545
 546         xfs_alert_tag(mp, tag,
 547 "%s (0x%x) detected at %pS (%s:%d).  Shutting down filesystem.",
 548                         why, flags, __return_address, fname, lnnum);
 549         xfs_alert(mp,
 550                 "Please unmount the filesystem and rectify the problem(s)");
 551         if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
 552                 xfs_stack_trace();
 553 }
 554
 555 /*
 556  * Reserve free space for per-AG metadata.
 557  */
 558 int
 559 xfs_fs_reserve_ag_blocks(
 560         struct xfs_mount        *mp)
 561 {
 562         xfs_agnumber_t          agno;
 563         struct xfs_perag        *pag;
 564         int                     error = 0;
 565         int                     err2;
 566
 567         mp->m_finobt_nores = false;
 568         for_each_perag(mp, agno, pag) {
 569                 err2 = xfs_ag_resv_init(pag, NULL);
 570                 if (err2 && !error)
 571                         error = err2;
 572         }
 573
 574         if (error && error != -ENOSPC) {
 575                 xfs_warn(mp,
 576         "Error %d reserving per-AG metadata reserve pool.", error);
 577                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 578         }
 579
 580         return error;
 581 }
 582
 583 /*
 584  * Free space reserved for per-AG metadata.
 585  */
 586 int
 587 xfs_fs_unreserve_ag_blocks(
 588         struct xfs_mount        *mp)
 589 {
 590         xfs_agnumber_t          agno;
 591         struct xfs_perag        *pag;
 592         int                     error = 0;
 593         int                     err2;
 594
 595         for_each_perag(mp, agno, pag) {
 596                 err2 = xfs_ag_resv_free(pag);
 597                 if (err2 && !error)
 598                         error = err2;
 599         }
 600
 601         if (error)
 602                 xfs_warn(mp,
 603         "Error %d freeing per-AG metadata reserve pool.", error);
 604
 605         return error;
 606 }