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); 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 } 580