1 /* 2 * Copyright (c) 2000-2004 Silicon Graphics, Inc. All Rights Reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms of version 2 of the GNU General Public License as 6 * published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it would be useful, but 9 * WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 11 * 12 * Further, this software is distributed without any warranty that it is 13 * free of the rightful claim of any third person regarding infringement 14 * or the like. Any license provided herein, whether implied or 15 * otherwise, applies only to this software file. Patent licenses, if 16 * any, provided herein do not apply to combinations of this program with 17 * other software, or any other product whatsoever. 18 * 19 * You should have received a copy of the GNU General Public License along 20 * with this program; if not, write the Free Software Foundation, Inc., 59 21 * Temple Place - Suite 330, Boston MA 02111-1307, USA. 22 * 23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, 24 * Mountain View, CA 94043, or: 25 * 26 * http://www.sgi.com 27 * 28 * For further information regarding this notice, see: 29 * 30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/ 31 */ 32 33 #include "xfs.h" 34 #include "xfs_macros.h" 35 #include "xfs_types.h" 36 #include "xfs_inum.h" 37 #include "xfs_log.h" 38 #include "xfs_trans.h" 39 #include "xfs_sb.h" 40 #include "xfs_ag.h" 41 #include "xfs_dir.h" 42 #include "xfs_dir2.h" 43 #include "xfs_dmapi.h" 44 #include "xfs_mount.h" 45 #include "xfs_alloc_btree.h" 46 #include "xfs_bmap_btree.h" 47 #include "xfs_ialloc_btree.h" 48 #include "xfs_btree.h" 49 #include "xfs_ialloc.h" 50 #include "xfs_attr_sf.h" 51 #include "xfs_dir_sf.h" 52 #include "xfs_dir2_sf.h" 53 #include "xfs_dinode.h" 54 #include "xfs_inode.h" 55 #include "xfs_alloc.h" 56 #include "xfs_rtalloc.h" 57 #include "xfs_bmap.h" 58 #include "xfs_error.h" 59 #include "xfs_bit.h" 60 #include "xfs_rw.h" 61 #include "xfs_quota.h" 62 #include "xfs_fsops.h" 63 64 STATIC void xfs_mount_log_sbunit(xfs_mount_t *, __int64_t); 65 STATIC int xfs_uuid_mount(xfs_mount_t *); 66 STATIC void xfs_uuid_unmount(xfs_mount_t *mp); 67 68 static struct { 69 short offset; 70 short type; /* 0 = integer 71 * 1 = binary / string (no translation) 72 */ 73 } xfs_sb_info[] = { 74 { offsetof(xfs_sb_t, sb_magicnum), 0 }, 75 { offsetof(xfs_sb_t, sb_blocksize), 0 }, 76 { offsetof(xfs_sb_t, sb_dblocks), 0 }, 77 { offsetof(xfs_sb_t, sb_rblocks), 0 }, 78 { offsetof(xfs_sb_t, sb_rextents), 0 }, 79 { offsetof(xfs_sb_t, sb_uuid), 1 }, 80 { offsetof(xfs_sb_t, sb_logstart), 0 }, 81 { offsetof(xfs_sb_t, sb_rootino), 0 }, 82 { offsetof(xfs_sb_t, sb_rbmino), 0 }, 83 { offsetof(xfs_sb_t, sb_rsumino), 0 }, 84 { offsetof(xfs_sb_t, sb_rextsize), 0 }, 85 { offsetof(xfs_sb_t, sb_agblocks), 0 }, 86 { offsetof(xfs_sb_t, sb_agcount), 0 }, 87 { offsetof(xfs_sb_t, sb_rbmblocks), 0 }, 88 { offsetof(xfs_sb_t, sb_logblocks), 0 }, 89 { offsetof(xfs_sb_t, sb_versionnum), 0 }, 90 { offsetof(xfs_sb_t, sb_sectsize), 0 }, 91 { offsetof(xfs_sb_t, sb_inodesize), 0 }, 92 { offsetof(xfs_sb_t, sb_inopblock), 0 }, 93 { offsetof(xfs_sb_t, sb_fname[0]), 1 }, 94 { offsetof(xfs_sb_t, sb_blocklog), 0 }, 95 { offsetof(xfs_sb_t, sb_sectlog), 0 }, 96 { offsetof(xfs_sb_t, sb_inodelog), 0 }, 97 { offsetof(xfs_sb_t, sb_inopblog), 0 }, 98 { offsetof(xfs_sb_t, sb_agblklog), 0 }, 99 { offsetof(xfs_sb_t, sb_rextslog), 0 }, 100 { offsetof(xfs_sb_t, sb_inprogress), 0 }, 101 { offsetof(xfs_sb_t, sb_imax_pct), 0 }, 102 { offsetof(xfs_sb_t, sb_icount), 0 }, 103 { offsetof(xfs_sb_t, sb_ifree), 0 }, 104 { offsetof(xfs_sb_t, sb_fdblocks), 0 }, 105 { offsetof(xfs_sb_t, sb_frextents), 0 }, 106 { offsetof(xfs_sb_t, sb_uquotino), 0 }, 107 { offsetof(xfs_sb_t, sb_gquotino), 0 }, 108 { offsetof(xfs_sb_t, sb_qflags), 0 }, 109 { offsetof(xfs_sb_t, sb_flags), 0 }, 110 { offsetof(xfs_sb_t, sb_shared_vn), 0 }, 111 { offsetof(xfs_sb_t, sb_inoalignmt), 0 }, 112 { offsetof(xfs_sb_t, sb_unit), 0 }, 113 { offsetof(xfs_sb_t, sb_width), 0 }, 114 { offsetof(xfs_sb_t, sb_dirblklog), 0 }, 115 { offsetof(xfs_sb_t, sb_logsectlog), 0 }, 116 { offsetof(xfs_sb_t, sb_logsectsize),0 }, 117 { offsetof(xfs_sb_t, sb_logsunit), 0 }, 118 { offsetof(xfs_sb_t, sb_features2), 0 }, 119 { sizeof(xfs_sb_t), 0 } 120 }; 121 122 /* 123 * Return a pointer to an initialized xfs_mount structure. 124 */ 125 xfs_mount_t * 126 xfs_mount_init(void) 127 { 128 xfs_mount_t *mp; 129 130 mp = kmem_zalloc(sizeof(*mp), KM_SLEEP); 131 132 AIL_LOCKINIT(&mp->m_ail_lock, "xfs_ail"); 133 spinlock_init(&mp->m_sb_lock, "xfs_sb"); 134 mutex_init(&mp->m_ilock, MUTEX_DEFAULT, "xfs_ilock"); 135 initnsema(&mp->m_growlock, 1, "xfs_grow"); 136 /* 137 * Initialize the AIL. 138 */ 139 xfs_trans_ail_init(mp); 140 141 atomic_set(&mp->m_active_trans, 0); 142 143 return mp; 144 } 145 146 /* 147 * Free up the resources associated with a mount structure. Assume that 148 * the structure was initially zeroed, so we can tell which fields got 149 * initialized. 150 */ 151 void 152 xfs_mount_free( 153 xfs_mount_t *mp, 154 int remove_bhv) 155 { 156 if (mp->m_ihash) 157 xfs_ihash_free(mp); 158 if (mp->m_chash) 159 xfs_chash_free(mp); 160 161 if (mp->m_perag) { 162 int agno; 163 164 for (agno = 0; agno < mp->m_maxagi; agno++) 165 if (mp->m_perag[agno].pagb_list) 166 kmem_free(mp->m_perag[agno].pagb_list, 167 sizeof(xfs_perag_busy_t) * 168 XFS_PAGB_NUM_SLOTS); 169 kmem_free(mp->m_perag, 170 sizeof(xfs_perag_t) * mp->m_sb.sb_agcount); 171 } 172 173 AIL_LOCK_DESTROY(&mp->m_ail_lock); 174 spinlock_destroy(&mp->m_sb_lock); 175 mutex_destroy(&mp->m_ilock); 176 freesema(&mp->m_growlock); 177 if (mp->m_quotainfo) 178 XFS_QM_DONE(mp); 179 180 if (mp->m_fsname != NULL) 181 kmem_free(mp->m_fsname, mp->m_fsname_len); 182 183 if (remove_bhv) { 184 struct vfs *vfsp = XFS_MTOVFS(mp); 185 186 bhv_remove_all_vfsops(vfsp, 0); 187 VFS_REMOVEBHV(vfsp, &mp->m_bhv); 188 } 189 190 kmem_free(mp, sizeof(xfs_mount_t)); 191 } 192 193 194 /* 195 * Check the validity of the SB found. 196 */ 197 STATIC int 198 xfs_mount_validate_sb( 199 xfs_mount_t *mp, 200 xfs_sb_t *sbp) 201 { 202 /* 203 * If the log device and data device have the 204 * same device number, the log is internal. 205 * Consequently, the sb_logstart should be non-zero. If 206 * we have a zero sb_logstart in this case, we may be trying to mount 207 * a volume filesystem in a non-volume manner. 208 */ 209 if (sbp->sb_magicnum != XFS_SB_MAGIC) { 210 cmn_err(CE_WARN, "XFS: bad magic number"); 211 return XFS_ERROR(EWRONGFS); 212 } 213 214 if (!XFS_SB_GOOD_VERSION(sbp)) { 215 cmn_err(CE_WARN, "XFS: bad version"); 216 return XFS_ERROR(EWRONGFS); 217 } 218 219 if (unlikely( 220 sbp->sb_logstart == 0 && mp->m_logdev_targp == mp->m_ddev_targp)) { 221 cmn_err(CE_WARN, 222 "XFS: filesystem is marked as having an external log; " 223 "specify logdev on the\nmount command line."); 224 XFS_CORRUPTION_ERROR("xfs_mount_validate_sb(1)", 225 XFS_ERRLEVEL_HIGH, mp, sbp); 226 return XFS_ERROR(EFSCORRUPTED); 227 } 228 229 if (unlikely( 230 sbp->sb_logstart != 0 && mp->m_logdev_targp != mp->m_ddev_targp)) { 231 cmn_err(CE_WARN, 232 "XFS: filesystem is marked as having an internal log; " 233 "don't specify logdev on\nthe mount command line."); 234 XFS_CORRUPTION_ERROR("xfs_mount_validate_sb(2)", 235 XFS_ERRLEVEL_HIGH, mp, sbp); 236 return XFS_ERROR(EFSCORRUPTED); 237 } 238 239 /* 240 * More sanity checking. These were stolen directly from 241 * xfs_repair. 242 */ 243 if (unlikely( 244 sbp->sb_agcount <= 0 || 245 sbp->sb_sectsize < XFS_MIN_SECTORSIZE || 246 sbp->sb_sectsize > XFS_MAX_SECTORSIZE || 247 sbp->sb_sectlog < XFS_MIN_SECTORSIZE_LOG || 248 sbp->sb_sectlog > XFS_MAX_SECTORSIZE_LOG || 249 sbp->sb_blocksize < XFS_MIN_BLOCKSIZE || 250 sbp->sb_blocksize > XFS_MAX_BLOCKSIZE || 251 sbp->sb_blocklog < XFS_MIN_BLOCKSIZE_LOG || 252 sbp->sb_blocklog > XFS_MAX_BLOCKSIZE_LOG || 253 sbp->sb_inodesize < XFS_DINODE_MIN_SIZE || 254 sbp->sb_inodesize > XFS_DINODE_MAX_SIZE || 255 (sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE) || 256 (sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE) || 257 sbp->sb_imax_pct > 100)) { 258 cmn_err(CE_WARN, "XFS: SB sanity check 1 failed"); 259 XFS_CORRUPTION_ERROR("xfs_mount_validate_sb(3)", 260 XFS_ERRLEVEL_LOW, mp, sbp); 261 return XFS_ERROR(EFSCORRUPTED); 262 } 263 264 /* 265 * Sanity check AG count, size fields against data size field 266 */ 267 if (unlikely( 268 sbp->sb_dblocks == 0 || 269 sbp->sb_dblocks > 270 (xfs_drfsbno_t)sbp->sb_agcount * sbp->sb_agblocks || 271 sbp->sb_dblocks < (xfs_drfsbno_t)(sbp->sb_agcount - 1) * 272 sbp->sb_agblocks + XFS_MIN_AG_BLOCKS)) { 273 cmn_err(CE_WARN, "XFS: SB sanity check 2 failed"); 274 XFS_ERROR_REPORT("xfs_mount_validate_sb(4)", 275 XFS_ERRLEVEL_LOW, mp); 276 return XFS_ERROR(EFSCORRUPTED); 277 } 278 279 ASSERT(PAGE_SHIFT >= sbp->sb_blocklog); 280 ASSERT(sbp->sb_blocklog >= BBSHIFT); 281 282 #if XFS_BIG_BLKNOS /* Limited by ULONG_MAX of page cache index */ 283 if (unlikely( 284 (sbp->sb_dblocks >> (PAGE_SHIFT - sbp->sb_blocklog)) > ULONG_MAX || 285 (sbp->sb_rblocks >> (PAGE_SHIFT - sbp->sb_blocklog)) > ULONG_MAX)) { 286 #else /* Limited by UINT_MAX of sectors */ 287 if (unlikely( 288 (sbp->sb_dblocks << (sbp->sb_blocklog - BBSHIFT)) > UINT_MAX || 289 (sbp->sb_rblocks << (sbp->sb_blocklog - BBSHIFT)) > UINT_MAX)) { 290 #endif 291 cmn_err(CE_WARN, 292 "XFS: File system is too large to be mounted on this system."); 293 return XFS_ERROR(E2BIG); 294 } 295 296 if (unlikely(sbp->sb_inprogress)) { 297 cmn_err(CE_WARN, "XFS: file system busy"); 298 XFS_ERROR_REPORT("xfs_mount_validate_sb(5)", 299 XFS_ERRLEVEL_LOW, mp); 300 return XFS_ERROR(EFSCORRUPTED); 301 } 302 303 /* 304 * Until this is fixed only page-sized or smaller data blocks work. 305 */ 306 if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) { 307 cmn_err(CE_WARN, 308 "XFS: Attempted to mount file system with blocksize %d bytes", 309 sbp->sb_blocksize); 310 cmn_err(CE_WARN, 311 "XFS: Only page-sized (%d) or less blocksizes currently work.", 312 PAGE_SIZE); 313 return XFS_ERROR(ENOSYS); 314 } 315 316 return 0; 317 } 318 319 xfs_agnumber_t 320 xfs_initialize_perag(xfs_mount_t *mp, xfs_agnumber_t agcount) 321 { 322 xfs_agnumber_t index, max_metadata; 323 xfs_perag_t *pag; 324 xfs_agino_t agino; 325 xfs_ino_t ino; 326 xfs_sb_t *sbp = &mp->m_sb; 327 xfs_ino_t max_inum = XFS_MAXINUMBER_32; 328 329 /* Check to see if the filesystem can overflow 32 bit inodes */ 330 agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0); 331 ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino); 332 333 /* Clear the mount flag if no inode can overflow 32 bits 334 * on this filesystem, or if specifically requested.. 335 */ 336 if ((mp->m_flags & XFS_MOUNT_32BITINOOPT) && ino > max_inum) { 337 mp->m_flags |= XFS_MOUNT_32BITINODES; 338 } else { 339 mp->m_flags &= ~XFS_MOUNT_32BITINODES; 340 } 341 342 /* If we can overflow then setup the ag headers accordingly */ 343 if (mp->m_flags & XFS_MOUNT_32BITINODES) { 344 /* Calculate how much should be reserved for inodes to 345 * meet the max inode percentage. 346 */ 347 if (mp->m_maxicount) { 348 __uint64_t icount; 349 350 icount = sbp->sb_dblocks * sbp->sb_imax_pct; 351 do_div(icount, 100); 352 icount += sbp->sb_agblocks - 1; 353 do_div(icount, mp->m_ialloc_blks); 354 max_metadata = icount; 355 } else { 356 max_metadata = agcount; 357 } 358 for (index = 0; index < agcount; index++) { 359 ino = XFS_AGINO_TO_INO(mp, index, agino); 360 if (ino > max_inum) { 361 index++; 362 break; 363 } 364 365 /* This ag is prefered for inodes */ 366 pag = &mp->m_perag[index]; 367 pag->pagi_inodeok = 1; 368 if (index < max_metadata) 369 pag->pagf_metadata = 1; 370 } 371 } else { 372 /* Setup default behavior for smaller filesystems */ 373 for (index = 0; index < agcount; index++) { 374 pag = &mp->m_perag[index]; 375 pag->pagi_inodeok = 1; 376 } 377 } 378 return index; 379 } 380 381 /* 382 * xfs_xlatesb 383 * 384 * data - on disk version of sb 385 * sb - a superblock 386 * dir - conversion direction: <0 - convert sb to buf 387 * >0 - convert buf to sb 388 * fields - which fields to copy (bitmask) 389 */ 390 void 391 xfs_xlatesb( 392 void *data, 393 xfs_sb_t *sb, 394 int dir, 395 __int64_t fields) 396 { 397 xfs_caddr_t buf_ptr; 398 xfs_caddr_t mem_ptr; 399 xfs_sb_field_t f; 400 int first; 401 int size; 402 403 ASSERT(dir); 404 ASSERT(fields); 405 406 if (!fields) 407 return; 408 409 buf_ptr = (xfs_caddr_t)data; 410 mem_ptr = (xfs_caddr_t)sb; 411 412 while (fields) { 413 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields); 414 first = xfs_sb_info[f].offset; 415 size = xfs_sb_info[f + 1].offset - first; 416 417 ASSERT(xfs_sb_info[f].type == 0 || xfs_sb_info[f].type == 1); 418 419 if (size == 1 || xfs_sb_info[f].type == 1) { 420 if (dir > 0) { 421 memcpy(mem_ptr + first, buf_ptr + first, size); 422 } else { 423 memcpy(buf_ptr + first, mem_ptr + first, size); 424 } 425 } else { 426 switch (size) { 427 case 2: 428 INT_XLATE(*(__uint16_t*)(buf_ptr+first), 429 *(__uint16_t*)(mem_ptr+first), 430 dir, ARCH_CONVERT); 431 break; 432 case 4: 433 INT_XLATE(*(__uint32_t*)(buf_ptr+first), 434 *(__uint32_t*)(mem_ptr+first), 435 dir, ARCH_CONVERT); 436 break; 437 case 8: 438 INT_XLATE(*(__uint64_t*)(buf_ptr+first), 439 *(__uint64_t*)(mem_ptr+first), dir, ARCH_CONVERT); 440 break; 441 default: 442 ASSERT(0); 443 } 444 } 445 446 fields &= ~(1LL << f); 447 } 448 } 449 450 /* 451 * xfs_readsb 452 * 453 * Does the initial read of the superblock. 454 */ 455 int 456 xfs_readsb(xfs_mount_t *mp) 457 { 458 unsigned int sector_size; 459 unsigned int extra_flags; 460 xfs_buf_t *bp; 461 xfs_sb_t *sbp; 462 int error; 463 464 ASSERT(mp->m_sb_bp == NULL); 465 ASSERT(mp->m_ddev_targp != NULL); 466 467 /* 468 * Allocate a (locked) buffer to hold the superblock. 469 * This will be kept around at all times to optimize 470 * access to the superblock. 471 */ 472 sector_size = xfs_getsize_buftarg(mp->m_ddev_targp); 473 extra_flags = XFS_BUF_LOCK | XFS_BUF_MANAGE | XFS_BUF_MAPPED; 474 475 bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR, 476 BTOBB(sector_size), extra_flags); 477 if (!bp || XFS_BUF_ISERROR(bp)) { 478 cmn_err(CE_WARN, "XFS: SB read failed"); 479 error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM; 480 goto fail; 481 } 482 ASSERT(XFS_BUF_ISBUSY(bp)); 483 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0); 484 485 /* 486 * Initialize the mount structure from the superblock. 487 * But first do some basic consistency checking. 488 */ 489 sbp = XFS_BUF_TO_SBP(bp); 490 xfs_xlatesb(XFS_BUF_PTR(bp), &(mp->m_sb), 1, XFS_SB_ALL_BITS); 491 492 error = xfs_mount_validate_sb(mp, &(mp->m_sb)); 493 if (error) { 494 cmn_err(CE_WARN, "XFS: SB validate failed"); 495 goto fail; 496 } 497 498 /* 499 * We must be able to do sector-sized and sector-aligned IO. 500 */ 501 if (sector_size > mp->m_sb.sb_sectsize) { 502 cmn_err(CE_WARN, 503 "XFS: device supports only %u byte sectors (not %u)", 504 sector_size, mp->m_sb.sb_sectsize); 505 error = ENOSYS; 506 goto fail; 507 } 508 509 /* 510 * If device sector size is smaller than the superblock size, 511 * re-read the superblock so the buffer is correctly sized. 512 */ 513 if (sector_size < mp->m_sb.sb_sectsize) { 514 XFS_BUF_UNMANAGE(bp); 515 xfs_buf_relse(bp); 516 sector_size = mp->m_sb.sb_sectsize; 517 bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR, 518 BTOBB(sector_size), extra_flags); 519 if (!bp || XFS_BUF_ISERROR(bp)) { 520 cmn_err(CE_WARN, "XFS: SB re-read failed"); 521 error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM; 522 goto fail; 523 } 524 ASSERT(XFS_BUF_ISBUSY(bp)); 525 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0); 526 } 527 528 mp->m_sb_bp = bp; 529 xfs_buf_relse(bp); 530 ASSERT(XFS_BUF_VALUSEMA(bp) > 0); 531 return 0; 532 533 fail: 534 if (bp) { 535 XFS_BUF_UNMANAGE(bp); 536 xfs_buf_relse(bp); 537 } 538 return error; 539 } 540 541 542 /* 543 * xfs_mount_common 544 * 545 * Mount initialization code establishing various mount 546 * fields from the superblock associated with the given 547 * mount structure 548 */ 549 void 550 xfs_mount_common(xfs_mount_t *mp, xfs_sb_t *sbp) 551 { 552 int i; 553 554 mp->m_agfrotor = mp->m_agirotor = 0; 555 spinlock_init(&mp->m_agirotor_lock, "m_agirotor_lock"); 556 mp->m_maxagi = mp->m_sb.sb_agcount; 557 mp->m_blkbit_log = sbp->sb_blocklog + XFS_NBBYLOG; 558 mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT; 559 mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT; 560 mp->m_agno_log = xfs_highbit32(sbp->sb_agcount - 1) + 1; 561 mp->m_agino_log = sbp->sb_inopblog + sbp->sb_agblklog; 562 mp->m_litino = sbp->sb_inodesize - 563 ((uint)sizeof(xfs_dinode_core_t) + (uint)sizeof(xfs_agino_t)); 564 mp->m_blockmask = sbp->sb_blocksize - 1; 565 mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG; 566 mp->m_blockwmask = mp->m_blockwsize - 1; 567 INIT_LIST_HEAD(&mp->m_del_inodes); 568 569 /* 570 * Setup for attributes, in case they get created. 571 * This value is for inodes getting attributes for the first time, 572 * the per-inode value is for old attribute values. 573 */ 574 ASSERT(sbp->sb_inodesize >= 256 && sbp->sb_inodesize <= 2048); 575 switch (sbp->sb_inodesize) { 576 case 256: 577 mp->m_attroffset = XFS_LITINO(mp) - XFS_BMDR_SPACE_CALC(2); 578 break; 579 case 512: 580 case 1024: 581 case 2048: 582 mp->m_attroffset = XFS_BMDR_SPACE_CALC(12); 583 break; 584 default: 585 ASSERT(0); 586 } 587 ASSERT(mp->m_attroffset < XFS_LITINO(mp)); 588 589 for (i = 0; i < 2; i++) { 590 mp->m_alloc_mxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize, 591 xfs_alloc, i == 0); 592 mp->m_alloc_mnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize, 593 xfs_alloc, i == 0); 594 } 595 for (i = 0; i < 2; i++) { 596 mp->m_bmap_dmxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize, 597 xfs_bmbt, i == 0); 598 mp->m_bmap_dmnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize, 599 xfs_bmbt, i == 0); 600 } 601 for (i = 0; i < 2; i++) { 602 mp->m_inobt_mxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize, 603 xfs_inobt, i == 0); 604 mp->m_inobt_mnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize, 605 xfs_inobt, i == 0); 606 } 607 608 mp->m_bsize = XFS_FSB_TO_BB(mp, 1); 609 mp->m_ialloc_inos = (int)MAX((__uint16_t)XFS_INODES_PER_CHUNK, 610 sbp->sb_inopblock); 611 mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog; 612 } 613 /* 614 * xfs_mountfs 615 * 616 * This function does the following on an initial mount of a file system: 617 * - reads the superblock from disk and init the mount struct 618 * - if we're a 32-bit kernel, do a size check on the superblock 619 * so we don't mount terabyte filesystems 620 * - init mount struct realtime fields 621 * - allocate inode hash table for fs 622 * - init directory manager 623 * - perform recovery and init the log manager 624 */ 625 int 626 xfs_mountfs( 627 vfs_t *vfsp, 628 xfs_mount_t *mp, 629 int mfsi_flags) 630 { 631 xfs_buf_t *bp; 632 xfs_sb_t *sbp = &(mp->m_sb); 633 xfs_inode_t *rip; 634 vnode_t *rvp = NULL; 635 int readio_log, writeio_log; 636 xfs_daddr_t d; 637 __uint64_t ret64; 638 __int64_t update_flags; 639 uint quotamount, quotaflags; 640 int agno; 641 int uuid_mounted = 0; 642 int error = 0; 643 644 if (mp->m_sb_bp == NULL) { 645 if ((error = xfs_readsb(mp))) { 646 return (error); 647 } 648 } 649 xfs_mount_common(mp, sbp); 650 651 /* 652 * Check if sb_agblocks is aligned at stripe boundary 653 * If sb_agblocks is NOT aligned turn off m_dalign since 654 * allocator alignment is within an ag, therefore ag has 655 * to be aligned at stripe boundary. 656 */ 657 update_flags = 0LL; 658 if (mp->m_dalign && !(mfsi_flags & XFS_MFSI_SECOND)) { 659 /* 660 * If stripe unit and stripe width are not multiples 661 * of the fs blocksize turn off alignment. 662 */ 663 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) || 664 (BBTOB(mp->m_swidth) & mp->m_blockmask)) { 665 if (mp->m_flags & XFS_MOUNT_RETERR) { 666 cmn_err(CE_WARN, 667 "XFS: alignment check 1 failed"); 668 error = XFS_ERROR(EINVAL); 669 goto error1; 670 } 671 mp->m_dalign = mp->m_swidth = 0; 672 } else { 673 /* 674 * Convert the stripe unit and width to FSBs. 675 */ 676 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign); 677 if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) { 678 if (mp->m_flags & XFS_MOUNT_RETERR) { 679 error = XFS_ERROR(EINVAL); 680 goto error1; 681 } 682 xfs_fs_cmn_err(CE_WARN, mp, 683 "stripe alignment turned off: sunit(%d)/swidth(%d) incompatible with agsize(%d)", 684 mp->m_dalign, mp->m_swidth, 685 sbp->sb_agblocks); 686 687 mp->m_dalign = 0; 688 mp->m_swidth = 0; 689 } else if (mp->m_dalign) { 690 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth); 691 } else { 692 if (mp->m_flags & XFS_MOUNT_RETERR) { 693 xfs_fs_cmn_err(CE_WARN, mp, 694 "stripe alignment turned off: sunit(%d) less than bsize(%d)", 695 mp->m_dalign, 696 mp->m_blockmask +1); 697 error = XFS_ERROR(EINVAL); 698 goto error1; 699 } 700 mp->m_swidth = 0; 701 } 702 } 703 704 /* 705 * Update superblock with new values 706 * and log changes 707 */ 708 if (XFS_SB_VERSION_HASDALIGN(sbp)) { 709 if (sbp->sb_unit != mp->m_dalign) { 710 sbp->sb_unit = mp->m_dalign; 711 update_flags |= XFS_SB_UNIT; 712 } 713 if (sbp->sb_width != mp->m_swidth) { 714 sbp->sb_width = mp->m_swidth; 715 update_flags |= XFS_SB_WIDTH; 716 } 717 } 718 } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN && 719 XFS_SB_VERSION_HASDALIGN(&mp->m_sb)) { 720 mp->m_dalign = sbp->sb_unit; 721 mp->m_swidth = sbp->sb_width; 722 } 723 724 xfs_alloc_compute_maxlevels(mp); 725 xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK); 726 xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK); 727 xfs_ialloc_compute_maxlevels(mp); 728 729 if (sbp->sb_imax_pct) { 730 __uint64_t icount; 731 732 /* Make sure the maximum inode count is a multiple of the 733 * units we allocate inodes in. 734 */ 735 736 icount = sbp->sb_dblocks * sbp->sb_imax_pct; 737 do_div(icount, 100); 738 do_div(icount, mp->m_ialloc_blks); 739 mp->m_maxicount = (icount * mp->m_ialloc_blks) << 740 sbp->sb_inopblog; 741 } else 742 mp->m_maxicount = 0; 743 744 mp->m_maxioffset = xfs_max_file_offset(sbp->sb_blocklog); 745 746 /* 747 * XFS uses the uuid from the superblock as the unique 748 * identifier for fsid. We can not use the uuid from the volume 749 * since a single partition filesystem is identical to a single 750 * partition volume/filesystem. 751 */ 752 if ((mfsi_flags & XFS_MFSI_SECOND) == 0 && 753 (mp->m_flags & XFS_MOUNT_NOUUID) == 0) { 754 if (xfs_uuid_mount(mp)) { 755 error = XFS_ERROR(EINVAL); 756 goto error1; 757 } 758 uuid_mounted=1; 759 ret64 = uuid_hash64(&sbp->sb_uuid); 760 memcpy(&vfsp->vfs_fsid, &ret64, sizeof(ret64)); 761 } 762 763 /* 764 * Set the default minimum read and write sizes unless 765 * already specified in a mount option. 766 * We use smaller I/O sizes when the file system 767 * is being used for NFS service (wsync mount option). 768 */ 769 if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) { 770 if (mp->m_flags & XFS_MOUNT_WSYNC) { 771 readio_log = XFS_WSYNC_READIO_LOG; 772 writeio_log = XFS_WSYNC_WRITEIO_LOG; 773 } else { 774 readio_log = XFS_READIO_LOG_LARGE; 775 writeio_log = XFS_WRITEIO_LOG_LARGE; 776 } 777 } else { 778 readio_log = mp->m_readio_log; 779 writeio_log = mp->m_writeio_log; 780 } 781 782 /* 783 * Set the number of readahead buffers to use based on 784 * physical memory size. 785 */ 786 if (xfs_physmem <= 4096) /* <= 16MB */ 787 mp->m_nreadaheads = XFS_RW_NREADAHEAD_16MB; 788 else if (xfs_physmem <= 8192) /* <= 32MB */ 789 mp->m_nreadaheads = XFS_RW_NREADAHEAD_32MB; 790 else 791 mp->m_nreadaheads = XFS_RW_NREADAHEAD_K32; 792 if (sbp->sb_blocklog > readio_log) { 793 mp->m_readio_log = sbp->sb_blocklog; 794 } else { 795 mp->m_readio_log = readio_log; 796 } 797 mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog); 798 if (sbp->sb_blocklog > writeio_log) { 799 mp->m_writeio_log = sbp->sb_blocklog; 800 } else { 801 mp->m_writeio_log = writeio_log; 802 } 803 mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog); 804 805 /* 806 * Set the inode cluster size based on the physical memory 807 * size. This may still be overridden by the file system 808 * block size if it is larger than the chosen cluster size. 809 */ 810 if (xfs_physmem <= btoc(32 * 1024 * 1024)) { /* <= 32 MB */ 811 mp->m_inode_cluster_size = XFS_INODE_SMALL_CLUSTER_SIZE; 812 } else { 813 mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE; 814 } 815 /* 816 * Set whether we're using inode alignment. 817 */ 818 if (XFS_SB_VERSION_HASALIGN(&mp->m_sb) && 819 mp->m_sb.sb_inoalignmt >= 820 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) 821 mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1; 822 else 823 mp->m_inoalign_mask = 0; 824 /* 825 * If we are using stripe alignment, check whether 826 * the stripe unit is a multiple of the inode alignment 827 */ 828 if (mp->m_dalign && mp->m_inoalign_mask && 829 !(mp->m_dalign & mp->m_inoalign_mask)) 830 mp->m_sinoalign = mp->m_dalign; 831 else 832 mp->m_sinoalign = 0; 833 /* 834 * Check that the data (and log if separate) are an ok size. 835 */ 836 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks); 837 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) { 838 cmn_err(CE_WARN, "XFS: size check 1 failed"); 839 error = XFS_ERROR(E2BIG); 840 goto error1; 841 } 842 error = xfs_read_buf(mp, mp->m_ddev_targp, 843 d - XFS_FSS_TO_BB(mp, 1), 844 XFS_FSS_TO_BB(mp, 1), 0, &bp); 845 if (!error) { 846 xfs_buf_relse(bp); 847 } else { 848 cmn_err(CE_WARN, "XFS: size check 2 failed"); 849 if (error == ENOSPC) { 850 error = XFS_ERROR(E2BIG); 851 } 852 goto error1; 853 } 854 855 if (((mfsi_flags & XFS_MFSI_CLIENT) == 0) && 856 mp->m_logdev_targp != mp->m_ddev_targp) { 857 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks); 858 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) { 859 cmn_err(CE_WARN, "XFS: size check 3 failed"); 860 error = XFS_ERROR(E2BIG); 861 goto error1; 862 } 863 error = xfs_read_buf(mp, mp->m_logdev_targp, 864 d - XFS_FSB_TO_BB(mp, 1), 865 XFS_FSB_TO_BB(mp, 1), 0, &bp); 866 if (!error) { 867 xfs_buf_relse(bp); 868 } else { 869 cmn_err(CE_WARN, "XFS: size check 3 failed"); 870 if (error == ENOSPC) { 871 error = XFS_ERROR(E2BIG); 872 } 873 goto error1; 874 } 875 } 876 877 /* 878 * Initialize realtime fields in the mount structure 879 */ 880 if ((error = xfs_rtmount_init(mp))) { 881 cmn_err(CE_WARN, "XFS: RT mount failed"); 882 goto error1; 883 } 884 885 /* 886 * For client case we are done now 887 */ 888 if (mfsi_flags & XFS_MFSI_CLIENT) { 889 return(0); 890 } 891 892 /* 893 * Copies the low order bits of the timestamp and the randomly 894 * set "sequence" number out of a UUID. 895 */ 896 uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid); 897 898 /* 899 * The vfs structure needs to have a file system independent 900 * way of checking for the invariant file system ID. Since it 901 * can't look at mount structures it has a pointer to the data 902 * in the mount structure. 903 * 904 * File systems that don't support user level file handles (i.e. 905 * all of them except for XFS) will leave vfs_altfsid as NULL. 906 */ 907 vfsp->vfs_altfsid = (xfs_fsid_t *)mp->m_fixedfsid; 908 mp->m_dmevmask = 0; /* not persistent; set after each mount */ 909 910 /* 911 * Select the right directory manager. 912 */ 913 mp->m_dirops = 914 XFS_SB_VERSION_HASDIRV2(&mp->m_sb) ? 915 xfsv2_dirops : 916 xfsv1_dirops; 917 918 /* 919 * Initialize directory manager's entries. 920 */ 921 XFS_DIR_MOUNT(mp); 922 923 /* 924 * Initialize the attribute manager's entries. 925 */ 926 mp->m_attr_magicpct = (mp->m_sb.sb_blocksize * 37) / 100; 927 928 /* 929 * Initialize the precomputed transaction reservations values. 930 */ 931 xfs_trans_init(mp); 932 933 /* 934 * Allocate and initialize the inode hash table for this 935 * file system. 936 */ 937 xfs_ihash_init(mp); 938 xfs_chash_init(mp); 939 940 /* 941 * Allocate and initialize the per-ag data. 942 */ 943 init_rwsem(&mp->m_peraglock); 944 mp->m_perag = 945 kmem_zalloc(sbp->sb_agcount * sizeof(xfs_perag_t), KM_SLEEP); 946 947 mp->m_maxagi = xfs_initialize_perag(mp, sbp->sb_agcount); 948 949 /* 950 * log's mount-time initialization. Perform 1st part recovery if needed 951 */ 952 if (likely(sbp->sb_logblocks > 0)) { /* check for volume case */ 953 error = xfs_log_mount(mp, mp->m_logdev_targp, 954 XFS_FSB_TO_DADDR(mp, sbp->sb_logstart), 955 XFS_FSB_TO_BB(mp, sbp->sb_logblocks)); 956 if (error) { 957 cmn_err(CE_WARN, "XFS: log mount failed"); 958 goto error2; 959 } 960 } else { /* No log has been defined */ 961 cmn_err(CE_WARN, "XFS: no log defined"); 962 XFS_ERROR_REPORT("xfs_mountfs_int(1)", XFS_ERRLEVEL_LOW, mp); 963 error = XFS_ERROR(EFSCORRUPTED); 964 goto error2; 965 } 966 967 /* 968 * Get and sanity-check the root inode. 969 * Save the pointer to it in the mount structure. 970 */ 971 error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip, 0); 972 if (error) { 973 cmn_err(CE_WARN, "XFS: failed to read root inode"); 974 goto error3; 975 } 976 977 ASSERT(rip != NULL); 978 rvp = XFS_ITOV(rip); 979 980 if (unlikely((rip->i_d.di_mode & S_IFMT) != S_IFDIR)) { 981 cmn_err(CE_WARN, "XFS: corrupted root inode"); 982 prdev("Root inode %llu is not a directory", 983 mp->m_ddev_targp, (unsigned long long)rip->i_ino); 984 xfs_iunlock(rip, XFS_ILOCK_EXCL); 985 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW, 986 mp); 987 error = XFS_ERROR(EFSCORRUPTED); 988 goto error4; 989 } 990 mp->m_rootip = rip; /* save it */ 991 992 xfs_iunlock(rip, XFS_ILOCK_EXCL); 993 994 /* 995 * Initialize realtime inode pointers in the mount structure 996 */ 997 if ((error = xfs_rtmount_inodes(mp))) { 998 /* 999 * Free up the root inode. 1000 */ 1001 cmn_err(CE_WARN, "XFS: failed to read RT inodes"); 1002 goto error4; 1003 } 1004 1005 /* 1006 * If fs is not mounted readonly, then update the superblock 1007 * unit and width changes. 1008 */ 1009 if (update_flags && !(vfsp->vfs_flag & VFS_RDONLY)) 1010 xfs_mount_log_sbunit(mp, update_flags); 1011 1012 /* 1013 * Initialise the XFS quota management subsystem for this mount 1014 */ 1015 if ((error = XFS_QM_INIT(mp, "amount, "aflags))) 1016 goto error4; 1017 1018 /* 1019 * Finish recovering the file system. This part needed to be 1020 * delayed until after the root and real-time bitmap inodes 1021 * were consistently read in. 1022 */ 1023 error = xfs_log_mount_finish(mp, mfsi_flags); 1024 if (error) { 1025 cmn_err(CE_WARN, "XFS: log mount finish failed"); 1026 goto error4; 1027 } 1028 1029 /* 1030 * Complete the quota initialisation, post-log-replay component. 1031 */ 1032 if ((error = XFS_QM_MOUNT(mp, quotamount, quotaflags, mfsi_flags))) 1033 goto error4; 1034 1035 return 0; 1036 1037 error4: 1038 /* 1039 * Free up the root inode. 1040 */ 1041 VN_RELE(rvp); 1042 error3: 1043 xfs_log_unmount_dealloc(mp); 1044 error2: 1045 xfs_ihash_free(mp); 1046 xfs_chash_free(mp); 1047 for (agno = 0; agno < sbp->sb_agcount; agno++) 1048 if (mp->m_perag[agno].pagb_list) 1049 kmem_free(mp->m_perag[agno].pagb_list, 1050 sizeof(xfs_perag_busy_t) * XFS_PAGB_NUM_SLOTS); 1051 kmem_free(mp->m_perag, sbp->sb_agcount * sizeof(xfs_perag_t)); 1052 mp->m_perag = NULL; 1053 /* FALLTHROUGH */ 1054 error1: 1055 if (uuid_mounted) 1056 xfs_uuid_unmount(mp); 1057 xfs_freesb(mp); 1058 return error; 1059 } 1060 1061 /* 1062 * xfs_unmountfs 1063 * 1064 * This flushes out the inodes,dquots and the superblock, unmounts the 1065 * log and makes sure that incore structures are freed. 1066 */ 1067 int 1068 xfs_unmountfs(xfs_mount_t *mp, struct cred *cr) 1069 { 1070 struct vfs *vfsp = XFS_MTOVFS(mp); 1071 #if defined(DEBUG) || defined(INDUCE_IO_ERROR) 1072 int64_t fsid; 1073 #endif 1074 1075 xfs_iflush_all(mp, XFS_FLUSH_ALL); 1076 1077 XFS_QM_DQPURGEALL(mp, 1078 XFS_QMOPT_UQUOTA | XFS_QMOPT_GQUOTA | XFS_QMOPT_UMOUNTING); 1079 1080 /* 1081 * Flush out the log synchronously so that we know for sure 1082 * that nothing is pinned. This is important because bflush() 1083 * will skip pinned buffers. 1084 */ 1085 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE | XFS_LOG_SYNC); 1086 1087 xfs_binval(mp->m_ddev_targp); 1088 if (mp->m_rtdev_targp) { 1089 xfs_binval(mp->m_rtdev_targp); 1090 } 1091 1092 xfs_unmountfs_writesb(mp); 1093 1094 xfs_unmountfs_wait(mp); /* wait for async bufs */ 1095 1096 xfs_log_unmount(mp); /* Done! No more fs ops. */ 1097 1098 xfs_freesb(mp); 1099 1100 /* 1101 * All inodes from this mount point should be freed. 1102 */ 1103 ASSERT(mp->m_inodes == NULL); 1104 1105 /* 1106 * We may have bufs that are in the process of getting written still. 1107 * We must wait for the I/O completion of those. The sync flag here 1108 * does a two pass iteration thru the bufcache. 1109 */ 1110 if (XFS_FORCED_SHUTDOWN(mp)) { 1111 xfs_incore_relse(mp->m_ddev_targp, 0, 1); /* synchronous */ 1112 } 1113 1114 xfs_unmountfs_close(mp, cr); 1115 if ((mp->m_flags & XFS_MOUNT_NOUUID) == 0) 1116 xfs_uuid_unmount(mp); 1117 1118 #if defined(DEBUG) || defined(INDUCE_IO_ERROR) 1119 /* 1120 * clear all error tags on this filesystem 1121 */ 1122 memcpy(&fsid, &vfsp->vfs_fsid, sizeof(int64_t)); 1123 xfs_errortag_clearall_umount(fsid, mp->m_fsname, 0); 1124 #endif 1125 XFS_IODONE(vfsp); 1126 xfs_mount_free(mp, 1); 1127 return 0; 1128 } 1129 1130 void 1131 xfs_unmountfs_close(xfs_mount_t *mp, struct cred *cr) 1132 { 1133 if (mp->m_logdev_targp != mp->m_ddev_targp) 1134 xfs_free_buftarg(mp->m_logdev_targp, 1); 1135 if (mp->m_rtdev_targp) 1136 xfs_free_buftarg(mp->m_rtdev_targp, 1); 1137 xfs_free_buftarg(mp->m_ddev_targp, 0); 1138 } 1139 1140 void 1141 xfs_unmountfs_wait(xfs_mount_t *mp) 1142 { 1143 if (mp->m_logdev_targp != mp->m_ddev_targp) 1144 xfs_wait_buftarg(mp->m_logdev_targp); 1145 if (mp->m_rtdev_targp) 1146 xfs_wait_buftarg(mp->m_rtdev_targp); 1147 xfs_wait_buftarg(mp->m_ddev_targp); 1148 } 1149 1150 int 1151 xfs_unmountfs_writesb(xfs_mount_t *mp) 1152 { 1153 xfs_buf_t *sbp; 1154 xfs_sb_t *sb; 1155 int error = 0; 1156 1157 /* 1158 * skip superblock write if fs is read-only, or 1159 * if we are doing a forced umount. 1160 */ 1161 sbp = xfs_getsb(mp, 0); 1162 if (!(XFS_MTOVFS(mp)->vfs_flag & VFS_RDONLY || 1163 XFS_FORCED_SHUTDOWN(mp))) { 1164 /* 1165 * mark shared-readonly if desired 1166 */ 1167 sb = XFS_BUF_TO_SBP(sbp); 1168 if (mp->m_mk_sharedro) { 1169 if (!(sb->sb_flags & XFS_SBF_READONLY)) 1170 sb->sb_flags |= XFS_SBF_READONLY; 1171 if (!XFS_SB_VERSION_HASSHARED(sb)) 1172 XFS_SB_VERSION_ADDSHARED(sb); 1173 xfs_fs_cmn_err(CE_NOTE, mp, 1174 "Unmounting, marking shared read-only"); 1175 } 1176 XFS_BUF_UNDONE(sbp); 1177 XFS_BUF_UNREAD(sbp); 1178 XFS_BUF_UNDELAYWRITE(sbp); 1179 XFS_BUF_WRITE(sbp); 1180 XFS_BUF_UNASYNC(sbp); 1181 ASSERT(XFS_BUF_TARGET(sbp) == mp->m_ddev_targp); 1182 xfsbdstrat(mp, sbp); 1183 /* Nevermind errors we might get here. */ 1184 error = xfs_iowait(sbp); 1185 if (error) 1186 xfs_ioerror_alert("xfs_unmountfs_writesb", 1187 mp, sbp, XFS_BUF_ADDR(sbp)); 1188 if (error && mp->m_mk_sharedro) 1189 xfs_fs_cmn_err(CE_ALERT, mp, "Superblock write error detected while unmounting. Filesystem may not be marked shared readonly"); 1190 } 1191 xfs_buf_relse(sbp); 1192 return (error); 1193 } 1194 1195 /* 1196 * xfs_mod_sb() can be used to copy arbitrary changes to the 1197 * in-core superblock into the superblock buffer to be logged. 1198 * It does not provide the higher level of locking that is 1199 * needed to protect the in-core superblock from concurrent 1200 * access. 1201 */ 1202 void 1203 xfs_mod_sb(xfs_trans_t *tp, __int64_t fields) 1204 { 1205 xfs_buf_t *bp; 1206 int first; 1207 int last; 1208 xfs_mount_t *mp; 1209 xfs_sb_t *sbp; 1210 xfs_sb_field_t f; 1211 1212 ASSERT(fields); 1213 if (!fields) 1214 return; 1215 mp = tp->t_mountp; 1216 bp = xfs_trans_getsb(tp, mp, 0); 1217 sbp = XFS_BUF_TO_SBP(bp); 1218 first = sizeof(xfs_sb_t); 1219 last = 0; 1220 1221 /* translate/copy */ 1222 1223 xfs_xlatesb(XFS_BUF_PTR(bp), &(mp->m_sb), -1, fields); 1224 1225 /* find modified range */ 1226 1227 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields); 1228 ASSERT((1LL << f) & XFS_SB_MOD_BITS); 1229 first = xfs_sb_info[f].offset; 1230 1231 f = (xfs_sb_field_t)xfs_highbit64((__uint64_t)fields); 1232 ASSERT((1LL << f) & XFS_SB_MOD_BITS); 1233 last = xfs_sb_info[f + 1].offset - 1; 1234 1235 xfs_trans_log_buf(tp, bp, first, last); 1236 } 1237 1238 /* 1239 * xfs_mod_incore_sb_unlocked() is a utility routine common used to apply 1240 * a delta to a specified field in the in-core superblock. Simply 1241 * switch on the field indicated and apply the delta to that field. 1242 * Fields are not allowed to dip below zero, so if the delta would 1243 * do this do not apply it and return EINVAL. 1244 * 1245 * The SB_LOCK must be held when this routine is called. 1246 */ 1247 STATIC int 1248 xfs_mod_incore_sb_unlocked(xfs_mount_t *mp, xfs_sb_field_t field, 1249 int delta, int rsvd) 1250 { 1251 int scounter; /* short counter for 32 bit fields */ 1252 long long lcounter; /* long counter for 64 bit fields */ 1253 long long res_used, rem; 1254 1255 /* 1256 * With the in-core superblock spin lock held, switch 1257 * on the indicated field. Apply the delta to the 1258 * proper field. If the fields value would dip below 1259 * 0, then do not apply the delta and return EINVAL. 1260 */ 1261 switch (field) { 1262 case XFS_SBS_ICOUNT: 1263 lcounter = (long long)mp->m_sb.sb_icount; 1264 lcounter += delta; 1265 if (lcounter < 0) { 1266 ASSERT(0); 1267 return (XFS_ERROR(EINVAL)); 1268 } 1269 mp->m_sb.sb_icount = lcounter; 1270 return (0); 1271 case XFS_SBS_IFREE: 1272 lcounter = (long long)mp->m_sb.sb_ifree; 1273 lcounter += delta; 1274 if (lcounter < 0) { 1275 ASSERT(0); 1276 return (XFS_ERROR(EINVAL)); 1277 } 1278 mp->m_sb.sb_ifree = lcounter; 1279 return (0); 1280 case XFS_SBS_FDBLOCKS: 1281 1282 lcounter = (long long)mp->m_sb.sb_fdblocks; 1283 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail); 1284 1285 if (delta > 0) { /* Putting blocks back */ 1286 if (res_used > delta) { 1287 mp->m_resblks_avail += delta; 1288 } else { 1289 rem = delta - res_used; 1290 mp->m_resblks_avail = mp->m_resblks; 1291 lcounter += rem; 1292 } 1293 } else { /* Taking blocks away */ 1294 1295 lcounter += delta; 1296 1297 /* 1298 * If were out of blocks, use any available reserved blocks if 1299 * were allowed to. 1300 */ 1301 1302 if (lcounter < 0) { 1303 if (rsvd) { 1304 lcounter = (long long)mp->m_resblks_avail + delta; 1305 if (lcounter < 0) { 1306 return (XFS_ERROR(ENOSPC)); 1307 } 1308 mp->m_resblks_avail = lcounter; 1309 return (0); 1310 } else { /* not reserved */ 1311 return (XFS_ERROR(ENOSPC)); 1312 } 1313 } 1314 } 1315 1316 mp->m_sb.sb_fdblocks = lcounter; 1317 return (0); 1318 case XFS_SBS_FREXTENTS: 1319 lcounter = (long long)mp->m_sb.sb_frextents; 1320 lcounter += delta; 1321 if (lcounter < 0) { 1322 return (XFS_ERROR(ENOSPC)); 1323 } 1324 mp->m_sb.sb_frextents = lcounter; 1325 return (0); 1326 case XFS_SBS_DBLOCKS: 1327 lcounter = (long long)mp->m_sb.sb_dblocks; 1328 lcounter += delta; 1329 if (lcounter < 0) { 1330 ASSERT(0); 1331 return (XFS_ERROR(EINVAL)); 1332 } 1333 mp->m_sb.sb_dblocks = lcounter; 1334 return (0); 1335 case XFS_SBS_AGCOUNT: 1336 scounter = mp->m_sb.sb_agcount; 1337 scounter += delta; 1338 if (scounter < 0) { 1339 ASSERT(0); 1340 return (XFS_ERROR(EINVAL)); 1341 } 1342 mp->m_sb.sb_agcount = scounter; 1343 return (0); 1344 case XFS_SBS_IMAX_PCT: 1345 scounter = mp->m_sb.sb_imax_pct; 1346 scounter += delta; 1347 if (scounter < 0) { 1348 ASSERT(0); 1349 return (XFS_ERROR(EINVAL)); 1350 } 1351 mp->m_sb.sb_imax_pct = scounter; 1352 return (0); 1353 case XFS_SBS_REXTSIZE: 1354 scounter = mp->m_sb.sb_rextsize; 1355 scounter += delta; 1356 if (scounter < 0) { 1357 ASSERT(0); 1358 return (XFS_ERROR(EINVAL)); 1359 } 1360 mp->m_sb.sb_rextsize = scounter; 1361 return (0); 1362 case XFS_SBS_RBMBLOCKS: 1363 scounter = mp->m_sb.sb_rbmblocks; 1364 scounter += delta; 1365 if (scounter < 0) { 1366 ASSERT(0); 1367 return (XFS_ERROR(EINVAL)); 1368 } 1369 mp->m_sb.sb_rbmblocks = scounter; 1370 return (0); 1371 case XFS_SBS_RBLOCKS: 1372 lcounter = (long long)mp->m_sb.sb_rblocks; 1373 lcounter += delta; 1374 if (lcounter < 0) { 1375 ASSERT(0); 1376 return (XFS_ERROR(EINVAL)); 1377 } 1378 mp->m_sb.sb_rblocks = lcounter; 1379 return (0); 1380 case XFS_SBS_REXTENTS: 1381 lcounter = (long long)mp->m_sb.sb_rextents; 1382 lcounter += delta; 1383 if (lcounter < 0) { 1384 ASSERT(0); 1385 return (XFS_ERROR(EINVAL)); 1386 } 1387 mp->m_sb.sb_rextents = lcounter; 1388 return (0); 1389 case XFS_SBS_REXTSLOG: 1390 scounter = mp->m_sb.sb_rextslog; 1391 scounter += delta; 1392 if (scounter < 0) { 1393 ASSERT(0); 1394 return (XFS_ERROR(EINVAL)); 1395 } 1396 mp->m_sb.sb_rextslog = scounter; 1397 return (0); 1398 default: 1399 ASSERT(0); 1400 return (XFS_ERROR(EINVAL)); 1401 } 1402 } 1403 1404 /* 1405 * xfs_mod_incore_sb() is used to change a field in the in-core 1406 * superblock structure by the specified delta. This modification 1407 * is protected by the SB_LOCK. Just use the xfs_mod_incore_sb_unlocked() 1408 * routine to do the work. 1409 */ 1410 int 1411 xfs_mod_incore_sb(xfs_mount_t *mp, xfs_sb_field_t field, int delta, int rsvd) 1412 { 1413 unsigned long s; 1414 int status; 1415 1416 s = XFS_SB_LOCK(mp); 1417 status = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd); 1418 XFS_SB_UNLOCK(mp, s); 1419 return (status); 1420 } 1421 1422 /* 1423 * xfs_mod_incore_sb_batch() is used to change more than one field 1424 * in the in-core superblock structure at a time. This modification 1425 * is protected by a lock internal to this module. The fields and 1426 * changes to those fields are specified in the array of xfs_mod_sb 1427 * structures passed in. 1428 * 1429 * Either all of the specified deltas will be applied or none of 1430 * them will. If any modified field dips below 0, then all modifications 1431 * will be backed out and EINVAL will be returned. 1432 */ 1433 int 1434 xfs_mod_incore_sb_batch(xfs_mount_t *mp, xfs_mod_sb_t *msb, uint nmsb, int rsvd) 1435 { 1436 unsigned long s; 1437 int status=0; 1438 xfs_mod_sb_t *msbp; 1439 1440 /* 1441 * Loop through the array of mod structures and apply each 1442 * individually. If any fail, then back out all those 1443 * which have already been applied. Do all of this within 1444 * the scope of the SB_LOCK so that all of the changes will 1445 * be atomic. 1446 */ 1447 s = XFS_SB_LOCK(mp); 1448 msbp = &msb[0]; 1449 for (msbp = &msbp[0]; msbp < (msb + nmsb); msbp++) { 1450 /* 1451 * Apply the delta at index n. If it fails, break 1452 * from the loop so we'll fall into the undo loop 1453 * below. 1454 */ 1455 status = xfs_mod_incore_sb_unlocked(mp, msbp->msb_field, 1456 msbp->msb_delta, rsvd); 1457 if (status != 0) { 1458 break; 1459 } 1460 } 1461 1462 /* 1463 * If we didn't complete the loop above, then back out 1464 * any changes made to the superblock. If you add code 1465 * between the loop above and here, make sure that you 1466 * preserve the value of status. Loop back until 1467 * we step below the beginning of the array. Make sure 1468 * we don't touch anything back there. 1469 */ 1470 if (status != 0) { 1471 msbp--; 1472 while (msbp >= msb) { 1473 status = xfs_mod_incore_sb_unlocked(mp, 1474 msbp->msb_field, -(msbp->msb_delta), rsvd); 1475 ASSERT(status == 0); 1476 msbp--; 1477 } 1478 } 1479 XFS_SB_UNLOCK(mp, s); 1480 return (status); 1481 } 1482 1483 /* 1484 * xfs_getsb() is called to obtain the buffer for the superblock. 1485 * The buffer is returned locked and read in from disk. 1486 * The buffer should be released with a call to xfs_brelse(). 1487 * 1488 * If the flags parameter is BUF_TRYLOCK, then we'll only return 1489 * the superblock buffer if it can be locked without sleeping. 1490 * If it can't then we'll return NULL. 1491 */ 1492 xfs_buf_t * 1493 xfs_getsb( 1494 xfs_mount_t *mp, 1495 int flags) 1496 { 1497 xfs_buf_t *bp; 1498 1499 ASSERT(mp->m_sb_bp != NULL); 1500 bp = mp->m_sb_bp; 1501 if (flags & XFS_BUF_TRYLOCK) { 1502 if (!XFS_BUF_CPSEMA(bp)) { 1503 return NULL; 1504 } 1505 } else { 1506 XFS_BUF_PSEMA(bp, PRIBIO); 1507 } 1508 XFS_BUF_HOLD(bp); 1509 ASSERT(XFS_BUF_ISDONE(bp)); 1510 return (bp); 1511 } 1512 1513 /* 1514 * Used to free the superblock along various error paths. 1515 */ 1516 void 1517 xfs_freesb( 1518 xfs_mount_t *mp) 1519 { 1520 xfs_buf_t *bp; 1521 1522 /* 1523 * Use xfs_getsb() so that the buffer will be locked 1524 * when we call xfs_buf_relse(). 1525 */ 1526 bp = xfs_getsb(mp, 0); 1527 XFS_BUF_UNMANAGE(bp); 1528 xfs_buf_relse(bp); 1529 mp->m_sb_bp = NULL; 1530 } 1531 1532 /* 1533 * See if the UUID is unique among mounted XFS filesystems. 1534 * Mount fails if UUID is nil or a FS with the same UUID is already mounted. 1535 */ 1536 STATIC int 1537 xfs_uuid_mount( 1538 xfs_mount_t *mp) 1539 { 1540 if (uuid_is_nil(&mp->m_sb.sb_uuid)) { 1541 cmn_err(CE_WARN, 1542 "XFS: Filesystem %s has nil UUID - can't mount", 1543 mp->m_fsname); 1544 return -1; 1545 } 1546 if (!uuid_table_insert(&mp->m_sb.sb_uuid)) { 1547 cmn_err(CE_WARN, 1548 "XFS: Filesystem %s has duplicate UUID - can't mount", 1549 mp->m_fsname); 1550 return -1; 1551 } 1552 return 0; 1553 } 1554 1555 /* 1556 * Remove filesystem from the UUID table. 1557 */ 1558 STATIC void 1559 xfs_uuid_unmount( 1560 xfs_mount_t *mp) 1561 { 1562 uuid_table_remove(&mp->m_sb.sb_uuid); 1563 } 1564 1565 /* 1566 * Used to log changes to the superblock unit and width fields which could 1567 * be altered by the mount options. Only the first superblock is updated. 1568 */ 1569 STATIC void 1570 xfs_mount_log_sbunit( 1571 xfs_mount_t *mp, 1572 __int64_t fields) 1573 { 1574 xfs_trans_t *tp; 1575 1576 ASSERT(fields & (XFS_SB_UNIT|XFS_SB_WIDTH|XFS_SB_UUID)); 1577 1578 tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT); 1579 if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0, 1580 XFS_DEFAULT_LOG_COUNT)) { 1581 xfs_trans_cancel(tp, 0); 1582 return; 1583 } 1584 xfs_mod_sb(tp, fields); 1585 xfs_trans_commit(tp, 0, NULL); 1586 } 1587