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