1 /* 2 * Copyright (c) 2000-2005 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18 #include "xfs.h" 19 #include "xfs_fs.h" 20 #include "xfs_types.h" 21 #include "xfs_bit.h" 22 #include "xfs_log.h" 23 #include "xfs_inum.h" 24 #include "xfs_trans.h" 25 #include "xfs_sb.h" 26 #include "xfs_ag.h" 27 #include "xfs_dir2.h" 28 #include "xfs_mount.h" 29 #include "xfs_bmap_btree.h" 30 #include "xfs_alloc_btree.h" 31 #include "xfs_ialloc_btree.h" 32 #include "xfs_dinode.h" 33 #include "xfs_inode.h" 34 #include "xfs_btree.h" 35 #include "xfs_ialloc.h" 36 #include "xfs_alloc.h" 37 #include "xfs_rtalloc.h" 38 #include "xfs_bmap.h" 39 #include "xfs_error.h" 40 #include "xfs_rw.h" 41 #include "xfs_quota.h" 42 #include "xfs_fsops.h" 43 #include "xfs_utils.h" 44 #include "xfs_trace.h" 45 46 47 #ifdef HAVE_PERCPU_SB 48 STATIC void xfs_icsb_balance_counter(xfs_mount_t *, xfs_sb_field_t, 49 int); 50 STATIC void xfs_icsb_balance_counter_locked(xfs_mount_t *, xfs_sb_field_t, 51 int); 52 STATIC void xfs_icsb_disable_counter(xfs_mount_t *, xfs_sb_field_t); 53 #else 54 55 #define xfs_icsb_balance_counter(mp, a, b) do { } while (0) 56 #define xfs_icsb_balance_counter_locked(mp, a, b) do { } while (0) 57 #endif 58 59 static const struct { 60 short offset; 61 short type; /* 0 = integer 62 * 1 = binary / string (no translation) 63 */ 64 } xfs_sb_info[] = { 65 { offsetof(xfs_sb_t, sb_magicnum), 0 }, 66 { offsetof(xfs_sb_t, sb_blocksize), 0 }, 67 { offsetof(xfs_sb_t, sb_dblocks), 0 }, 68 { offsetof(xfs_sb_t, sb_rblocks), 0 }, 69 { offsetof(xfs_sb_t, sb_rextents), 0 }, 70 { offsetof(xfs_sb_t, sb_uuid), 1 }, 71 { offsetof(xfs_sb_t, sb_logstart), 0 }, 72 { offsetof(xfs_sb_t, sb_rootino), 0 }, 73 { offsetof(xfs_sb_t, sb_rbmino), 0 }, 74 { offsetof(xfs_sb_t, sb_rsumino), 0 }, 75 { offsetof(xfs_sb_t, sb_rextsize), 0 }, 76 { offsetof(xfs_sb_t, sb_agblocks), 0 }, 77 { offsetof(xfs_sb_t, sb_agcount), 0 }, 78 { offsetof(xfs_sb_t, sb_rbmblocks), 0 }, 79 { offsetof(xfs_sb_t, sb_logblocks), 0 }, 80 { offsetof(xfs_sb_t, sb_versionnum), 0 }, 81 { offsetof(xfs_sb_t, sb_sectsize), 0 }, 82 { offsetof(xfs_sb_t, sb_inodesize), 0 }, 83 { offsetof(xfs_sb_t, sb_inopblock), 0 }, 84 { offsetof(xfs_sb_t, sb_fname[0]), 1 }, 85 { offsetof(xfs_sb_t, sb_blocklog), 0 }, 86 { offsetof(xfs_sb_t, sb_sectlog), 0 }, 87 { offsetof(xfs_sb_t, sb_inodelog), 0 }, 88 { offsetof(xfs_sb_t, sb_inopblog), 0 }, 89 { offsetof(xfs_sb_t, sb_agblklog), 0 }, 90 { offsetof(xfs_sb_t, sb_rextslog), 0 }, 91 { offsetof(xfs_sb_t, sb_inprogress), 0 }, 92 { offsetof(xfs_sb_t, sb_imax_pct), 0 }, 93 { offsetof(xfs_sb_t, sb_icount), 0 }, 94 { offsetof(xfs_sb_t, sb_ifree), 0 }, 95 { offsetof(xfs_sb_t, sb_fdblocks), 0 }, 96 { offsetof(xfs_sb_t, sb_frextents), 0 }, 97 { offsetof(xfs_sb_t, sb_uquotino), 0 }, 98 { offsetof(xfs_sb_t, sb_gquotino), 0 }, 99 { offsetof(xfs_sb_t, sb_qflags), 0 }, 100 { offsetof(xfs_sb_t, sb_flags), 0 }, 101 { offsetof(xfs_sb_t, sb_shared_vn), 0 }, 102 { offsetof(xfs_sb_t, sb_inoalignmt), 0 }, 103 { offsetof(xfs_sb_t, sb_unit), 0 }, 104 { offsetof(xfs_sb_t, sb_width), 0 }, 105 { offsetof(xfs_sb_t, sb_dirblklog), 0 }, 106 { offsetof(xfs_sb_t, sb_logsectlog), 0 }, 107 { offsetof(xfs_sb_t, sb_logsectsize),0 }, 108 { offsetof(xfs_sb_t, sb_logsunit), 0 }, 109 { offsetof(xfs_sb_t, sb_features2), 0 }, 110 { offsetof(xfs_sb_t, sb_bad_features2), 0 }, 111 { sizeof(xfs_sb_t), 0 } 112 }; 113 114 static DEFINE_MUTEX(xfs_uuid_table_mutex); 115 static int xfs_uuid_table_size; 116 static uuid_t *xfs_uuid_table; 117 118 /* 119 * See if the UUID is unique among mounted XFS filesystems. 120 * Mount fails if UUID is nil or a FS with the same UUID is already mounted. 121 */ 122 STATIC int 123 xfs_uuid_mount( 124 struct xfs_mount *mp) 125 { 126 uuid_t *uuid = &mp->m_sb.sb_uuid; 127 int hole, i; 128 129 if (mp->m_flags & XFS_MOUNT_NOUUID) 130 return 0; 131 132 if (uuid_is_nil(uuid)) { 133 xfs_warn(mp, "Filesystem has nil UUID - can't mount"); 134 return XFS_ERROR(EINVAL); 135 } 136 137 mutex_lock(&xfs_uuid_table_mutex); 138 for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) { 139 if (uuid_is_nil(&xfs_uuid_table[i])) { 140 hole = i; 141 continue; 142 } 143 if (uuid_equal(uuid, &xfs_uuid_table[i])) 144 goto out_duplicate; 145 } 146 147 if (hole < 0) { 148 xfs_uuid_table = kmem_realloc(xfs_uuid_table, 149 (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table), 150 xfs_uuid_table_size * sizeof(*xfs_uuid_table), 151 KM_SLEEP); 152 hole = xfs_uuid_table_size++; 153 } 154 xfs_uuid_table[hole] = *uuid; 155 mutex_unlock(&xfs_uuid_table_mutex); 156 157 return 0; 158 159 out_duplicate: 160 mutex_unlock(&xfs_uuid_table_mutex); 161 xfs_warn(mp, "Filesystem has duplicate UUID - can't mount"); 162 return XFS_ERROR(EINVAL); 163 } 164 165 STATIC void 166 xfs_uuid_unmount( 167 struct xfs_mount *mp) 168 { 169 uuid_t *uuid = &mp->m_sb.sb_uuid; 170 int i; 171 172 if (mp->m_flags & XFS_MOUNT_NOUUID) 173 return; 174 175 mutex_lock(&xfs_uuid_table_mutex); 176 for (i = 0; i < xfs_uuid_table_size; i++) { 177 if (uuid_is_nil(&xfs_uuid_table[i])) 178 continue; 179 if (!uuid_equal(uuid, &xfs_uuid_table[i])) 180 continue; 181 memset(&xfs_uuid_table[i], 0, sizeof(uuid_t)); 182 break; 183 } 184 ASSERT(i < xfs_uuid_table_size); 185 mutex_unlock(&xfs_uuid_table_mutex); 186 } 187 188 189 /* 190 * Reference counting access wrappers to the perag structures. 191 * Because we never free per-ag structures, the only thing we 192 * have to protect against changes is the tree structure itself. 193 */ 194 struct xfs_perag * 195 xfs_perag_get(struct xfs_mount *mp, xfs_agnumber_t agno) 196 { 197 struct xfs_perag *pag; 198 int ref = 0; 199 200 rcu_read_lock(); 201 pag = radix_tree_lookup(&mp->m_perag_tree, agno); 202 if (pag) { 203 ASSERT(atomic_read(&pag->pag_ref) >= 0); 204 ref = atomic_inc_return(&pag->pag_ref); 205 } 206 rcu_read_unlock(); 207 trace_xfs_perag_get(mp, agno, ref, _RET_IP_); 208 return pag; 209 } 210 211 /* 212 * search from @first to find the next perag with the given tag set. 213 */ 214 struct xfs_perag * 215 xfs_perag_get_tag( 216 struct xfs_mount *mp, 217 xfs_agnumber_t first, 218 int tag) 219 { 220 struct xfs_perag *pag; 221 int found; 222 int ref; 223 224 rcu_read_lock(); 225 found = radix_tree_gang_lookup_tag(&mp->m_perag_tree, 226 (void **)&pag, first, 1, tag); 227 if (found <= 0) { 228 rcu_read_unlock(); 229 return NULL; 230 } 231 ref = atomic_inc_return(&pag->pag_ref); 232 rcu_read_unlock(); 233 trace_xfs_perag_get_tag(mp, pag->pag_agno, ref, _RET_IP_); 234 return pag; 235 } 236 237 void 238 xfs_perag_put(struct xfs_perag *pag) 239 { 240 int ref; 241 242 ASSERT(atomic_read(&pag->pag_ref) > 0); 243 ref = atomic_dec_return(&pag->pag_ref); 244 trace_xfs_perag_put(pag->pag_mount, pag->pag_agno, ref, _RET_IP_); 245 } 246 247 STATIC void 248 __xfs_free_perag( 249 struct rcu_head *head) 250 { 251 struct xfs_perag *pag = container_of(head, struct xfs_perag, rcu_head); 252 253 ASSERT(atomic_read(&pag->pag_ref) == 0); 254 kmem_free(pag); 255 } 256 257 /* 258 * Free up the per-ag resources associated with the mount structure. 259 */ 260 STATIC void 261 xfs_free_perag( 262 xfs_mount_t *mp) 263 { 264 xfs_agnumber_t agno; 265 struct xfs_perag *pag; 266 267 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) { 268 spin_lock(&mp->m_perag_lock); 269 pag = radix_tree_delete(&mp->m_perag_tree, agno); 270 spin_unlock(&mp->m_perag_lock); 271 ASSERT(pag); 272 ASSERT(atomic_read(&pag->pag_ref) == 0); 273 call_rcu(&pag->rcu_head, __xfs_free_perag); 274 } 275 } 276 277 /* 278 * Check size of device based on the (data/realtime) block count. 279 * Note: this check is used by the growfs code as well as mount. 280 */ 281 int 282 xfs_sb_validate_fsb_count( 283 xfs_sb_t *sbp, 284 __uint64_t nblocks) 285 { 286 ASSERT(PAGE_SHIFT >= sbp->sb_blocklog); 287 ASSERT(sbp->sb_blocklog >= BBSHIFT); 288 289 #if XFS_BIG_BLKNOS /* Limited by ULONG_MAX of page cache index */ 290 if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX) 291 return EFBIG; 292 #else /* Limited by UINT_MAX of sectors */ 293 if (nblocks << (sbp->sb_blocklog - BBSHIFT) > UINT_MAX) 294 return EFBIG; 295 #endif 296 return 0; 297 } 298 299 /* 300 * Check the validity of the SB found. 301 */ 302 STATIC int 303 xfs_mount_validate_sb( 304 xfs_mount_t *mp, 305 xfs_sb_t *sbp, 306 int flags) 307 { 308 int loud = !(flags & XFS_MFSI_QUIET); 309 310 /* 311 * If the log device and data device have the 312 * same device number, the log is internal. 313 * Consequently, the sb_logstart should be non-zero. If 314 * we have a zero sb_logstart in this case, we may be trying to mount 315 * a volume filesystem in a non-volume manner. 316 */ 317 if (sbp->sb_magicnum != XFS_SB_MAGIC) { 318 if (loud) 319 xfs_warn(mp, "bad magic number"); 320 return XFS_ERROR(EWRONGFS); 321 } 322 323 if (!xfs_sb_good_version(sbp)) { 324 if (loud) 325 xfs_warn(mp, "bad version"); 326 return XFS_ERROR(EWRONGFS); 327 } 328 329 if (unlikely( 330 sbp->sb_logstart == 0 && mp->m_logdev_targp == mp->m_ddev_targp)) { 331 if (loud) 332 xfs_warn(mp, 333 "filesystem is marked as having an external log; " 334 "specify logdev on the mount command line."); 335 return XFS_ERROR(EINVAL); 336 } 337 338 if (unlikely( 339 sbp->sb_logstart != 0 && mp->m_logdev_targp != mp->m_ddev_targp)) { 340 if (loud) 341 xfs_warn(mp, 342 "filesystem is marked as having an internal log; " 343 "do not specify logdev on the mount command line."); 344 return XFS_ERROR(EINVAL); 345 } 346 347 /* 348 * More sanity checking. Most of these were stolen directly from 349 * xfs_repair. 350 */ 351 if (unlikely( 352 sbp->sb_agcount <= 0 || 353 sbp->sb_sectsize < XFS_MIN_SECTORSIZE || 354 sbp->sb_sectsize > XFS_MAX_SECTORSIZE || 355 sbp->sb_sectlog < XFS_MIN_SECTORSIZE_LOG || 356 sbp->sb_sectlog > XFS_MAX_SECTORSIZE_LOG || 357 sbp->sb_sectsize != (1 << sbp->sb_sectlog) || 358 sbp->sb_blocksize < XFS_MIN_BLOCKSIZE || 359 sbp->sb_blocksize > XFS_MAX_BLOCKSIZE || 360 sbp->sb_blocklog < XFS_MIN_BLOCKSIZE_LOG || 361 sbp->sb_blocklog > XFS_MAX_BLOCKSIZE_LOG || 362 sbp->sb_blocksize != (1 << sbp->sb_blocklog) || 363 sbp->sb_inodesize < XFS_DINODE_MIN_SIZE || 364 sbp->sb_inodesize > XFS_DINODE_MAX_SIZE || 365 sbp->sb_inodelog < XFS_DINODE_MIN_LOG || 366 sbp->sb_inodelog > XFS_DINODE_MAX_LOG || 367 sbp->sb_inodesize != (1 << sbp->sb_inodelog) || 368 (sbp->sb_blocklog - sbp->sb_inodelog != sbp->sb_inopblog) || 369 (sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE) || 370 (sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE) || 371 (sbp->sb_imax_pct > 100 /* zero sb_imax_pct is valid */) || 372 sbp->sb_dblocks == 0 || 373 sbp->sb_dblocks > XFS_MAX_DBLOCKS(sbp) || 374 sbp->sb_dblocks < XFS_MIN_DBLOCKS(sbp))) { 375 if (loud) 376 XFS_CORRUPTION_ERROR("SB sanity check failed", 377 XFS_ERRLEVEL_LOW, mp, sbp); 378 return XFS_ERROR(EFSCORRUPTED); 379 } 380 381 /* 382 * Until this is fixed only page-sized or smaller data blocks work. 383 */ 384 if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) { 385 if (loud) { 386 xfs_warn(mp, 387 "File system with blocksize %d bytes. " 388 "Only pagesize (%ld) or less will currently work.", 389 sbp->sb_blocksize, PAGE_SIZE); 390 } 391 return XFS_ERROR(ENOSYS); 392 } 393 394 /* 395 * Currently only very few inode sizes are supported. 396 */ 397 switch (sbp->sb_inodesize) { 398 case 256: 399 case 512: 400 case 1024: 401 case 2048: 402 break; 403 default: 404 if (loud) 405 xfs_warn(mp, "inode size of %d bytes not supported", 406 sbp->sb_inodesize); 407 return XFS_ERROR(ENOSYS); 408 } 409 410 if (xfs_sb_validate_fsb_count(sbp, sbp->sb_dblocks) || 411 xfs_sb_validate_fsb_count(sbp, sbp->sb_rblocks)) { 412 if (loud) 413 xfs_warn(mp, 414 "file system too large to be mounted on this system."); 415 return XFS_ERROR(EFBIG); 416 } 417 418 if (unlikely(sbp->sb_inprogress)) { 419 if (loud) 420 xfs_warn(mp, "file system busy"); 421 return XFS_ERROR(EFSCORRUPTED); 422 } 423 424 /* 425 * Version 1 directory format has never worked on Linux. 426 */ 427 if (unlikely(!xfs_sb_version_hasdirv2(sbp))) { 428 if (loud) 429 xfs_warn(mp, 430 "file system using version 1 directory format"); 431 return XFS_ERROR(ENOSYS); 432 } 433 434 return 0; 435 } 436 437 int 438 xfs_initialize_perag( 439 xfs_mount_t *mp, 440 xfs_agnumber_t agcount, 441 xfs_agnumber_t *maxagi) 442 { 443 xfs_agnumber_t index, max_metadata; 444 xfs_agnumber_t first_initialised = 0; 445 xfs_perag_t *pag; 446 xfs_agino_t agino; 447 xfs_ino_t ino; 448 xfs_sb_t *sbp = &mp->m_sb; 449 int error = -ENOMEM; 450 451 /* 452 * Walk the current per-ag tree so we don't try to initialise AGs 453 * that already exist (growfs case). Allocate and insert all the 454 * AGs we don't find ready for initialisation. 455 */ 456 for (index = 0; index < agcount; index++) { 457 pag = xfs_perag_get(mp, index); 458 if (pag) { 459 xfs_perag_put(pag); 460 continue; 461 } 462 if (!first_initialised) 463 first_initialised = index; 464 465 pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL); 466 if (!pag) 467 goto out_unwind; 468 pag->pag_agno = index; 469 pag->pag_mount = mp; 470 spin_lock_init(&pag->pag_ici_lock); 471 mutex_init(&pag->pag_ici_reclaim_lock); 472 INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC); 473 spin_lock_init(&pag->pag_buf_lock); 474 pag->pag_buf_tree = RB_ROOT; 475 476 if (radix_tree_preload(GFP_NOFS)) 477 goto out_unwind; 478 479 spin_lock(&mp->m_perag_lock); 480 if (radix_tree_insert(&mp->m_perag_tree, index, pag)) { 481 BUG(); 482 spin_unlock(&mp->m_perag_lock); 483 radix_tree_preload_end(); 484 error = -EEXIST; 485 goto out_unwind; 486 } 487 spin_unlock(&mp->m_perag_lock); 488 radix_tree_preload_end(); 489 } 490 491 /* 492 * If we mount with the inode64 option, or no inode overflows 493 * the legacy 32-bit address space clear the inode32 option. 494 */ 495 agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0); 496 ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino); 497 498 if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > XFS_MAXINUMBER_32) 499 mp->m_flags |= XFS_MOUNT_32BITINODES; 500 else 501 mp->m_flags &= ~XFS_MOUNT_32BITINODES; 502 503 if (mp->m_flags & XFS_MOUNT_32BITINODES) { 504 /* 505 * Calculate how much should be reserved for inodes to meet 506 * the max inode percentage. 507 */ 508 if (mp->m_maxicount) { 509 __uint64_t icount; 510 511 icount = sbp->sb_dblocks * sbp->sb_imax_pct; 512 do_div(icount, 100); 513 icount += sbp->sb_agblocks - 1; 514 do_div(icount, sbp->sb_agblocks); 515 max_metadata = icount; 516 } else { 517 max_metadata = agcount; 518 } 519 520 for (index = 0; index < agcount; index++) { 521 ino = XFS_AGINO_TO_INO(mp, index, agino); 522 if (ino > XFS_MAXINUMBER_32) { 523 index++; 524 break; 525 } 526 527 pag = xfs_perag_get(mp, index); 528 pag->pagi_inodeok = 1; 529 if (index < max_metadata) 530 pag->pagf_metadata = 1; 531 xfs_perag_put(pag); 532 } 533 } else { 534 for (index = 0; index < agcount; index++) { 535 pag = xfs_perag_get(mp, index); 536 pag->pagi_inodeok = 1; 537 xfs_perag_put(pag); 538 } 539 } 540 541 if (maxagi) 542 *maxagi = index; 543 return 0; 544 545 out_unwind: 546 kmem_free(pag); 547 for (; index > first_initialised; index--) { 548 pag = radix_tree_delete(&mp->m_perag_tree, index); 549 kmem_free(pag); 550 } 551 return error; 552 } 553 554 void 555 xfs_sb_from_disk( 556 xfs_sb_t *to, 557 xfs_dsb_t *from) 558 { 559 to->sb_magicnum = be32_to_cpu(from->sb_magicnum); 560 to->sb_blocksize = be32_to_cpu(from->sb_blocksize); 561 to->sb_dblocks = be64_to_cpu(from->sb_dblocks); 562 to->sb_rblocks = be64_to_cpu(from->sb_rblocks); 563 to->sb_rextents = be64_to_cpu(from->sb_rextents); 564 memcpy(&to->sb_uuid, &from->sb_uuid, sizeof(to->sb_uuid)); 565 to->sb_logstart = be64_to_cpu(from->sb_logstart); 566 to->sb_rootino = be64_to_cpu(from->sb_rootino); 567 to->sb_rbmino = be64_to_cpu(from->sb_rbmino); 568 to->sb_rsumino = be64_to_cpu(from->sb_rsumino); 569 to->sb_rextsize = be32_to_cpu(from->sb_rextsize); 570 to->sb_agblocks = be32_to_cpu(from->sb_agblocks); 571 to->sb_agcount = be32_to_cpu(from->sb_agcount); 572 to->sb_rbmblocks = be32_to_cpu(from->sb_rbmblocks); 573 to->sb_logblocks = be32_to_cpu(from->sb_logblocks); 574 to->sb_versionnum = be16_to_cpu(from->sb_versionnum); 575 to->sb_sectsize = be16_to_cpu(from->sb_sectsize); 576 to->sb_inodesize = be16_to_cpu(from->sb_inodesize); 577 to->sb_inopblock = be16_to_cpu(from->sb_inopblock); 578 memcpy(&to->sb_fname, &from->sb_fname, sizeof(to->sb_fname)); 579 to->sb_blocklog = from->sb_blocklog; 580 to->sb_sectlog = from->sb_sectlog; 581 to->sb_inodelog = from->sb_inodelog; 582 to->sb_inopblog = from->sb_inopblog; 583 to->sb_agblklog = from->sb_agblklog; 584 to->sb_rextslog = from->sb_rextslog; 585 to->sb_inprogress = from->sb_inprogress; 586 to->sb_imax_pct = from->sb_imax_pct; 587 to->sb_icount = be64_to_cpu(from->sb_icount); 588 to->sb_ifree = be64_to_cpu(from->sb_ifree); 589 to->sb_fdblocks = be64_to_cpu(from->sb_fdblocks); 590 to->sb_frextents = be64_to_cpu(from->sb_frextents); 591 to->sb_uquotino = be64_to_cpu(from->sb_uquotino); 592 to->sb_gquotino = be64_to_cpu(from->sb_gquotino); 593 to->sb_qflags = be16_to_cpu(from->sb_qflags); 594 to->sb_flags = from->sb_flags; 595 to->sb_shared_vn = from->sb_shared_vn; 596 to->sb_inoalignmt = be32_to_cpu(from->sb_inoalignmt); 597 to->sb_unit = be32_to_cpu(from->sb_unit); 598 to->sb_width = be32_to_cpu(from->sb_width); 599 to->sb_dirblklog = from->sb_dirblklog; 600 to->sb_logsectlog = from->sb_logsectlog; 601 to->sb_logsectsize = be16_to_cpu(from->sb_logsectsize); 602 to->sb_logsunit = be32_to_cpu(from->sb_logsunit); 603 to->sb_features2 = be32_to_cpu(from->sb_features2); 604 to->sb_bad_features2 = be32_to_cpu(from->sb_bad_features2); 605 } 606 607 /* 608 * Copy in core superblock to ondisk one. 609 * 610 * The fields argument is mask of superblock fields to copy. 611 */ 612 void 613 xfs_sb_to_disk( 614 xfs_dsb_t *to, 615 xfs_sb_t *from, 616 __int64_t fields) 617 { 618 xfs_caddr_t to_ptr = (xfs_caddr_t)to; 619 xfs_caddr_t from_ptr = (xfs_caddr_t)from; 620 xfs_sb_field_t f; 621 int first; 622 int size; 623 624 ASSERT(fields); 625 if (!fields) 626 return; 627 628 while (fields) { 629 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields); 630 first = xfs_sb_info[f].offset; 631 size = xfs_sb_info[f + 1].offset - first; 632 633 ASSERT(xfs_sb_info[f].type == 0 || xfs_sb_info[f].type == 1); 634 635 if (size == 1 || xfs_sb_info[f].type == 1) { 636 memcpy(to_ptr + first, from_ptr + first, size); 637 } else { 638 switch (size) { 639 case 2: 640 *(__be16 *)(to_ptr + first) = 641 cpu_to_be16(*(__u16 *)(from_ptr + first)); 642 break; 643 case 4: 644 *(__be32 *)(to_ptr + first) = 645 cpu_to_be32(*(__u32 *)(from_ptr + first)); 646 break; 647 case 8: 648 *(__be64 *)(to_ptr + first) = 649 cpu_to_be64(*(__u64 *)(from_ptr + first)); 650 break; 651 default: 652 ASSERT(0); 653 } 654 } 655 656 fields &= ~(1LL << f); 657 } 658 } 659 660 /* 661 * xfs_readsb 662 * 663 * Does the initial read of the superblock. 664 */ 665 int 666 xfs_readsb(xfs_mount_t *mp, int flags) 667 { 668 unsigned int sector_size; 669 xfs_buf_t *bp; 670 int error; 671 int loud = !(flags & XFS_MFSI_QUIET); 672 673 ASSERT(mp->m_sb_bp == NULL); 674 ASSERT(mp->m_ddev_targp != NULL); 675 676 /* 677 * Allocate a (locked) buffer to hold the superblock. 678 * This will be kept around at all times to optimize 679 * access to the superblock. 680 */ 681 sector_size = xfs_getsize_buftarg(mp->m_ddev_targp); 682 683 reread: 684 bp = xfs_buf_read_uncached(mp, mp->m_ddev_targp, 685 XFS_SB_DADDR, sector_size, 0); 686 if (!bp) { 687 if (loud) 688 xfs_warn(mp, "SB buffer read failed"); 689 return EIO; 690 } 691 692 /* 693 * Initialize the mount structure from the superblock. 694 * But first do some basic consistency checking. 695 */ 696 xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp)); 697 error = xfs_mount_validate_sb(mp, &(mp->m_sb), flags); 698 if (error) { 699 if (loud) 700 xfs_warn(mp, "SB validate failed"); 701 goto release_buf; 702 } 703 704 /* 705 * We must be able to do sector-sized and sector-aligned IO. 706 */ 707 if (sector_size > mp->m_sb.sb_sectsize) { 708 if (loud) 709 xfs_warn(mp, "device supports %u byte sectors (not %u)", 710 sector_size, mp->m_sb.sb_sectsize); 711 error = ENOSYS; 712 goto release_buf; 713 } 714 715 /* 716 * If device sector size is smaller than the superblock size, 717 * re-read the superblock so the buffer is correctly sized. 718 */ 719 if (sector_size < mp->m_sb.sb_sectsize) { 720 xfs_buf_relse(bp); 721 sector_size = mp->m_sb.sb_sectsize; 722 goto reread; 723 } 724 725 /* Initialize per-cpu counters */ 726 xfs_icsb_reinit_counters(mp); 727 728 mp->m_sb_bp = bp; 729 xfs_buf_unlock(bp); 730 return 0; 731 732 release_buf: 733 xfs_buf_relse(bp); 734 return error; 735 } 736 737 738 /* 739 * xfs_mount_common 740 * 741 * Mount initialization code establishing various mount 742 * fields from the superblock associated with the given 743 * mount structure 744 */ 745 STATIC void 746 xfs_mount_common(xfs_mount_t *mp, xfs_sb_t *sbp) 747 { 748 mp->m_agfrotor = mp->m_agirotor = 0; 749 spin_lock_init(&mp->m_agirotor_lock); 750 mp->m_maxagi = mp->m_sb.sb_agcount; 751 mp->m_blkbit_log = sbp->sb_blocklog + XFS_NBBYLOG; 752 mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT; 753 mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT; 754 mp->m_agno_log = xfs_highbit32(sbp->sb_agcount - 1) + 1; 755 mp->m_agino_log = sbp->sb_inopblog + sbp->sb_agblklog; 756 mp->m_blockmask = sbp->sb_blocksize - 1; 757 mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG; 758 mp->m_blockwmask = mp->m_blockwsize - 1; 759 760 mp->m_alloc_mxr[0] = xfs_allocbt_maxrecs(mp, sbp->sb_blocksize, 1); 761 mp->m_alloc_mxr[1] = xfs_allocbt_maxrecs(mp, sbp->sb_blocksize, 0); 762 mp->m_alloc_mnr[0] = mp->m_alloc_mxr[0] / 2; 763 mp->m_alloc_mnr[1] = mp->m_alloc_mxr[1] / 2; 764 765 mp->m_inobt_mxr[0] = xfs_inobt_maxrecs(mp, sbp->sb_blocksize, 1); 766 mp->m_inobt_mxr[1] = xfs_inobt_maxrecs(mp, sbp->sb_blocksize, 0); 767 mp->m_inobt_mnr[0] = mp->m_inobt_mxr[0] / 2; 768 mp->m_inobt_mnr[1] = mp->m_inobt_mxr[1] / 2; 769 770 mp->m_bmap_dmxr[0] = xfs_bmbt_maxrecs(mp, sbp->sb_blocksize, 1); 771 mp->m_bmap_dmxr[1] = xfs_bmbt_maxrecs(mp, sbp->sb_blocksize, 0); 772 mp->m_bmap_dmnr[0] = mp->m_bmap_dmxr[0] / 2; 773 mp->m_bmap_dmnr[1] = mp->m_bmap_dmxr[1] / 2; 774 775 mp->m_bsize = XFS_FSB_TO_BB(mp, 1); 776 mp->m_ialloc_inos = (int)MAX((__uint16_t)XFS_INODES_PER_CHUNK, 777 sbp->sb_inopblock); 778 mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog; 779 } 780 781 /* 782 * xfs_initialize_perag_data 783 * 784 * Read in each per-ag structure so we can count up the number of 785 * allocated inodes, free inodes and used filesystem blocks as this 786 * information is no longer persistent in the superblock. Once we have 787 * this information, write it into the in-core superblock structure. 788 */ 789 STATIC int 790 xfs_initialize_perag_data(xfs_mount_t *mp, xfs_agnumber_t agcount) 791 { 792 xfs_agnumber_t index; 793 xfs_perag_t *pag; 794 xfs_sb_t *sbp = &mp->m_sb; 795 uint64_t ifree = 0; 796 uint64_t ialloc = 0; 797 uint64_t bfree = 0; 798 uint64_t bfreelst = 0; 799 uint64_t btree = 0; 800 int error; 801 802 for (index = 0; index < agcount; index++) { 803 /* 804 * read the agf, then the agi. This gets us 805 * all the information we need and populates the 806 * per-ag structures for us. 807 */ 808 error = xfs_alloc_pagf_init(mp, NULL, index, 0); 809 if (error) 810 return error; 811 812 error = xfs_ialloc_pagi_init(mp, NULL, index); 813 if (error) 814 return error; 815 pag = xfs_perag_get(mp, index); 816 ifree += pag->pagi_freecount; 817 ialloc += pag->pagi_count; 818 bfree += pag->pagf_freeblks; 819 bfreelst += pag->pagf_flcount; 820 btree += pag->pagf_btreeblks; 821 xfs_perag_put(pag); 822 } 823 /* 824 * Overwrite incore superblock counters with just-read data 825 */ 826 spin_lock(&mp->m_sb_lock); 827 sbp->sb_ifree = ifree; 828 sbp->sb_icount = ialloc; 829 sbp->sb_fdblocks = bfree + bfreelst + btree; 830 spin_unlock(&mp->m_sb_lock); 831 832 /* Fixup the per-cpu counters as well. */ 833 xfs_icsb_reinit_counters(mp); 834 835 return 0; 836 } 837 838 /* 839 * Update alignment values based on mount options and sb values 840 */ 841 STATIC int 842 xfs_update_alignment(xfs_mount_t *mp) 843 { 844 xfs_sb_t *sbp = &(mp->m_sb); 845 846 if (mp->m_dalign) { 847 /* 848 * If stripe unit and stripe width are not multiples 849 * of the fs blocksize turn off alignment. 850 */ 851 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) || 852 (BBTOB(mp->m_swidth) & mp->m_blockmask)) { 853 if (mp->m_flags & XFS_MOUNT_RETERR) { 854 xfs_warn(mp, "alignment check failed: " 855 "(sunit/swidth vs. blocksize)"); 856 return XFS_ERROR(EINVAL); 857 } 858 mp->m_dalign = mp->m_swidth = 0; 859 } else { 860 /* 861 * Convert the stripe unit and width to FSBs. 862 */ 863 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign); 864 if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) { 865 if (mp->m_flags & XFS_MOUNT_RETERR) { 866 xfs_warn(mp, "alignment check failed: " 867 "(sunit/swidth vs. ag size)"); 868 return XFS_ERROR(EINVAL); 869 } 870 xfs_warn(mp, 871 "stripe alignment turned off: sunit(%d)/swidth(%d) " 872 "incompatible with agsize(%d)", 873 mp->m_dalign, mp->m_swidth, 874 sbp->sb_agblocks); 875 876 mp->m_dalign = 0; 877 mp->m_swidth = 0; 878 } else if (mp->m_dalign) { 879 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth); 880 } else { 881 if (mp->m_flags & XFS_MOUNT_RETERR) { 882 xfs_warn(mp, "alignment check failed: " 883 "sunit(%d) less than bsize(%d)", 884 mp->m_dalign, 885 mp->m_blockmask +1); 886 return XFS_ERROR(EINVAL); 887 } 888 mp->m_swidth = 0; 889 } 890 } 891 892 /* 893 * Update superblock with new values 894 * and log changes 895 */ 896 if (xfs_sb_version_hasdalign(sbp)) { 897 if (sbp->sb_unit != mp->m_dalign) { 898 sbp->sb_unit = mp->m_dalign; 899 mp->m_update_flags |= XFS_SB_UNIT; 900 } 901 if (sbp->sb_width != mp->m_swidth) { 902 sbp->sb_width = mp->m_swidth; 903 mp->m_update_flags |= XFS_SB_WIDTH; 904 } 905 } 906 } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN && 907 xfs_sb_version_hasdalign(&mp->m_sb)) { 908 mp->m_dalign = sbp->sb_unit; 909 mp->m_swidth = sbp->sb_width; 910 } 911 912 return 0; 913 } 914 915 /* 916 * Set the maximum inode count for this filesystem 917 */ 918 STATIC void 919 xfs_set_maxicount(xfs_mount_t *mp) 920 { 921 xfs_sb_t *sbp = &(mp->m_sb); 922 __uint64_t icount; 923 924 if (sbp->sb_imax_pct) { 925 /* 926 * Make sure the maximum inode count is a multiple 927 * of the units we allocate inodes in. 928 */ 929 icount = sbp->sb_dblocks * sbp->sb_imax_pct; 930 do_div(icount, 100); 931 do_div(icount, mp->m_ialloc_blks); 932 mp->m_maxicount = (icount * mp->m_ialloc_blks) << 933 sbp->sb_inopblog; 934 } else { 935 mp->m_maxicount = 0; 936 } 937 } 938 939 /* 940 * Set the default minimum read and write sizes unless 941 * already specified in a mount option. 942 * We use smaller I/O sizes when the file system 943 * is being used for NFS service (wsync mount option). 944 */ 945 STATIC void 946 xfs_set_rw_sizes(xfs_mount_t *mp) 947 { 948 xfs_sb_t *sbp = &(mp->m_sb); 949 int readio_log, writeio_log; 950 951 if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) { 952 if (mp->m_flags & XFS_MOUNT_WSYNC) { 953 readio_log = XFS_WSYNC_READIO_LOG; 954 writeio_log = XFS_WSYNC_WRITEIO_LOG; 955 } else { 956 readio_log = XFS_READIO_LOG_LARGE; 957 writeio_log = XFS_WRITEIO_LOG_LARGE; 958 } 959 } else { 960 readio_log = mp->m_readio_log; 961 writeio_log = mp->m_writeio_log; 962 } 963 964 if (sbp->sb_blocklog > readio_log) { 965 mp->m_readio_log = sbp->sb_blocklog; 966 } else { 967 mp->m_readio_log = readio_log; 968 } 969 mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog); 970 if (sbp->sb_blocklog > writeio_log) { 971 mp->m_writeio_log = sbp->sb_blocklog; 972 } else { 973 mp->m_writeio_log = writeio_log; 974 } 975 mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog); 976 } 977 978 /* 979 * precalculate the low space thresholds for dynamic speculative preallocation. 980 */ 981 void 982 xfs_set_low_space_thresholds( 983 struct xfs_mount *mp) 984 { 985 int i; 986 987 for (i = 0; i < XFS_LOWSP_MAX; i++) { 988 __uint64_t space = mp->m_sb.sb_dblocks; 989 990 do_div(space, 100); 991 mp->m_low_space[i] = space * (i + 1); 992 } 993 } 994 995 996 /* 997 * Set whether we're using inode alignment. 998 */ 999 STATIC void 1000 xfs_set_inoalignment(xfs_mount_t *mp) 1001 { 1002 if (xfs_sb_version_hasalign(&mp->m_sb) && 1003 mp->m_sb.sb_inoalignmt >= 1004 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) 1005 mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1; 1006 else 1007 mp->m_inoalign_mask = 0; 1008 /* 1009 * If we are using stripe alignment, check whether 1010 * the stripe unit is a multiple of the inode alignment 1011 */ 1012 if (mp->m_dalign && mp->m_inoalign_mask && 1013 !(mp->m_dalign & mp->m_inoalign_mask)) 1014 mp->m_sinoalign = mp->m_dalign; 1015 else 1016 mp->m_sinoalign = 0; 1017 } 1018 1019 /* 1020 * Check that the data (and log if separate) are an ok size. 1021 */ 1022 STATIC int 1023 xfs_check_sizes(xfs_mount_t *mp) 1024 { 1025 xfs_buf_t *bp; 1026 xfs_daddr_t d; 1027 1028 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks); 1029 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) { 1030 xfs_warn(mp, "filesystem size mismatch detected"); 1031 return XFS_ERROR(EFBIG); 1032 } 1033 bp = xfs_buf_read_uncached(mp, mp->m_ddev_targp, 1034 d - XFS_FSS_TO_BB(mp, 1), 1035 BBTOB(XFS_FSS_TO_BB(mp, 1)), 0); 1036 if (!bp) { 1037 xfs_warn(mp, "last sector read failed"); 1038 return EIO; 1039 } 1040 xfs_buf_relse(bp); 1041 1042 if (mp->m_logdev_targp != mp->m_ddev_targp) { 1043 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks); 1044 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) { 1045 xfs_warn(mp, "log size mismatch detected"); 1046 return XFS_ERROR(EFBIG); 1047 } 1048 bp = xfs_buf_read_uncached(mp, mp->m_logdev_targp, 1049 d - XFS_FSB_TO_BB(mp, 1), 1050 XFS_FSB_TO_B(mp, 1), 0); 1051 if (!bp) { 1052 xfs_warn(mp, "log device read failed"); 1053 return EIO; 1054 } 1055 xfs_buf_relse(bp); 1056 } 1057 return 0; 1058 } 1059 1060 /* 1061 * Clear the quotaflags in memory and in the superblock. 1062 */ 1063 int 1064 xfs_mount_reset_sbqflags( 1065 struct xfs_mount *mp) 1066 { 1067 int error; 1068 struct xfs_trans *tp; 1069 1070 mp->m_qflags = 0; 1071 1072 /* 1073 * It is OK to look at sb_qflags here in mount path, 1074 * without m_sb_lock. 1075 */ 1076 if (mp->m_sb.sb_qflags == 0) 1077 return 0; 1078 spin_lock(&mp->m_sb_lock); 1079 mp->m_sb.sb_qflags = 0; 1080 spin_unlock(&mp->m_sb_lock); 1081 1082 /* 1083 * If the fs is readonly, let the incore superblock run 1084 * with quotas off but don't flush the update out to disk 1085 */ 1086 if (mp->m_flags & XFS_MOUNT_RDONLY) 1087 return 0; 1088 1089 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE); 1090 error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0, 1091 XFS_DEFAULT_LOG_COUNT); 1092 if (error) { 1093 xfs_trans_cancel(tp, 0); 1094 xfs_alert(mp, "%s: Superblock update failed!", __func__); 1095 return error; 1096 } 1097 1098 xfs_mod_sb(tp, XFS_SB_QFLAGS); 1099 return xfs_trans_commit(tp, 0); 1100 } 1101 1102 __uint64_t 1103 xfs_default_resblks(xfs_mount_t *mp) 1104 { 1105 __uint64_t resblks; 1106 1107 /* 1108 * We default to 5% or 8192 fsbs of space reserved, whichever is 1109 * smaller. This is intended to cover concurrent allocation 1110 * transactions when we initially hit enospc. These each require a 4 1111 * block reservation. Hence by default we cover roughly 2000 concurrent 1112 * allocation reservations. 1113 */ 1114 resblks = mp->m_sb.sb_dblocks; 1115 do_div(resblks, 20); 1116 resblks = min_t(__uint64_t, resblks, 8192); 1117 return resblks; 1118 } 1119 1120 /* 1121 * This function does the following on an initial mount of a file system: 1122 * - reads the superblock from disk and init the mount struct 1123 * - if we're a 32-bit kernel, do a size check on the superblock 1124 * so we don't mount terabyte filesystems 1125 * - init mount struct realtime fields 1126 * - allocate inode hash table for fs 1127 * - init directory manager 1128 * - perform recovery and init the log manager 1129 */ 1130 int 1131 xfs_mountfs( 1132 xfs_mount_t *mp) 1133 { 1134 xfs_sb_t *sbp = &(mp->m_sb); 1135 xfs_inode_t *rip; 1136 __uint64_t resblks; 1137 uint quotamount = 0; 1138 uint quotaflags = 0; 1139 int error = 0; 1140 1141 xfs_mount_common(mp, sbp); 1142 1143 /* 1144 * Check for a mismatched features2 values. Older kernels 1145 * read & wrote into the wrong sb offset for sb_features2 1146 * on some platforms due to xfs_sb_t not being 64bit size aligned 1147 * when sb_features2 was added, which made older superblock 1148 * reading/writing routines swap it as a 64-bit value. 1149 * 1150 * For backwards compatibility, we make both slots equal. 1151 * 1152 * If we detect a mismatched field, we OR the set bits into the 1153 * existing features2 field in case it has already been modified; we 1154 * don't want to lose any features. We then update the bad location 1155 * with the ORed value so that older kernels will see any features2 1156 * flags, and mark the two fields as needing updates once the 1157 * transaction subsystem is online. 1158 */ 1159 if (xfs_sb_has_mismatched_features2(sbp)) { 1160 xfs_warn(mp, "correcting sb_features alignment problem"); 1161 sbp->sb_features2 |= sbp->sb_bad_features2; 1162 sbp->sb_bad_features2 = sbp->sb_features2; 1163 mp->m_update_flags |= XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2; 1164 1165 /* 1166 * Re-check for ATTR2 in case it was found in bad_features2 1167 * slot. 1168 */ 1169 if (xfs_sb_version_hasattr2(&mp->m_sb) && 1170 !(mp->m_flags & XFS_MOUNT_NOATTR2)) 1171 mp->m_flags |= XFS_MOUNT_ATTR2; 1172 } 1173 1174 if (xfs_sb_version_hasattr2(&mp->m_sb) && 1175 (mp->m_flags & XFS_MOUNT_NOATTR2)) { 1176 xfs_sb_version_removeattr2(&mp->m_sb); 1177 mp->m_update_flags |= XFS_SB_FEATURES2; 1178 1179 /* update sb_versionnum for the clearing of the morebits */ 1180 if (!sbp->sb_features2) 1181 mp->m_update_flags |= XFS_SB_VERSIONNUM; 1182 } 1183 1184 /* 1185 * Check if sb_agblocks is aligned at stripe boundary 1186 * If sb_agblocks is NOT aligned turn off m_dalign since 1187 * allocator alignment is within an ag, therefore ag has 1188 * to be aligned at stripe boundary. 1189 */ 1190 error = xfs_update_alignment(mp); 1191 if (error) 1192 goto out; 1193 1194 xfs_alloc_compute_maxlevels(mp); 1195 xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK); 1196 xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK); 1197 xfs_ialloc_compute_maxlevels(mp); 1198 1199 xfs_set_maxicount(mp); 1200 1201 mp->m_maxioffset = xfs_max_file_offset(sbp->sb_blocklog); 1202 1203 error = xfs_uuid_mount(mp); 1204 if (error) 1205 goto out; 1206 1207 /* 1208 * Set the minimum read and write sizes 1209 */ 1210 xfs_set_rw_sizes(mp); 1211 1212 /* set the low space thresholds for dynamic preallocation */ 1213 xfs_set_low_space_thresholds(mp); 1214 1215 /* 1216 * Set the inode cluster size. 1217 * This may still be overridden by the file system 1218 * block size if it is larger than the chosen cluster size. 1219 */ 1220 mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE; 1221 1222 /* 1223 * Set inode alignment fields 1224 */ 1225 xfs_set_inoalignment(mp); 1226 1227 /* 1228 * Check that the data (and log if separate) are an ok size. 1229 */ 1230 error = xfs_check_sizes(mp); 1231 if (error) 1232 goto out_remove_uuid; 1233 1234 /* 1235 * Initialize realtime fields in the mount structure 1236 */ 1237 error = xfs_rtmount_init(mp); 1238 if (error) { 1239 xfs_warn(mp, "RT mount failed"); 1240 goto out_remove_uuid; 1241 } 1242 1243 /* 1244 * Copies the low order bits of the timestamp and the randomly 1245 * set "sequence" number out of a UUID. 1246 */ 1247 uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid); 1248 1249 mp->m_dmevmask = 0; /* not persistent; set after each mount */ 1250 1251 xfs_dir_mount(mp); 1252 1253 /* 1254 * Initialize the attribute manager's entries. 1255 */ 1256 mp->m_attr_magicpct = (mp->m_sb.sb_blocksize * 37) / 100; 1257 1258 /* 1259 * Initialize the precomputed transaction reservations values. 1260 */ 1261 xfs_trans_init(mp); 1262 1263 /* 1264 * Allocate and initialize the per-ag data. 1265 */ 1266 spin_lock_init(&mp->m_perag_lock); 1267 INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC); 1268 error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi); 1269 if (error) { 1270 xfs_warn(mp, "Failed per-ag init: %d", error); 1271 goto out_remove_uuid; 1272 } 1273 1274 if (!sbp->sb_logblocks) { 1275 xfs_warn(mp, "no log defined"); 1276 XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp); 1277 error = XFS_ERROR(EFSCORRUPTED); 1278 goto out_free_perag; 1279 } 1280 1281 /* 1282 * log's mount-time initialization. Perform 1st part recovery if needed 1283 */ 1284 error = xfs_log_mount(mp, mp->m_logdev_targp, 1285 XFS_FSB_TO_DADDR(mp, sbp->sb_logstart), 1286 XFS_FSB_TO_BB(mp, sbp->sb_logblocks)); 1287 if (error) { 1288 xfs_warn(mp, "log mount failed"); 1289 goto out_free_perag; 1290 } 1291 1292 /* 1293 * Now the log is mounted, we know if it was an unclean shutdown or 1294 * not. If it was, with the first phase of recovery has completed, we 1295 * have consistent AG blocks on disk. We have not recovered EFIs yet, 1296 * but they are recovered transactionally in the second recovery phase 1297 * later. 1298 * 1299 * Hence we can safely re-initialise incore superblock counters from 1300 * the per-ag data. These may not be correct if the filesystem was not 1301 * cleanly unmounted, so we need to wait for recovery to finish before 1302 * doing this. 1303 * 1304 * If the filesystem was cleanly unmounted, then we can trust the 1305 * values in the superblock to be correct and we don't need to do 1306 * anything here. 1307 * 1308 * If we are currently making the filesystem, the initialisation will 1309 * fail as the perag data is in an undefined state. 1310 */ 1311 if (xfs_sb_version_haslazysbcount(&mp->m_sb) && 1312 !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) && 1313 !mp->m_sb.sb_inprogress) { 1314 error = xfs_initialize_perag_data(mp, sbp->sb_agcount); 1315 if (error) 1316 goto out_free_perag; 1317 } 1318 1319 /* 1320 * Get and sanity-check the root inode. 1321 * Save the pointer to it in the mount structure. 1322 */ 1323 error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip); 1324 if (error) { 1325 xfs_warn(mp, "failed to read root inode"); 1326 goto out_log_dealloc; 1327 } 1328 1329 ASSERT(rip != NULL); 1330 1331 if (unlikely(!S_ISDIR(rip->i_d.di_mode))) { 1332 xfs_warn(mp, "corrupted root inode %llu: not a directory", 1333 (unsigned long long)rip->i_ino); 1334 xfs_iunlock(rip, XFS_ILOCK_EXCL); 1335 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW, 1336 mp); 1337 error = XFS_ERROR(EFSCORRUPTED); 1338 goto out_rele_rip; 1339 } 1340 mp->m_rootip = rip; /* save it */ 1341 1342 xfs_iunlock(rip, XFS_ILOCK_EXCL); 1343 1344 /* 1345 * Initialize realtime inode pointers in the mount structure 1346 */ 1347 error = xfs_rtmount_inodes(mp); 1348 if (error) { 1349 /* 1350 * Free up the root inode. 1351 */ 1352 xfs_warn(mp, "failed to read RT inodes"); 1353 goto out_rele_rip; 1354 } 1355 1356 /* 1357 * If this is a read-only mount defer the superblock updates until 1358 * the next remount into writeable mode. Otherwise we would never 1359 * perform the update e.g. for the root filesystem. 1360 */ 1361 if (mp->m_update_flags && !(mp->m_flags & XFS_MOUNT_RDONLY)) { 1362 error = xfs_mount_log_sb(mp, mp->m_update_flags); 1363 if (error) { 1364 xfs_warn(mp, "failed to write sb changes"); 1365 goto out_rtunmount; 1366 } 1367 } 1368 1369 /* 1370 * Initialise the XFS quota management subsystem for this mount 1371 */ 1372 if (XFS_IS_QUOTA_RUNNING(mp)) { 1373 error = xfs_qm_newmount(mp, "amount, "aflags); 1374 if (error) 1375 goto out_rtunmount; 1376 } else { 1377 ASSERT(!XFS_IS_QUOTA_ON(mp)); 1378 1379 /* 1380 * If a file system had quotas running earlier, but decided to 1381 * mount without -o uquota/pquota/gquota options, revoke the 1382 * quotachecked license. 1383 */ 1384 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) { 1385 xfs_notice(mp, "resetting quota flags"); 1386 error = xfs_mount_reset_sbqflags(mp); 1387 if (error) 1388 return error; 1389 } 1390 } 1391 1392 /* 1393 * Finish recovering the file system. This part needed to be 1394 * delayed until after the root and real-time bitmap inodes 1395 * were consistently read in. 1396 */ 1397 error = xfs_log_mount_finish(mp); 1398 if (error) { 1399 xfs_warn(mp, "log mount finish failed"); 1400 goto out_rtunmount; 1401 } 1402 1403 /* 1404 * Complete the quota initialisation, post-log-replay component. 1405 */ 1406 if (quotamount) { 1407 ASSERT(mp->m_qflags == 0); 1408 mp->m_qflags = quotaflags; 1409 1410 xfs_qm_mount_quotas(mp); 1411 } 1412 1413 /* 1414 * Now we are mounted, reserve a small amount of unused space for 1415 * privileged transactions. This is needed so that transaction 1416 * space required for critical operations can dip into this pool 1417 * when at ENOSPC. This is needed for operations like create with 1418 * attr, unwritten extent conversion at ENOSPC, etc. Data allocations 1419 * are not allowed to use this reserved space. 1420 * 1421 * This may drive us straight to ENOSPC on mount, but that implies 1422 * we were already there on the last unmount. Warn if this occurs. 1423 */ 1424 if (!(mp->m_flags & XFS_MOUNT_RDONLY)) { 1425 resblks = xfs_default_resblks(mp); 1426 error = xfs_reserve_blocks(mp, &resblks, NULL); 1427 if (error) 1428 xfs_warn(mp, 1429 "Unable to allocate reserve blocks. Continuing without reserve pool."); 1430 } 1431 1432 return 0; 1433 1434 out_rtunmount: 1435 xfs_rtunmount_inodes(mp); 1436 out_rele_rip: 1437 IRELE(rip); 1438 out_log_dealloc: 1439 xfs_log_unmount(mp); 1440 out_free_perag: 1441 xfs_free_perag(mp); 1442 out_remove_uuid: 1443 xfs_uuid_unmount(mp); 1444 out: 1445 return error; 1446 } 1447 1448 /* 1449 * This flushes out the inodes,dquots and the superblock, unmounts the 1450 * log and makes sure that incore structures are freed. 1451 */ 1452 void 1453 xfs_unmountfs( 1454 struct xfs_mount *mp) 1455 { 1456 __uint64_t resblks; 1457 int error; 1458 1459 xfs_qm_unmount_quotas(mp); 1460 xfs_rtunmount_inodes(mp); 1461 IRELE(mp->m_rootip); 1462 1463 /* 1464 * We can potentially deadlock here if we have an inode cluster 1465 * that has been freed has its buffer still pinned in memory because 1466 * the transaction is still sitting in a iclog. The stale inodes 1467 * on that buffer will have their flush locks held until the 1468 * transaction hits the disk and the callbacks run. the inode 1469 * flush takes the flush lock unconditionally and with nothing to 1470 * push out the iclog we will never get that unlocked. hence we 1471 * need to force the log first. 1472 */ 1473 xfs_log_force(mp, XFS_LOG_SYNC); 1474 1475 /* 1476 * Do a delwri reclaim pass first so that as many dirty inodes are 1477 * queued up for IO as possible. Then flush the buffers before making 1478 * a synchronous path to catch all the remaining inodes are reclaimed. 1479 * This makes the reclaim process as quick as possible by avoiding 1480 * synchronous writeout and blocking on inodes already in the delwri 1481 * state as much as possible. 1482 */ 1483 xfs_reclaim_inodes(mp, 0); 1484 xfs_flush_buftarg(mp->m_ddev_targp, 1); 1485 xfs_reclaim_inodes(mp, SYNC_WAIT); 1486 1487 xfs_qm_unmount(mp); 1488 1489 /* 1490 * Flush out the log synchronously so that we know for sure 1491 * that nothing is pinned. This is important because bflush() 1492 * will skip pinned buffers. 1493 */ 1494 xfs_log_force(mp, XFS_LOG_SYNC); 1495 1496 /* 1497 * Unreserve any blocks we have so that when we unmount we don't account 1498 * the reserved free space as used. This is really only necessary for 1499 * lazy superblock counting because it trusts the incore superblock 1500 * counters to be absolutely correct on clean unmount. 1501 * 1502 * We don't bother correcting this elsewhere for lazy superblock 1503 * counting because on mount of an unclean filesystem we reconstruct the 1504 * correct counter value and this is irrelevant. 1505 * 1506 * For non-lazy counter filesystems, this doesn't matter at all because 1507 * we only every apply deltas to the superblock and hence the incore 1508 * value does not matter.... 1509 */ 1510 resblks = 0; 1511 error = xfs_reserve_blocks(mp, &resblks, NULL); 1512 if (error) 1513 xfs_warn(mp, "Unable to free reserved block pool. " 1514 "Freespace may not be correct on next mount."); 1515 1516 error = xfs_log_sbcount(mp); 1517 if (error) 1518 xfs_warn(mp, "Unable to update superblock counters. " 1519 "Freespace may not be correct on next mount."); 1520 xfs_unmountfs_writesb(mp); 1521 1522 /* 1523 * Make sure all buffers have been flushed and completed before 1524 * unmounting the log. 1525 */ 1526 error = xfs_flush_buftarg(mp->m_ddev_targp, 1); 1527 if (error) 1528 xfs_warn(mp, "%d busy buffers during unmount.", error); 1529 xfs_wait_buftarg(mp->m_ddev_targp); 1530 1531 xfs_log_unmount_write(mp); 1532 xfs_log_unmount(mp); 1533 xfs_uuid_unmount(mp); 1534 1535 #if defined(DEBUG) 1536 xfs_errortag_clearall(mp, 0); 1537 #endif 1538 xfs_free_perag(mp); 1539 } 1540 1541 int 1542 xfs_fs_writable(xfs_mount_t *mp) 1543 { 1544 return !(xfs_test_for_freeze(mp) || XFS_FORCED_SHUTDOWN(mp) || 1545 (mp->m_flags & XFS_MOUNT_RDONLY)); 1546 } 1547 1548 /* 1549 * xfs_log_sbcount 1550 * 1551 * Sync the superblock counters to disk. 1552 * 1553 * Note this code can be called during the process of freezing, so 1554 * we may need to use the transaction allocator which does not 1555 * block when the transaction subsystem is in its frozen state. 1556 */ 1557 int 1558 xfs_log_sbcount(xfs_mount_t *mp) 1559 { 1560 xfs_trans_t *tp; 1561 int error; 1562 1563 if (!xfs_fs_writable(mp)) 1564 return 0; 1565 1566 xfs_icsb_sync_counters(mp, 0); 1567 1568 /* 1569 * we don't need to do this if we are updating the superblock 1570 * counters on every modification. 1571 */ 1572 if (!xfs_sb_version_haslazysbcount(&mp->m_sb)) 1573 return 0; 1574 1575 tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT, KM_SLEEP); 1576 error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0, 1577 XFS_DEFAULT_LOG_COUNT); 1578 if (error) { 1579 xfs_trans_cancel(tp, 0); 1580 return error; 1581 } 1582 1583 xfs_mod_sb(tp, XFS_SB_IFREE | XFS_SB_ICOUNT | XFS_SB_FDBLOCKS); 1584 xfs_trans_set_sync(tp); 1585 error = xfs_trans_commit(tp, 0); 1586 return error; 1587 } 1588 1589 int 1590 xfs_unmountfs_writesb(xfs_mount_t *mp) 1591 { 1592 xfs_buf_t *sbp; 1593 int error = 0; 1594 1595 /* 1596 * skip superblock write if fs is read-only, or 1597 * if we are doing a forced umount. 1598 */ 1599 if (!((mp->m_flags & XFS_MOUNT_RDONLY) || 1600 XFS_FORCED_SHUTDOWN(mp))) { 1601 1602 sbp = xfs_getsb(mp, 0); 1603 1604 XFS_BUF_UNDONE(sbp); 1605 XFS_BUF_UNREAD(sbp); 1606 xfs_buf_delwri_dequeue(sbp); 1607 XFS_BUF_WRITE(sbp); 1608 XFS_BUF_UNASYNC(sbp); 1609 ASSERT(sbp->b_target == mp->m_ddev_targp); 1610 xfsbdstrat(mp, sbp); 1611 error = xfs_buf_iowait(sbp); 1612 if (error) 1613 xfs_buf_ioerror_alert(sbp, __func__); 1614 xfs_buf_relse(sbp); 1615 } 1616 return error; 1617 } 1618 1619 /* 1620 * xfs_mod_sb() can be used to copy arbitrary changes to the 1621 * in-core superblock into the superblock buffer to be logged. 1622 * It does not provide the higher level of locking that is 1623 * needed to protect the in-core superblock from concurrent 1624 * access. 1625 */ 1626 void 1627 xfs_mod_sb(xfs_trans_t *tp, __int64_t fields) 1628 { 1629 xfs_buf_t *bp; 1630 int first; 1631 int last; 1632 xfs_mount_t *mp; 1633 xfs_sb_field_t f; 1634 1635 ASSERT(fields); 1636 if (!fields) 1637 return; 1638 mp = tp->t_mountp; 1639 bp = xfs_trans_getsb(tp, mp, 0); 1640 first = sizeof(xfs_sb_t); 1641 last = 0; 1642 1643 /* translate/copy */ 1644 1645 xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, fields); 1646 1647 /* find modified range */ 1648 f = (xfs_sb_field_t)xfs_highbit64((__uint64_t)fields); 1649 ASSERT((1LL << f) & XFS_SB_MOD_BITS); 1650 last = xfs_sb_info[f + 1].offset - 1; 1651 1652 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields); 1653 ASSERT((1LL << f) & XFS_SB_MOD_BITS); 1654 first = xfs_sb_info[f].offset; 1655 1656 xfs_trans_log_buf(tp, bp, first, last); 1657 } 1658 1659 1660 /* 1661 * xfs_mod_incore_sb_unlocked() is a utility routine common used to apply 1662 * a delta to a specified field in the in-core superblock. Simply 1663 * switch on the field indicated and apply the delta to that field. 1664 * Fields are not allowed to dip below zero, so if the delta would 1665 * do this do not apply it and return EINVAL. 1666 * 1667 * The m_sb_lock must be held when this routine is called. 1668 */ 1669 STATIC int 1670 xfs_mod_incore_sb_unlocked( 1671 xfs_mount_t *mp, 1672 xfs_sb_field_t field, 1673 int64_t delta, 1674 int rsvd) 1675 { 1676 int scounter; /* short counter for 32 bit fields */ 1677 long long lcounter; /* long counter for 64 bit fields */ 1678 long long res_used, rem; 1679 1680 /* 1681 * With the in-core superblock spin lock held, switch 1682 * on the indicated field. Apply the delta to the 1683 * proper field. If the fields value would dip below 1684 * 0, then do not apply the delta and return EINVAL. 1685 */ 1686 switch (field) { 1687 case XFS_SBS_ICOUNT: 1688 lcounter = (long long)mp->m_sb.sb_icount; 1689 lcounter += delta; 1690 if (lcounter < 0) { 1691 ASSERT(0); 1692 return XFS_ERROR(EINVAL); 1693 } 1694 mp->m_sb.sb_icount = lcounter; 1695 return 0; 1696 case XFS_SBS_IFREE: 1697 lcounter = (long long)mp->m_sb.sb_ifree; 1698 lcounter += delta; 1699 if (lcounter < 0) { 1700 ASSERT(0); 1701 return XFS_ERROR(EINVAL); 1702 } 1703 mp->m_sb.sb_ifree = lcounter; 1704 return 0; 1705 case XFS_SBS_FDBLOCKS: 1706 lcounter = (long long) 1707 mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp); 1708 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail); 1709 1710 if (delta > 0) { /* Putting blocks back */ 1711 if (res_used > delta) { 1712 mp->m_resblks_avail += delta; 1713 } else { 1714 rem = delta - res_used; 1715 mp->m_resblks_avail = mp->m_resblks; 1716 lcounter += rem; 1717 } 1718 } else { /* Taking blocks away */ 1719 lcounter += delta; 1720 if (lcounter >= 0) { 1721 mp->m_sb.sb_fdblocks = lcounter + 1722 XFS_ALLOC_SET_ASIDE(mp); 1723 return 0; 1724 } 1725 1726 /* 1727 * We are out of blocks, use any available reserved 1728 * blocks if were allowed to. 1729 */ 1730 if (!rsvd) 1731 return XFS_ERROR(ENOSPC); 1732 1733 lcounter = (long long)mp->m_resblks_avail + delta; 1734 if (lcounter >= 0) { 1735 mp->m_resblks_avail = lcounter; 1736 return 0; 1737 } 1738 printk_once(KERN_WARNING 1739 "Filesystem \"%s\": reserve blocks depleted! " 1740 "Consider increasing reserve pool size.", 1741 mp->m_fsname); 1742 return XFS_ERROR(ENOSPC); 1743 } 1744 1745 mp->m_sb.sb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp); 1746 return 0; 1747 case XFS_SBS_FREXTENTS: 1748 lcounter = (long long)mp->m_sb.sb_frextents; 1749 lcounter += delta; 1750 if (lcounter < 0) { 1751 return XFS_ERROR(ENOSPC); 1752 } 1753 mp->m_sb.sb_frextents = lcounter; 1754 return 0; 1755 case XFS_SBS_DBLOCKS: 1756 lcounter = (long long)mp->m_sb.sb_dblocks; 1757 lcounter += delta; 1758 if (lcounter < 0) { 1759 ASSERT(0); 1760 return XFS_ERROR(EINVAL); 1761 } 1762 mp->m_sb.sb_dblocks = lcounter; 1763 return 0; 1764 case XFS_SBS_AGCOUNT: 1765 scounter = mp->m_sb.sb_agcount; 1766 scounter += delta; 1767 if (scounter < 0) { 1768 ASSERT(0); 1769 return XFS_ERROR(EINVAL); 1770 } 1771 mp->m_sb.sb_agcount = scounter; 1772 return 0; 1773 case XFS_SBS_IMAX_PCT: 1774 scounter = mp->m_sb.sb_imax_pct; 1775 scounter += delta; 1776 if (scounter < 0) { 1777 ASSERT(0); 1778 return XFS_ERROR(EINVAL); 1779 } 1780 mp->m_sb.sb_imax_pct = scounter; 1781 return 0; 1782 case XFS_SBS_REXTSIZE: 1783 scounter = mp->m_sb.sb_rextsize; 1784 scounter += delta; 1785 if (scounter < 0) { 1786 ASSERT(0); 1787 return XFS_ERROR(EINVAL); 1788 } 1789 mp->m_sb.sb_rextsize = scounter; 1790 return 0; 1791 case XFS_SBS_RBMBLOCKS: 1792 scounter = mp->m_sb.sb_rbmblocks; 1793 scounter += delta; 1794 if (scounter < 0) { 1795 ASSERT(0); 1796 return XFS_ERROR(EINVAL); 1797 } 1798 mp->m_sb.sb_rbmblocks = scounter; 1799 return 0; 1800 case XFS_SBS_RBLOCKS: 1801 lcounter = (long long)mp->m_sb.sb_rblocks; 1802 lcounter += delta; 1803 if (lcounter < 0) { 1804 ASSERT(0); 1805 return XFS_ERROR(EINVAL); 1806 } 1807 mp->m_sb.sb_rblocks = lcounter; 1808 return 0; 1809 case XFS_SBS_REXTENTS: 1810 lcounter = (long long)mp->m_sb.sb_rextents; 1811 lcounter += delta; 1812 if (lcounter < 0) { 1813 ASSERT(0); 1814 return XFS_ERROR(EINVAL); 1815 } 1816 mp->m_sb.sb_rextents = lcounter; 1817 return 0; 1818 case XFS_SBS_REXTSLOG: 1819 scounter = mp->m_sb.sb_rextslog; 1820 scounter += delta; 1821 if (scounter < 0) { 1822 ASSERT(0); 1823 return XFS_ERROR(EINVAL); 1824 } 1825 mp->m_sb.sb_rextslog = scounter; 1826 return 0; 1827 default: 1828 ASSERT(0); 1829 return XFS_ERROR(EINVAL); 1830 } 1831 } 1832 1833 /* 1834 * xfs_mod_incore_sb() is used to change a field in the in-core 1835 * superblock structure by the specified delta. This modification 1836 * is protected by the m_sb_lock. Just use the xfs_mod_incore_sb_unlocked() 1837 * routine to do the work. 1838 */ 1839 int 1840 xfs_mod_incore_sb( 1841 struct xfs_mount *mp, 1842 xfs_sb_field_t field, 1843 int64_t delta, 1844 int rsvd) 1845 { 1846 int status; 1847 1848 #ifdef HAVE_PERCPU_SB 1849 ASSERT(field < XFS_SBS_ICOUNT || field > XFS_SBS_FDBLOCKS); 1850 #endif 1851 spin_lock(&mp->m_sb_lock); 1852 status = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd); 1853 spin_unlock(&mp->m_sb_lock); 1854 1855 return status; 1856 } 1857 1858 /* 1859 * Change more than one field in the in-core superblock structure at a time. 1860 * 1861 * The fields and changes to those fields are specified in the array of 1862 * xfs_mod_sb structures passed in. Either all of the specified deltas 1863 * will be applied or none of them will. If any modified field dips below 0, 1864 * then all modifications will be backed out and EINVAL will be returned. 1865 * 1866 * Note that this function may not be used for the superblock values that 1867 * are tracked with the in-memory per-cpu counters - a direct call to 1868 * xfs_icsb_modify_counters is required for these. 1869 */ 1870 int 1871 xfs_mod_incore_sb_batch( 1872 struct xfs_mount *mp, 1873 xfs_mod_sb_t *msb, 1874 uint nmsb, 1875 int rsvd) 1876 { 1877 xfs_mod_sb_t *msbp; 1878 int error = 0; 1879 1880 /* 1881 * Loop through the array of mod structures and apply each individually. 1882 * If any fail, then back out all those which have already been applied. 1883 * Do all of this within the scope of the m_sb_lock so that all of the 1884 * changes will be atomic. 1885 */ 1886 spin_lock(&mp->m_sb_lock); 1887 for (msbp = msb; msbp < (msb + nmsb); msbp++) { 1888 ASSERT(msbp->msb_field < XFS_SBS_ICOUNT || 1889 msbp->msb_field > XFS_SBS_FDBLOCKS); 1890 1891 error = xfs_mod_incore_sb_unlocked(mp, msbp->msb_field, 1892 msbp->msb_delta, rsvd); 1893 if (error) 1894 goto unwind; 1895 } 1896 spin_unlock(&mp->m_sb_lock); 1897 return 0; 1898 1899 unwind: 1900 while (--msbp >= msb) { 1901 error = xfs_mod_incore_sb_unlocked(mp, msbp->msb_field, 1902 -msbp->msb_delta, rsvd); 1903 ASSERT(error == 0); 1904 } 1905 spin_unlock(&mp->m_sb_lock); 1906 return error; 1907 } 1908 1909 /* 1910 * xfs_getsb() is called to obtain the buffer for the superblock. 1911 * The buffer is returned locked and read in from disk. 1912 * The buffer should be released with a call to xfs_brelse(). 1913 * 1914 * If the flags parameter is BUF_TRYLOCK, then we'll only return 1915 * the superblock buffer if it can be locked without sleeping. 1916 * If it can't then we'll return NULL. 1917 */ 1918 struct xfs_buf * 1919 xfs_getsb( 1920 struct xfs_mount *mp, 1921 int flags) 1922 { 1923 struct xfs_buf *bp = mp->m_sb_bp; 1924 1925 if (!xfs_buf_trylock(bp)) { 1926 if (flags & XBF_TRYLOCK) 1927 return NULL; 1928 xfs_buf_lock(bp); 1929 } 1930 1931 xfs_buf_hold(bp); 1932 ASSERT(XFS_BUF_ISDONE(bp)); 1933 return bp; 1934 } 1935 1936 /* 1937 * Used to free the superblock along various error paths. 1938 */ 1939 void 1940 xfs_freesb( 1941 struct xfs_mount *mp) 1942 { 1943 struct xfs_buf *bp = mp->m_sb_bp; 1944 1945 xfs_buf_lock(bp); 1946 mp->m_sb_bp = NULL; 1947 xfs_buf_relse(bp); 1948 } 1949 1950 /* 1951 * Used to log changes to the superblock unit and width fields which could 1952 * be altered by the mount options, as well as any potential sb_features2 1953 * fixup. Only the first superblock is updated. 1954 */ 1955 int 1956 xfs_mount_log_sb( 1957 xfs_mount_t *mp, 1958 __int64_t fields) 1959 { 1960 xfs_trans_t *tp; 1961 int error; 1962 1963 ASSERT(fields & (XFS_SB_UNIT | XFS_SB_WIDTH | XFS_SB_UUID | 1964 XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2 | 1965 XFS_SB_VERSIONNUM)); 1966 1967 tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT); 1968 error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0, 1969 XFS_DEFAULT_LOG_COUNT); 1970 if (error) { 1971 xfs_trans_cancel(tp, 0); 1972 return error; 1973 } 1974 xfs_mod_sb(tp, fields); 1975 error = xfs_trans_commit(tp, 0); 1976 return error; 1977 } 1978 1979 /* 1980 * If the underlying (data/log/rt) device is readonly, there are some 1981 * operations that cannot proceed. 1982 */ 1983 int 1984 xfs_dev_is_read_only( 1985 struct xfs_mount *mp, 1986 char *message) 1987 { 1988 if (xfs_readonly_buftarg(mp->m_ddev_targp) || 1989 xfs_readonly_buftarg(mp->m_logdev_targp) || 1990 (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) { 1991 xfs_notice(mp, "%s required on read-only device.", message); 1992 xfs_notice(mp, "write access unavailable, cannot proceed."); 1993 return EROFS; 1994 } 1995 return 0; 1996 } 1997 1998 #ifdef HAVE_PERCPU_SB 1999 /* 2000 * Per-cpu incore superblock counters 2001 * 2002 * Simple concept, difficult implementation 2003 * 2004 * Basically, replace the incore superblock counters with a distributed per cpu 2005 * counter for contended fields (e.g. free block count). 2006 * 2007 * Difficulties arise in that the incore sb is used for ENOSPC checking, and 2008 * hence needs to be accurately read when we are running low on space. Hence 2009 * there is a method to enable and disable the per-cpu counters based on how 2010 * much "stuff" is available in them. 2011 * 2012 * Basically, a counter is enabled if there is enough free resource to justify 2013 * running a per-cpu fast-path. If the per-cpu counter runs out (i.e. a local 2014 * ENOSPC), then we disable the counters to synchronise all callers and 2015 * re-distribute the available resources. 2016 * 2017 * If, once we redistributed the available resources, we still get a failure, 2018 * we disable the per-cpu counter and go through the slow path. 2019 * 2020 * The slow path is the current xfs_mod_incore_sb() function. This means that 2021 * when we disable a per-cpu counter, we need to drain its resources back to 2022 * the global superblock. We do this after disabling the counter to prevent 2023 * more threads from queueing up on the counter. 2024 * 2025 * Essentially, this means that we still need a lock in the fast path to enable 2026 * synchronisation between the global counters and the per-cpu counters. This 2027 * is not a problem because the lock will be local to a CPU almost all the time 2028 * and have little contention except when we get to ENOSPC conditions. 2029 * 2030 * Basically, this lock becomes a barrier that enables us to lock out the fast 2031 * path while we do things like enabling and disabling counters and 2032 * synchronising the counters. 2033 * 2034 * Locking rules: 2035 * 2036 * 1. m_sb_lock before picking up per-cpu locks 2037 * 2. per-cpu locks always picked up via for_each_online_cpu() order 2038 * 3. accurate counter sync requires m_sb_lock + per cpu locks 2039 * 4. modifying per-cpu counters requires holding per-cpu lock 2040 * 5. modifying global counters requires holding m_sb_lock 2041 * 6. enabling or disabling a counter requires holding the m_sb_lock 2042 * and _none_ of the per-cpu locks. 2043 * 2044 * Disabled counters are only ever re-enabled by a balance operation 2045 * that results in more free resources per CPU than a given threshold. 2046 * To ensure counters don't remain disabled, they are rebalanced when 2047 * the global resource goes above a higher threshold (i.e. some hysteresis 2048 * is present to prevent thrashing). 2049 */ 2050 2051 #ifdef CONFIG_HOTPLUG_CPU 2052 /* 2053 * hot-plug CPU notifier support. 2054 * 2055 * We need a notifier per filesystem as we need to be able to identify 2056 * the filesystem to balance the counters out. This is achieved by 2057 * having a notifier block embedded in the xfs_mount_t and doing pointer 2058 * magic to get the mount pointer from the notifier block address. 2059 */ 2060 STATIC int 2061 xfs_icsb_cpu_notify( 2062 struct notifier_block *nfb, 2063 unsigned long action, 2064 void *hcpu) 2065 { 2066 xfs_icsb_cnts_t *cntp; 2067 xfs_mount_t *mp; 2068 2069 mp = (xfs_mount_t *)container_of(nfb, xfs_mount_t, m_icsb_notifier); 2070 cntp = (xfs_icsb_cnts_t *) 2071 per_cpu_ptr(mp->m_sb_cnts, (unsigned long)hcpu); 2072 switch (action) { 2073 case CPU_UP_PREPARE: 2074 case CPU_UP_PREPARE_FROZEN: 2075 /* Easy Case - initialize the area and locks, and 2076 * then rebalance when online does everything else for us. */ 2077 memset(cntp, 0, sizeof(xfs_icsb_cnts_t)); 2078 break; 2079 case CPU_ONLINE: 2080 case CPU_ONLINE_FROZEN: 2081 xfs_icsb_lock(mp); 2082 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0); 2083 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0); 2084 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0); 2085 xfs_icsb_unlock(mp); 2086 break; 2087 case CPU_DEAD: 2088 case CPU_DEAD_FROZEN: 2089 /* Disable all the counters, then fold the dead cpu's 2090 * count into the total on the global superblock and 2091 * re-enable the counters. */ 2092 xfs_icsb_lock(mp); 2093 spin_lock(&mp->m_sb_lock); 2094 xfs_icsb_disable_counter(mp, XFS_SBS_ICOUNT); 2095 xfs_icsb_disable_counter(mp, XFS_SBS_IFREE); 2096 xfs_icsb_disable_counter(mp, XFS_SBS_FDBLOCKS); 2097 2098 mp->m_sb.sb_icount += cntp->icsb_icount; 2099 mp->m_sb.sb_ifree += cntp->icsb_ifree; 2100 mp->m_sb.sb_fdblocks += cntp->icsb_fdblocks; 2101 2102 memset(cntp, 0, sizeof(xfs_icsb_cnts_t)); 2103 2104 xfs_icsb_balance_counter_locked(mp, XFS_SBS_ICOUNT, 0); 2105 xfs_icsb_balance_counter_locked(mp, XFS_SBS_IFREE, 0); 2106 xfs_icsb_balance_counter_locked(mp, XFS_SBS_FDBLOCKS, 0); 2107 spin_unlock(&mp->m_sb_lock); 2108 xfs_icsb_unlock(mp); 2109 break; 2110 } 2111 2112 return NOTIFY_OK; 2113 } 2114 #endif /* CONFIG_HOTPLUG_CPU */ 2115 2116 int 2117 xfs_icsb_init_counters( 2118 xfs_mount_t *mp) 2119 { 2120 xfs_icsb_cnts_t *cntp; 2121 int i; 2122 2123 mp->m_sb_cnts = alloc_percpu(xfs_icsb_cnts_t); 2124 if (mp->m_sb_cnts == NULL) 2125 return -ENOMEM; 2126 2127 #ifdef CONFIG_HOTPLUG_CPU 2128 mp->m_icsb_notifier.notifier_call = xfs_icsb_cpu_notify; 2129 mp->m_icsb_notifier.priority = 0; 2130 register_hotcpu_notifier(&mp->m_icsb_notifier); 2131 #endif /* CONFIG_HOTPLUG_CPU */ 2132 2133 for_each_online_cpu(i) { 2134 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 2135 memset(cntp, 0, sizeof(xfs_icsb_cnts_t)); 2136 } 2137 2138 mutex_init(&mp->m_icsb_mutex); 2139 2140 /* 2141 * start with all counters disabled so that the 2142 * initial balance kicks us off correctly 2143 */ 2144 mp->m_icsb_counters = -1; 2145 return 0; 2146 } 2147 2148 void 2149 xfs_icsb_reinit_counters( 2150 xfs_mount_t *mp) 2151 { 2152 xfs_icsb_lock(mp); 2153 /* 2154 * start with all counters disabled so that the 2155 * initial balance kicks us off correctly 2156 */ 2157 mp->m_icsb_counters = -1; 2158 xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0); 2159 xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0); 2160 xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0); 2161 xfs_icsb_unlock(mp); 2162 } 2163 2164 void 2165 xfs_icsb_destroy_counters( 2166 xfs_mount_t *mp) 2167 { 2168 if (mp->m_sb_cnts) { 2169 unregister_hotcpu_notifier(&mp->m_icsb_notifier); 2170 free_percpu(mp->m_sb_cnts); 2171 } 2172 mutex_destroy(&mp->m_icsb_mutex); 2173 } 2174 2175 STATIC void 2176 xfs_icsb_lock_cntr( 2177 xfs_icsb_cnts_t *icsbp) 2178 { 2179 while (test_and_set_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags)) { 2180 ndelay(1000); 2181 } 2182 } 2183 2184 STATIC void 2185 xfs_icsb_unlock_cntr( 2186 xfs_icsb_cnts_t *icsbp) 2187 { 2188 clear_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags); 2189 } 2190 2191 2192 STATIC void 2193 xfs_icsb_lock_all_counters( 2194 xfs_mount_t *mp) 2195 { 2196 xfs_icsb_cnts_t *cntp; 2197 int i; 2198 2199 for_each_online_cpu(i) { 2200 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 2201 xfs_icsb_lock_cntr(cntp); 2202 } 2203 } 2204 2205 STATIC void 2206 xfs_icsb_unlock_all_counters( 2207 xfs_mount_t *mp) 2208 { 2209 xfs_icsb_cnts_t *cntp; 2210 int i; 2211 2212 for_each_online_cpu(i) { 2213 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 2214 xfs_icsb_unlock_cntr(cntp); 2215 } 2216 } 2217 2218 STATIC void 2219 xfs_icsb_count( 2220 xfs_mount_t *mp, 2221 xfs_icsb_cnts_t *cnt, 2222 int flags) 2223 { 2224 xfs_icsb_cnts_t *cntp; 2225 int i; 2226 2227 memset(cnt, 0, sizeof(xfs_icsb_cnts_t)); 2228 2229 if (!(flags & XFS_ICSB_LAZY_COUNT)) 2230 xfs_icsb_lock_all_counters(mp); 2231 2232 for_each_online_cpu(i) { 2233 cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 2234 cnt->icsb_icount += cntp->icsb_icount; 2235 cnt->icsb_ifree += cntp->icsb_ifree; 2236 cnt->icsb_fdblocks += cntp->icsb_fdblocks; 2237 } 2238 2239 if (!(flags & XFS_ICSB_LAZY_COUNT)) 2240 xfs_icsb_unlock_all_counters(mp); 2241 } 2242 2243 STATIC int 2244 xfs_icsb_counter_disabled( 2245 xfs_mount_t *mp, 2246 xfs_sb_field_t field) 2247 { 2248 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS)); 2249 return test_bit(field, &mp->m_icsb_counters); 2250 } 2251 2252 STATIC void 2253 xfs_icsb_disable_counter( 2254 xfs_mount_t *mp, 2255 xfs_sb_field_t field) 2256 { 2257 xfs_icsb_cnts_t cnt; 2258 2259 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS)); 2260 2261 /* 2262 * If we are already disabled, then there is nothing to do 2263 * here. We check before locking all the counters to avoid 2264 * the expensive lock operation when being called in the 2265 * slow path and the counter is already disabled. This is 2266 * safe because the only time we set or clear this state is under 2267 * the m_icsb_mutex. 2268 */ 2269 if (xfs_icsb_counter_disabled(mp, field)) 2270 return; 2271 2272 xfs_icsb_lock_all_counters(mp); 2273 if (!test_and_set_bit(field, &mp->m_icsb_counters)) { 2274 /* drain back to superblock */ 2275 2276 xfs_icsb_count(mp, &cnt, XFS_ICSB_LAZY_COUNT); 2277 switch(field) { 2278 case XFS_SBS_ICOUNT: 2279 mp->m_sb.sb_icount = cnt.icsb_icount; 2280 break; 2281 case XFS_SBS_IFREE: 2282 mp->m_sb.sb_ifree = cnt.icsb_ifree; 2283 break; 2284 case XFS_SBS_FDBLOCKS: 2285 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks; 2286 break; 2287 default: 2288 BUG(); 2289 } 2290 } 2291 2292 xfs_icsb_unlock_all_counters(mp); 2293 } 2294 2295 STATIC void 2296 xfs_icsb_enable_counter( 2297 xfs_mount_t *mp, 2298 xfs_sb_field_t field, 2299 uint64_t count, 2300 uint64_t resid) 2301 { 2302 xfs_icsb_cnts_t *cntp; 2303 int i; 2304 2305 ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS)); 2306 2307 xfs_icsb_lock_all_counters(mp); 2308 for_each_online_cpu(i) { 2309 cntp = per_cpu_ptr(mp->m_sb_cnts, i); 2310 switch (field) { 2311 case XFS_SBS_ICOUNT: 2312 cntp->icsb_icount = count + resid; 2313 break; 2314 case XFS_SBS_IFREE: 2315 cntp->icsb_ifree = count + resid; 2316 break; 2317 case XFS_SBS_FDBLOCKS: 2318 cntp->icsb_fdblocks = count + resid; 2319 break; 2320 default: 2321 BUG(); 2322 break; 2323 } 2324 resid = 0; 2325 } 2326 clear_bit(field, &mp->m_icsb_counters); 2327 xfs_icsb_unlock_all_counters(mp); 2328 } 2329 2330 void 2331 xfs_icsb_sync_counters_locked( 2332 xfs_mount_t *mp, 2333 int flags) 2334 { 2335 xfs_icsb_cnts_t cnt; 2336 2337 xfs_icsb_count(mp, &cnt, flags); 2338 2339 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_ICOUNT)) 2340 mp->m_sb.sb_icount = cnt.icsb_icount; 2341 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_IFREE)) 2342 mp->m_sb.sb_ifree = cnt.icsb_ifree; 2343 if (!xfs_icsb_counter_disabled(mp, XFS_SBS_FDBLOCKS)) 2344 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks; 2345 } 2346 2347 /* 2348 * Accurate update of per-cpu counters to incore superblock 2349 */ 2350 void 2351 xfs_icsb_sync_counters( 2352 xfs_mount_t *mp, 2353 int flags) 2354 { 2355 spin_lock(&mp->m_sb_lock); 2356 xfs_icsb_sync_counters_locked(mp, flags); 2357 spin_unlock(&mp->m_sb_lock); 2358 } 2359 2360 /* 2361 * Balance and enable/disable counters as necessary. 2362 * 2363 * Thresholds for re-enabling counters are somewhat magic. inode counts are 2364 * chosen to be the same number as single on disk allocation chunk per CPU, and 2365 * free blocks is something far enough zero that we aren't going thrash when we 2366 * get near ENOSPC. We also need to supply a minimum we require per cpu to 2367 * prevent looping endlessly when xfs_alloc_space asks for more than will 2368 * be distributed to a single CPU but each CPU has enough blocks to be 2369 * reenabled. 2370 * 2371 * Note that we can be called when counters are already disabled. 2372 * xfs_icsb_disable_counter() optimises the counter locking in this case to 2373 * prevent locking every per-cpu counter needlessly. 2374 */ 2375 2376 #define XFS_ICSB_INO_CNTR_REENABLE (uint64_t)64 2377 #define XFS_ICSB_FDBLK_CNTR_REENABLE(mp) \ 2378 (uint64_t)(512 + XFS_ALLOC_SET_ASIDE(mp)) 2379 STATIC void 2380 xfs_icsb_balance_counter_locked( 2381 xfs_mount_t *mp, 2382 xfs_sb_field_t field, 2383 int min_per_cpu) 2384 { 2385 uint64_t count, resid; 2386 int weight = num_online_cpus(); 2387 uint64_t min = (uint64_t)min_per_cpu; 2388 2389 /* disable counter and sync counter */ 2390 xfs_icsb_disable_counter(mp, field); 2391 2392 /* update counters - first CPU gets residual*/ 2393 switch (field) { 2394 case XFS_SBS_ICOUNT: 2395 count = mp->m_sb.sb_icount; 2396 resid = do_div(count, weight); 2397 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE)) 2398 return; 2399 break; 2400 case XFS_SBS_IFREE: 2401 count = mp->m_sb.sb_ifree; 2402 resid = do_div(count, weight); 2403 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE)) 2404 return; 2405 break; 2406 case XFS_SBS_FDBLOCKS: 2407 count = mp->m_sb.sb_fdblocks; 2408 resid = do_div(count, weight); 2409 if (count < max(min, XFS_ICSB_FDBLK_CNTR_REENABLE(mp))) 2410 return; 2411 break; 2412 default: 2413 BUG(); 2414 count = resid = 0; /* quiet, gcc */ 2415 break; 2416 } 2417 2418 xfs_icsb_enable_counter(mp, field, count, resid); 2419 } 2420 2421 STATIC void 2422 xfs_icsb_balance_counter( 2423 xfs_mount_t *mp, 2424 xfs_sb_field_t fields, 2425 int min_per_cpu) 2426 { 2427 spin_lock(&mp->m_sb_lock); 2428 xfs_icsb_balance_counter_locked(mp, fields, min_per_cpu); 2429 spin_unlock(&mp->m_sb_lock); 2430 } 2431 2432 int 2433 xfs_icsb_modify_counters( 2434 xfs_mount_t *mp, 2435 xfs_sb_field_t field, 2436 int64_t delta, 2437 int rsvd) 2438 { 2439 xfs_icsb_cnts_t *icsbp; 2440 long long lcounter; /* long counter for 64 bit fields */ 2441 int ret = 0; 2442 2443 might_sleep(); 2444 again: 2445 preempt_disable(); 2446 icsbp = this_cpu_ptr(mp->m_sb_cnts); 2447 2448 /* 2449 * if the counter is disabled, go to slow path 2450 */ 2451 if (unlikely(xfs_icsb_counter_disabled(mp, field))) 2452 goto slow_path; 2453 xfs_icsb_lock_cntr(icsbp); 2454 if (unlikely(xfs_icsb_counter_disabled(mp, field))) { 2455 xfs_icsb_unlock_cntr(icsbp); 2456 goto slow_path; 2457 } 2458 2459 switch (field) { 2460 case XFS_SBS_ICOUNT: 2461 lcounter = icsbp->icsb_icount; 2462 lcounter += delta; 2463 if (unlikely(lcounter < 0)) 2464 goto balance_counter; 2465 icsbp->icsb_icount = lcounter; 2466 break; 2467 2468 case XFS_SBS_IFREE: 2469 lcounter = icsbp->icsb_ifree; 2470 lcounter += delta; 2471 if (unlikely(lcounter < 0)) 2472 goto balance_counter; 2473 icsbp->icsb_ifree = lcounter; 2474 break; 2475 2476 case XFS_SBS_FDBLOCKS: 2477 BUG_ON((mp->m_resblks - mp->m_resblks_avail) != 0); 2478 2479 lcounter = icsbp->icsb_fdblocks - XFS_ALLOC_SET_ASIDE(mp); 2480 lcounter += delta; 2481 if (unlikely(lcounter < 0)) 2482 goto balance_counter; 2483 icsbp->icsb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp); 2484 break; 2485 default: 2486 BUG(); 2487 break; 2488 } 2489 xfs_icsb_unlock_cntr(icsbp); 2490 preempt_enable(); 2491 return 0; 2492 2493 slow_path: 2494 preempt_enable(); 2495 2496 /* 2497 * serialise with a mutex so we don't burn lots of cpu on 2498 * the superblock lock. We still need to hold the superblock 2499 * lock, however, when we modify the global structures. 2500 */ 2501 xfs_icsb_lock(mp); 2502 2503 /* 2504 * Now running atomically. 2505 * 2506 * If the counter is enabled, someone has beaten us to rebalancing. 2507 * Drop the lock and try again in the fast path.... 2508 */ 2509 if (!(xfs_icsb_counter_disabled(mp, field))) { 2510 xfs_icsb_unlock(mp); 2511 goto again; 2512 } 2513 2514 /* 2515 * The counter is currently disabled. Because we are 2516 * running atomically here, we know a rebalance cannot 2517 * be in progress. Hence we can go straight to operating 2518 * on the global superblock. We do not call xfs_mod_incore_sb() 2519 * here even though we need to get the m_sb_lock. Doing so 2520 * will cause us to re-enter this function and deadlock. 2521 * Hence we get the m_sb_lock ourselves and then call 2522 * xfs_mod_incore_sb_unlocked() as the unlocked path operates 2523 * directly on the global counters. 2524 */ 2525 spin_lock(&mp->m_sb_lock); 2526 ret = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd); 2527 spin_unlock(&mp->m_sb_lock); 2528 2529 /* 2530 * Now that we've modified the global superblock, we 2531 * may be able to re-enable the distributed counters 2532 * (e.g. lots of space just got freed). After that 2533 * we are done. 2534 */ 2535 if (ret != ENOSPC) 2536 xfs_icsb_balance_counter(mp, field, 0); 2537 xfs_icsb_unlock(mp); 2538 return ret; 2539 2540 balance_counter: 2541 xfs_icsb_unlock_cntr(icsbp); 2542 preempt_enable(); 2543 2544 /* 2545 * We may have multiple threads here if multiple per-cpu 2546 * counters run dry at the same time. This will mean we can 2547 * do more balances than strictly necessary but it is not 2548 * the common slowpath case. 2549 */ 2550 xfs_icsb_lock(mp); 2551 2552 /* 2553 * running atomically. 2554 * 2555 * This will leave the counter in the correct state for future 2556 * accesses. After the rebalance, we simply try again and our retry 2557 * will either succeed through the fast path or slow path without 2558 * another balance operation being required. 2559 */ 2560 xfs_icsb_balance_counter(mp, field, delta); 2561 xfs_icsb_unlock(mp); 2562 goto again; 2563 } 2564 2565 #endif 2566