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