Lines Matching defs:sblock
442 #define sblock fsun.fs
1326 * only fill in sblock fields so we can use MAXIpG.
1340 sblock.fs_bsize = bsize;
1341 sblock.fs_inopb = sblock.fs_bsize / sizeof (struct dinode);
1345 howmany(MAXIpG(&sblock), NBBY)) /
1519 * Note: it's ok to use sblock as a buffer because it is immediately
1528 rdfs(fssize_db - 1, (int)sectorsize, (char *)&sblock);
1533 rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock);
1534 sblock.fs_magic = -1;
1535 sblock.fs_clean = FSBAD;
1536 sblock.fs_state = FSOKAY - sblock.fs_time;
1537 wtfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock);
1538 bzero(&sblock, (size_t)sbsize);
1540 sblock.fs_nsect = nsect;
1541 sblock.fs_ntrak = ntrack;
1551 sblock.fs_spc = sblock.fs_ntrak * sblock.fs_nsect;
1555 sblock.fs_spc -= apc;
1561 if (sblock.fs_spc != sblock.fs_ntrak * sblock.fs_nsect) {
1567 sblock.fs_nrpos = nrpos;
1568 sblock.fs_bsize = bsize;
1569 sblock.fs_fsize = fragsize;
1570 sblock.fs_minfree = minfree;
1573 if (nbpi < sblock.fs_fsize) {
1578 nbpi, sblock.fs_fsize);
1584 sblock.fs_optim = FS_OPTSPACE;
1586 sblock.fs_optim = FS_OPTTIME;
1588 sblock.fs_bmask = ~(sblock.fs_bsize - 1);
1589 sblock.fs_fmask = ~(sblock.fs_fsize - 1);
1594 sblock.fs_qbmask.val[0] = 0;
1595 sblock.fs_qbmask.val[1] = ~sblock.fs_bmask;
1596 sblock.fs_qfmask.val[0] = 0;
1597 sblock.fs_qfmask.val[1] = ~sblock.fs_fmask;
1600 sblock.fs_qbmask.val[0] = ~sblock.fs_bmask;
1601 sblock.fs_qbmask.val[1] = 0;
1602 sblock.fs_qfmask.val[0] = ~sblock.fs_fmask;
1603 sblock.fs_qfmask.val[1] = 0;
1605 for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1)
1606 sblock.fs_bshift++;
1607 for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1)
1608 sblock.fs_fshift++;
1609 sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);
1610 for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1)
1611 sblock.fs_fragshift++;
1612 if (sblock.fs_frag > MAXFRAG) {
1615 sblock.fs_fsize, sblock.fs_bsize,
1616 sblock.fs_bsize / MAXFRAG);
1619 sblock.fs_nindir = sblock.fs_bsize / sizeof (daddr32_t);
1620 sblock.fs_inopb = sblock.fs_bsize / sizeof (struct dinode);
1621 sblock.fs_nspf = sblock.fs_fsize / sectorsize;
1622 for (sblock.fs_fsbtodb = 0, i = NSPF(&sblock); i > 1; i >>= 1)
1623 sblock.fs_fsbtodb++;
1633 sblock.fs_sblkno =
1634 roundup(howmany(bbsize + sbsize, sblock.fs_fsize), sblock.fs_frag);
1635 sblock.fs_cblkno = (daddr32_t)(sblock.fs_sblkno +
1636 roundup(howmany(sbsize, sblock.fs_fsize), sblock.fs_frag));
1637 sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;
1639 sblock.fs_cgoffset = roundup(
1640 howmany(sblock.fs_nsect, NSPF(&sblock)), sblock.fs_frag);
1641 for (sblock.fs_cgmask = -1, i = sblock.fs_ntrak; i > 1; i >>= 1)
1642 sblock.fs_cgmask <<= 1;
1643 if (!POWEROF2(sblock.fs_ntrak))
1644 sblock.fs_cgmask <<= 1;
1650 for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc;
1651 sblock.fs_cpc > 1 && (i & 1) == 0;
1652 sblock.fs_cpc >>= 1, i >>= 1)
1654 mincpc = sblock.fs_cpc;
1657 bpcg = (uint64_t)sblock.fs_spc * sectorsize;
1659 INOPB(&sblock));
1660 if (inospercg > MAXIpG(&sblock))
1661 inospercg = MAXIpG(&sblock);
1662 used = (uint64_t)(sblock.fs_iblkno + inospercg /
1663 INOPF(&sblock)) * NSPF(&sblock);
1664 mincpgcnt = (long)howmany((uint64_t)sblock.fs_cgoffset *
1665 (~sblock.fs_cgmask) + used, sblock.fs_spc);
1671 sblock.fs_cpg = mincpg;
1672 sblock.fs_ipg = (int32_t)inospercg;
1679 while (CGSIZE(&sblock) > sblock.fs_bsize) {
1681 if (sblock.fs_bsize < MAXBSIZE) {
1682 sblock.fs_bsize <<= 1;
1686 sblock.fs_cpc <<= 1;
1689 sblock.fs_cpg = mincpg;
1691 sblock.fs_frag <<= 1;
1692 sblock.fs_fragshift += 1;
1693 if (sblock.fs_frag <= MAXFRAG)
1701 if (sblock.fs_fsize == sblock.fs_bsize) {
1710 sblock.fs_frag >>= 1;
1711 sblock.fs_fragshift -= 1;
1712 sblock.fs_fsize <<= 1;
1713 sblock.fs_nspf <<= 1;
1721 inospercg = (uint64_t)roundup((nbytes64 / nbpi), INOPB(&sblock));
1722 sblock.fs_ipg = (int32_t)inospercg;
1723 while (inospercg > MAXIpG(&sblock)) {
1725 if (mincpc == 1 || sblock.fs_frag == 1 ||
1726 sblock.fs_bsize == MINBSIZE)
1731 sblock.fs_bsize, gettext("minimum bytes per inode is"),
1732 (uint32_t)(nbytes64 / MAXIpG(&sblock) + 1));
1733 sblock.fs_bsize >>= 1;
1734 sblock.fs_frag >>= 1;
1735 sblock.fs_fragshift -= 1;
1737 sblock.fs_cpg = roundup(mincpgcnt, mincpc);
1738 if (CGSIZE(&sblock) > sblock.fs_bsize) {
1739 sblock.fs_bsize <<= 1;
1742 mincpg = sblock.fs_cpg;
1745 INOPB(&sblock));
1746 sblock.fs_ipg = (int32_t)inospercg;
1749 if (inospercg > MAXIpG(&sblock)) {
1753 (uint32_t)(nbytes64 / MAXIpG(&sblock) + 1));
1764 sblock.fs_spc, mincpg);
1773 if ((sblock.fs_bsize != bsize) &&
1774 (sblock.fs_fsize != fragsize)) {
1778 bsize, sblock.fs_bsize,
1779 fragsize, sblock.fs_fsize);
1780 } else if (sblock.fs_bsize != bsize) {
1783 bsize, sblock.fs_bsize);
1784 } else if (sblock.fs_fsize != fragsize) {
1787 fragsize, sblock.fs_fsize);
1799 sblock.fs_cpg = cpg;
1800 if (sblock.fs_cpg % mincpc != 0) {
1805 sblock.fs_cpg = roundup(sblock.fs_cpg, mincpc);
1807 sblock.fs_cpg);
1813 nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used;
1814 sblock.fs_ipg = roundup((uint32_t)(nbytes64 / nbpi), INOPB(&sblock));
1819 while (sblock.fs_ipg > MAXIpG(&sblock)) {
1821 sblock.fs_cpg -= mincpc;
1822 nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used;
1823 sblock.fs_ipg = roundup((uint32_t)(nbytes64 / nbpi),
1824 INOPB(&sblock));
1831 while (CGSIZE(&sblock) > sblock.fs_bsize) {
1833 sblock.fs_cpg -= mincpc;
1834 nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used;
1835 sblock.fs_ipg = roundup((uint32_t)(nbytes64 / nbpi),
1836 INOPB(&sblock));
1838 sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
1839 if ((sblock.fs_cpg * sblock.fs_spc) % NSPB(&sblock) != 0) {
1844 if (sblock.fs_cpg < mincpg) {
1850 sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock));
1856 fssize_frag = (int64_t)dbtofsb(&sblock, fssize_db);
1863 sblock.fs_size = (int32_t)fssize_frag;
1864 sblock.fs_ncyl = (int32_t)(fssize_frag * NSPF(&sblock) / sblock.fs_spc);
1865 if (fssize_frag * NSPF(&sblock) >
1866 (uint64_t)sblock.fs_ncyl * sblock.fs_spc) {
1867 sblock.fs_ncyl++;
1870 if (sblock.fs_ncyl < 1) {
1889 sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
1890 sblock.fs_sbsize = fragroundup(&sblock, sizeof (struct fs));
1891 sblock.fs_npsect = sblock.fs_nsect;
1892 if (sblock.fs_ntrak == 1) {
1893 sblock.fs_cpc = 0;
1896 postblsize = sblock.fs_nrpos * sblock.fs_cpc * sizeof (short);
1897 rotblsize = sblock.fs_cpc * sblock.fs_spc / NSPB(&sblock);
1901 if (sblock.fs_nrpos == 8 && sblock.fs_cpc <= 16) {
1903 sblock.fs_postbloff = (char *)(&sblock.fs_opostbl[0][0]) -
1904 (char *)(&sblock.fs_link);
1905 sblock.fs_rotbloff = &sblock.fs_space[0] -
1906 (uchar_t *)(&sblock.fs_link);
1909 sblock.fs_postbloff = &sblock.fs_space[0] -
1910 (uchar_t *)(&sblock.fs_link);
1911 sblock.fs_rotbloff = sblock.fs_postbloff + postblsize;
1914 if (totalsbsize > sblock.fs_bsize ||
1915 sblock.fs_nsect > (1 << NBBY) * NSPB(&sblock)) {
1921 sblock.fs_nsect, sblock.fs_ntrak, sblock.fs_nrpos);
1928 sblock.fs_cpc = 0;
1931 sblock.fs_sbsize = fragroundup(&sblock, totalsbsize);
1937 for (cylno = 0; cylno < sblock.fs_cpc; cylno++)
1938 for (rpos = 0; rpos < sblock.fs_nrpos; rpos++)
1939 fs_postbl(&sblock, cylno)[rpos] = -1;
1940 for (i = (rotblsize - 1) * sblock.fs_frag;
1941 i >= 0; i -= sblock.fs_frag) {
1942 cylno = cbtocylno(&sblock, i);
1943 rpos = cbtorpos(&sblock, i);
1944 blk = fragstoblks(&sblock, i);
1945 if (fs_postbl(&sblock, cylno)[rpos] == -1)
1946 fs_rotbl(&sblock)[blk] = 0;
1948 fs_rotbl(&sblock)[blk] =
1949 fs_postbl(&sblock, cylno)[rpos] - blk;
1950 fs_postbl(&sblock, cylno)[rpos] = blk;
1960 sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;
1961 if (sblock.fs_ncyl % sblock.fs_cpg)
1962 sblock.fs_ncg++;
1963 sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);
1964 i = MIN(~sblock.fs_cgmask, sblock.fs_ncg - 1);
1965 ibpcl = cgdmin(&sblock, i) - cgbase(&sblock, i);
1966 if (ibpcl >= sblock.fs_fpg) {
1969 cgdmin(&sblock, i) - cgbase(&sblock, i) / sblock.fs_frag,
1970 sblock.fs_fpg / sblock.fs_frag);
1971 if ((ibpcl < 0) || (sblock.fs_fpg < 0)) {
1974 sblock.fs_cpg);
1978 sblock.fs_cpg);
1984 j = sblock.fs_ncg - 1;
1985 if ((i = fssize_frag - j * sblock.fs_fpg) < sblock.fs_fpg &&
1986 cgdmin(&sblock, j) - cgbase(&sblock, j) > i) {
1991 (cgdmin(&sblock, j) - cgbase(&sblock, j)) / sblock.fs_frag,
1992 i / sblock.fs_frag, i * NSPF(&sblock));
1997 if (sblock.fs_ncg == 1)
1999 sblock.fs_ncg--;
2000 sblock.fs_ncyl = sblock.fs_ncg * sblock.fs_cpg;
2001 sblock.fs_size = fssize_frag =
2002 (int64_t)sblock.fs_ncyl * (int64_t)sblock.fs_spc /
2003 (int64_t)NSPF(&sblock);
2009 sblock.fs_spc - (uint32_t)(fssize_frag * NSPF(&sblock) -
2010 (uint64_t)(sblock.fs_ncyl - 1) * sblock.fs_spc));
2020 sblock.fs_csaddr = cgdmin(&sblock, 0);
2021 sblock.fs_cssize =
2022 fragroundup(&sblock, sblock.fs_ncg * sizeof (struct csum));
2023 i = sblock.fs_bsize / sizeof (struct csum);
2024 sblock.fs_csmask = ~(i - 1);
2025 for (sblock.fs_csshift = 0; i > 1; i >>= 1)
2026 sblock.fs_csshift++;
2027 fscs = (struct csum *)calloc(1, sblock.fs_cssize);
2031 sblock.fs_magic = MTB_UFS_MAGIC;
2032 sblock.fs_version = MTB_UFS_VERSION_1;
2034 sblock.fs_magic = FS_MAGIC;
2036 sblock.fs_version = UFS_EFISTYLE4NONEFI_VERSION_2;
2038 sblock.fs_version = UFS_VERSION_MIN;
2046 sblock.fs_rotdelay = rotdelay;
2047 sblock.fs_maxcontig = maxcontig;
2048 sblock.fs_maxbpg = MAXBLKPG(sblock.fs_bsize);
2050 sblock.fs_rps = rps;
2051 sblock.fs_cgrotor = 0;
2052 sblock.fs_cstotal.cs_ndir = 0;
2053 sblock.fs_cstotal.cs_nbfree = 0;
2054 sblock.fs_cstotal.cs_nifree = 0;
2055 sblock.fs_cstotal.cs_nffree = 0;
2056 sblock.fs_fmod = 0;
2057 sblock.fs_ronly = 0;
2058 sblock.fs_time = mkfstime;
2059 sblock.fs_state = FSOKAY - sblock.fs_time;
2060 sblock.fs_clean = FSCLEAN;
2077 fsys, (uint64_t)sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl,
2078 sblock.fs_ntrak, sblock.fs_nsect);
2081 (float)sblock.fs_size * sblock.fs_fsize / MB, sblock.fs_ncg,
2082 sblock.fs_cpg, (float)sblock.fs_fpg * sblock.fs_fsize / MB,
2083 sblock.fs_ipg);
2085 tmpbuf = calloc(sblock.fs_ncg / 50 + 500, 1);
2102 for (width = cylno = 0; cylno < sblock.fs_ncg && cylno < 10; cylno++) {
2105 num = fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno));
2168 remaining_cg = sblock.fs_ncg - cylno;
2185 * and cylno will already be equal to sblock.fs_ncg and so this
2192 for (; cylno < sblock.fs_ncg - 10; cylno++) {
2214 for (width = 0; cylno < sblock.fs_ncg; cylno++) {
2217 num = fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno));
2258 if (cylno == sblock.fs_ncg-1)
2310 for (cylno = 0; cylno < sblock.fs_ncg && cylno < 10; cylno++)
2311 awtfs(fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno)),
2312 (int)sbsize, (char *)&sblock, SAVE);
2321 if (sblock.fs_ncg <= 10)
2322 cylno = sblock.fs_ncg;
2323 else if (sblock.fs_ncg <= 20)
2326 cylno = sblock.fs_ncg - 10;
2329 for (; cylno < sblock.fs_ncg; cylno++)
2330 awtfs(fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno)),
2331 (int)sbsize, (char *)&sblock, SAVE);
2344 sblock.fs_clean = grow_fs_clean;
2346 sblock.fs_clean = FSCLEAN;
2347 sblock.fs_time = mkfstime;
2348 sblock.fs_state = FSOKAY - sblock.fs_time;
2349 wtfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock);
2521 cbase = cgbase(&sblock, cylno);
2522 dmax = cbase + sblock.fs_fpg;
2523 if (dmax > sblock.fs_size) /* last cg may be smaller than normal */
2524 dmax = sblock.fs_size;
2525 dlower = cgsblock(&sblock, cylno) - cbase;
2526 dupper = cgdmin(&sblock, cylno) - cbase;
2528 dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
2534 if (cylno == sblock.fs_ncg - 1)
2535 icg.cg_ncyl = sblock.fs_ncyl - (sblock.fs_cpg * cylno);
2537 icg.cg_ncyl = sblock.fs_cpg;
2538 icg.cg_niblk = sblock.fs_ipg;
2548 icg.cg_boff = icg.cg_btotoff + sblock.fs_cpg * sizeof (long);
2550 sblock.fs_cpg * sblock.fs_nrpos * sizeof (short);
2551 icg.cg_freeoff = icg.cg_iusedoff + howmany(sblock.fs_ipg, NBBY);
2553 howmany(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY);
2554 for (i = 0; i < sblock.fs_frag; i++) {
2558 icg.cg_cs.cs_nifree += sblock.fs_ipg;
2569 size = sblock.fs_ipg * sizeof (struct dinode);
2572 for (i = 0; i < sblock.fs_ipg; i++) {
2579 awtfs(fsbtodb(&sblock, (uint64_t)cgimin(&sblock, cylno)), (int)size,
2583 bzero((caddr_t)cg_blks(&sblock, &icg, 0),
2588 for (d = 0; d < dlower; d += sblock.fs_frag) {
2589 setblock(&sblock, cg_blksfree(&icg), d/sblock.fs_frag);
2591 cg_blktot(&icg)[cbtocylno(&sblock, d)]++;
2592 cg_blks(&sblock, &icg, cbtocylno(&sblock, d))
2593 [cbtorpos(&sblock, d)]++;
2595 sblock.fs_dsize += dlower;
2597 sblock.fs_dsize += icg.cg_ndblk - dupper;
2598 if ((i = dupper % sblock.fs_frag) != 0) {
2599 icg.cg_frsum[sblock.fs_frag - i]++;
2600 for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
2647 cbcylno_sect = dupper * NSPF(&sblock);
2648 cbsect_incr = sblock.fs_frag * NSPF(&sblock);
2649 cbcylno = cbcylno_sect / sblock.fs_spc;
2650 cbcylno_sect %= sblock.fs_spc;
2651 cgblks = cg_blks(&sblock, &icg, cbcylno);
2652 bno = dupper / sblock.fs_frag;
2665 trackrpos = (cbcylno_sect % sblock.fs_nsect) * sblock.fs_nrpos;
2666 rpos = trackrpos / sblock.fs_nsect;
2667 trackoff = trackrpos % sblock.fs_nsect;
2668 trackoff_incr = cbsect_incr * sblock.fs_nrpos;
2669 rpos_incr = (trackoff_incr / sblock.fs_nsect) % sblock.fs_nrpos;
2670 trackoff_incr = trackoff_incr % sblock.fs_nsect;
2677 for (d = dupper; d + sblock.fs_frag <= dmax - cbase; ) {
2678 setblock(&sblock, cg_blksfree(&icg), bno);
2686 cg_blks(&sblock, &icg, cbtocylno(&sblock, d))
2687 [cbtorpos(&sblock, d)]++;
2689 d += sblock.fs_frag;
2701 if (cbcylno_sect >= sblock.fs_spc) {
2703 cbcylno_sect -= sblock.fs_spc;
2704 cgblks += sblock.fs_nrpos;
2718 if (trackoff >= sblock.fs_nsect) {
2719 trackoff -= sblock.fs_nsect;
2722 if (rpos >= sblock.fs_nrpos)
2723 rpos -= sblock.fs_nrpos;
2734 sblock.fs_cstotal.cs_ndir += icg.cg_cs.cs_ndir;
2735 sblock.fs_cstotal.cs_nffree += icg.cg_cs.cs_nffree;
2736 sblock.fs_cstotal.cs_nbfree += icg.cg_cs.cs_nbfree;
2737 sblock.fs_cstotal.cs_nifree += icg.cg_cs.cs_nifree;
2739 awtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, cylno)),
2740 sblock.fs_bsize, (char *)&icg, RELEASE);
2788 for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ) {
2794 node.i_size = sblock.fs_bsize;
2796 node.i_blocks = btodb(fragroundup(&sblock, (int)node.i_size));
2798 wtfs(fsbtodb(&sblock, (uint64_t)node.i_db[0]), (int)node.i_size, buf);
2808 node.i_db[0] = alloc(sblock.fs_fsize, node.i_mode);
2810 node.i_blocks = btodb(fragroundup(&sblock, (int)node.i_size));
2812 wtfs(fsbtodb(&sblock, (uint64_t)node.i_db[0]), sblock.fs_fsize, buf);
2848 rdfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize,
2859 for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag)
2860 if (isblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag))
2866 clrblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag);
2868 sblock.fs_cstotal.cs_nbfree--;
2872 sblock.fs_cstotal.cs_ndir++;
2875 cg_blktot(&acg)[cbtocylno(&sblock, d)]--;
2876 cg_blks(&sblock, &acg, cbtocylno(&sblock, d))[cbtorpos(&sblock, d)]--;
2877 if (size != sblock.fs_bsize) {
2878 frag = howmany(size, sblock.fs_fsize);
2879 fscs[0].cs_nffree += sblock.fs_frag - frag;
2880 sblock.fs_cstotal.cs_nffree += sblock.fs_frag - frag;
2881 acg.cg_cs.cs_nffree += sblock.fs_frag - frag;
2882 acg.cg_frsum[sblock.fs_frag - frag]++;
2883 for (i = frag; i < sblock.fs_frag; i++)
2886 wtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize,
2900 rdfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize,
2908 wtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize,
2910 sblock.fs_cstotal.cs_nifree--;
2912 if ((int)ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {
2918 d = fsbtodb(&sblock, (uint64_t)itod(&sblock, (int)ip->i_number));
2919 rdfs(d, sblock.fs_bsize, (char *)buf);
2920 buf[itoo(&sblock, (int)ip->i_number)].di_ic = ip->i_ic;
2921 wtfs(d, sblock.fs_bsize, (char *)buf);
3485 nsect, ntrack, bsize, fragsize, cpg, sblock.fs_minfree, rps,
3487 sblock.fs_nrpos, maxcontig, mtb);
3499 bzero((char *)&sblock, sizeof (sblock));
3500 rdfs((diskaddr_t)SBLOCK, SBSIZE, (char *)&sblock);
3508 if ((sblock.fs_magic != FS_MAGIC) &&
3509 (sblock.fs_magic != MTB_UFS_MAGIC)) {
3515 if (sblock.fs_magic == FS_MAGIC &&
3516 (sblock.fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 &&
3517 sblock.fs_version != UFS_VERSION_MIN)) {
3519 "Unknown version of UFS format: %d\n"), sblock.fs_version);
3523 if (sblock.fs_magic == MTB_UFS_MAGIC &&
3524 (sblock.fs_version > MTB_UFS_VERSION_1 ||
3525 sblock.fs_version < MTB_UFS_VERSION_MIN)) {
3527 "Unknown version of UFS format: %d\n"), sblock.fs_version);
3544 bpcg = sblock.fs_spc * sectorsize;
3546 INOPB(&sblock));
3547 if (inospercg > MAXIpG(&sblock))
3548 inospercg = MAXIpG(&sblock);
3550 (sblock.fs_iblkno + inospercg / INOPF(&sblock)) * NSPF(&sblock);
3552 nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used;
3559 nbpi = (int64_t)(nbytes64 / (sblock.fs_ipg));
3563 sblock.fs_nsect, sblock.fs_ntrak);
3565 sblock.fs_bsize, sblock.fs_fsize, sblock.fs_cpg, sblock.fs_minfree);
3567 sblock.fs_rps, nbpi, (sblock.fs_optim == FS_OPTSPACE) ? 's' : 't',
3568 (sblock.fs_ntrak * sblock.fs_nsect) - sblock.fs_spc,
3569 sblock.fs_rotdelay);
3571 sblock.fs_nrpos, sblock.fs_maxcontig,
3572 ((sblock.fs_magic == MTB_UFS_MAGIC) ? 'y' : 'n'));
3574 fsbtodb(&sblock, sblock.fs_size));
3576 bzero((char *)&sblock, sizeof (sblock));
3841 for (i = 0, dp = zino; i < sblock.fs_inopb; ++i, ++dp)
3847 * Fields in sblock are not changed in this function.
3871 dmin = cgdmin(&sblock, 0);
3872 dmax = cgbase(&sblock, 0) + sblock.fs_fpg;
3873 fs_size = (grow) ? grow_fs_size : sblock.fs_size;
3877 cg0blocks = cg0frags / sblock.fs_frag;
3878 cg0frags = cg0blocks * sblock.fs_frag;
3880 (longlong_t)(sblock.fs_bsize / sizeof (struct csum));
3884 if (maxncg > ((longlong_t)maxfs_blocks / (longlong_t)sblock.fs_fpg) + 1)
3886 (longlong_t)sblock.fs_fpg) + 1;
3888 maxfrags = maxncg * (longlong_t)sblock.fs_fpg;
3898 grow_sifrag = dmin + (cg0blocks * sblock.fs_frag);
3912 if ((longlong_t)sblock.fs_size > maxfrags) {
3916 fsbtodb(&sblock, (uint64_t)sblock.fs_size),
3917 fsbtodb(&sblock, (uint64_t)maxfrags));
3992 if (sblock.fs_logbno == 0) {
4014 if ((FSOKAY != (sblock.fs_state + sblock.fs_time)) ||
4015 (sblock.fs_clean != FSLOG))
4029 rdfs((diskaddr_t)logbtodb(&sblock, sblock.fs_logbno),
4041 rdfs((diskaddr_t)logbtodb(&sblock, ebp->extents[0].pbno),
4067 rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock);
4068 (void) checksblock(sblock, 0);
4069 if (sblock.fs_postblformat != FS_DYNAMICPOSTBLFMT) {
4078 grow_fssize = fsbtodb(&sblock, (uint64_t)sblock.fs_size);
4090 if (mtb == 'y' && sblock.fs_magic != MTB_UFS_MAGIC) {
4109 ((FSOKAY == (sblock.fs_state + sblock.fs_time)) &&
4110 (sblock.fs_clean == FSLOG && !islog))) {
4139 rdfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock);
4150 grow_fscs = read_summaryinfo(&sblock);
4156 grow_fs_size = sblock.fs_size;
4157 grow_fs_ncg = sblock.fs_ncg;
4158 grow_fs_csaddr = (diskaddr_t)sblock.fs_csaddr;
4159 grow_fs_cssize = sblock.fs_cssize;
4164 if (FSOKAY == (sblock.fs_state + sblock.fs_time))
4165 grow_fs_clean = sblock.fs_clean;
4168 sblock.fs_clean = FSBAD;
4169 sblock.fs_state = FSOKAY - sblock.fs_time;
4171 wtfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock);
4256 dibuf = (struct dinode *)malloc((unsigned)sblock.fs_bsize);
4257 if (itod(&sblock, ino) != difrag) {
4258 difrag = itod(&sblock, ino);
4259 rdfs(fsbtodb(&sblock, (uint64_t)difrag), (int)sblock.fs_bsize,
4262 return (dibuf + (ino % INOPB(&sblock)));
4313 int ne = sblock.fs_bsize / sizeof (daddr32_t);
4319 rdfs(fsbtodb(&sblock, frag), (int)sblock.fs_bsize,
4322 checkdirect(ino, fragsp, fsb, sblock.fs_bsize / sizeof (daddr32_t));
4346 if (ino && (frag % sblock.fs_frag))
4353 cfp->size += sblock.fs_fsize;
4364 cfp->size = sblock.fs_fsize;
4426 for (j = 0; j < sblock.fs_frag && *fragsp; ++j) {
4451 for (i = UFSROOTINO; i < grow_fs_ncg*sblock.fs_ipg && csfrag; ++i) {
4461 frags = dbtofsb(&sblock, dp->di_blocks);
4480 int ne = sblock.fs_bsize / sizeof (daddr32_t);
4486 rdfs(fsbtodb(&sblock, (uint64_t)frag), (int)sblock.fs_bsize,
4509 wtfs(fsbtodb(&sblock, (uint64_t)frag), (int)sblock.fs_bsize,
4618 rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock);
4619 (void) checksblock(sblock, 0);
4628 fscs = read_summaryinfo(&sblock);
4633 oldfrag_daddr = howmany(sblock.fs_cssize, sblock.fs_fsize) +
4634 sblock.fs_csaddr;
4635 new_fs_ncg = howmany(dbtofsb(&sblock, fssize_db), sblock.fs_fpg);
4636 new_fs_cssize = fragroundup(&sblock, new_fs_ncg * sizeof (struct csum));
4637 newfrag_daddr = howmany(new_fs_cssize, sblock.fs_fsize) +
4638 sblock.fs_csaddr;
4658 grow_fs_ncg = sblock.fs_ncg; /* findcsfragino() needs this glob. var. */
4689 growth_fs_frags = howmany(sblock.fs_fsize, sizeof (struct csum)) *
4690 growth_csum_frags * sblock.fs_fpg;
4695 rdcg(sblock.fs_ncg - 1);
4696 growth_fs_frags += sblock.fs_fpg - acg.cg_ndblk;
4703 spare_csum = howmany(sblock.fs_cssize, sizeof (struct csum)) -
4704 sblock.fs_ncg;
4706 growth_fs_frags += spare_csum * sblock.fs_fpg;
4714 sect = (sblock.fs_size + growth_fs_frags) * sblock.fs_nspf;
4741 if (grow_fs_cssize == sblock.fs_cssize)
4748 oldfrag = howmany(grow_fs_cssize, sblock.fs_fsize) + grow_fs_csaddr;
4749 newfrag = howmany(sblock.fs_cssize, sblock.fs_fsize) + grow_fs_csaddr;
4761 sblock.fs_dsize -= (newfrag - oldfrag);
4830 setbit(cg_blksfree(&acg), i-cgbase(&sblock, 0));
4895 if (isset(cg_blksfree(&acg), cfp->ofrag - cgbase(&sblock, 0))) {
4912 rdfs(fsbtodb(&sblock, (uint64_t)cfp->ofrag), (int)cfp->size,
4914 wtfs(fsbtodb(&sblock, (uint64_t)cfp->nfrag), (int)cfp->size,
4928 rdfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, curcylno)),
4929 (int)sblock.fs_cgsize, (char *)&acg);
4943 wtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, curcylno)),
4944 (int)sblock.fs_cgsize, (char *)&acg);
4981 *fragp = bit + cgbase(&sblock, i);
5025 clrbit(cg_blksfree(&acg), cfp->ofrag - cgbase(&sblock, 0));
5040 setbit(cg_blksfree(&acg), (frag+i) - cgbase(&sblock, cylno));
5063 if ((bit % sblock.fs_frag) == 0)
5082 sblock.fs_cstotal.cs_nffree -= acg.cg_cs.cs_nffree;
5083 sblock.fs_cstotal.cs_nbfree -= acg.cg_cs.cs_nbfree;
5093 if (bits == sblock.fs_frag) {
5095 cno = cbtocylno(&sblock, bit);
5097 cg_blks(&sblock, &acg, cno)[cbtorpos(&sblock, bit)]++;
5107 sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
5108 sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
5127 if (cylno == sblock.fs_ncg - 1)
5128 acg.cg_ncyl = sblock.fs_ncyl - (sblock.fs_cpg * cylno);
5130 acg.cg_ncyl = sblock.fs_cpg;
5131 cbase = cgbase(&sblock, cylno);
5132 dmax = cbase + sblock.fs_fpg;
5133 if (dmax > sblock.fs_size)
5134 dmax = sblock.fs_size;
5140 sblock.fs_dsize += (acg.cg_ndblk - dupper);
5255 for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize)
5256 wtfs(fsbtodb(&sblock, (uint64_t)(sblock.fs_csaddr +
5257 numfrags(&sblock, i))),
5258 (int)(sblock.fs_cssize - i < sblock.fs_bsize ?
5259 sblock.fs_cssize - i : sblock.fs_bsize),
5265 sblock.fs_time = mkfstime;
5266 wtfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock);
5720 pending = sizeof (sblock);
5721 source = (caddr_t)&sblock;
5734 printf("0x%x sblock.fs_link\n", sblock.fs_link);
5735 printf("0x%x sblock.fs_rolled\n", sblock.fs_rolled);
5736 printf("0x%x sblock.fs_sblkno\n", sblock.fs_sblkno);
5737 printf("0x%x sblock.fs_cblkno\n", sblock.fs_cblkno);
5738 printf("0x%x sblock.fs_iblkno\n", sblock.fs_iblkno);
5739 printf("0x%x sblock.fs_dblkno\n", sblock.fs_dblkno);
5740 printf("0x%x sblock.fs_cgoffset\n", sblock.fs_cgoffset);
5741 printf("0x%x sblock.fs_cgmask\n", sblock.fs_cgmask);
5742 printf("0x%x sblock.fs_time\n", sblock.fs_time);
5743 printf("0x%x sblock.fs_size\n", sblock.fs_size);
5744 printf("0x%x sblock.fs_dsize\n", sblock.fs_dsize);
5745 printf("0x%x sblock.fs_ncg\n", sblock.fs_ncg);
5746 printf("0x%x sblock.fs_bsize\n", sblock.fs_bsize);
5747 printf("0x%x sblock.fs_fsize\n", sblock.fs_fsize);
5748 printf("0x%x sblock.fs_frag\n", sblock.fs_frag);
5749 printf("0x%x sblock.fs_minfree\n", sblock.fs_minfree);
5750 printf("0x%x sblock.fs_rotdelay\n", sblock.fs_rotdelay);
5751 printf("0x%x sblock.fs_rps\n", sblock.fs_rps);
5752 printf("0x%x sblock.fs_bmask\n", sblock.fs_bmask);
5753 printf("0x%x sblock.fs_fmask\n", sblock.fs_fmask);
5754 printf("0x%x sblock.fs_bshift\n", sblock.fs_bshift);
5755 printf("0x%x sblock.fs_fshift\n", sblock.fs_fshift);
5756 printf("0x%x sblock.fs_maxcontig\n", sblock.fs_maxcontig);
5757 printf("0x%x sblock.fs_maxbpg\n", sblock.fs_maxbpg);
5758 printf("0x%x sblock.fs_fragshift\n", sblock.fs_fragshift);
5759 printf("0x%x sblock.fs_fsbtodb\n", sblock.fs_fsbtodb);
5760 printf("0x%x sblock.fs_sbsize\n", sblock.fs_sbsize);
5761 printf("0x%x sblock.fs_csmask\n", sblock.fs_csmask);
5762 printf("0x%x sblock.fs_csshift\n", sblock.fs_csshift);
5763 printf("0x%x sblock.fs_nindir\n", sblock.fs_nindir);
5764 printf("0x%x sblock.fs_inopb\n", sblock.fs_inopb);
5765 printf("0x%x sblock.fs_nspf\n", sblock.fs_nspf);
5766 printf("0x%x sblock.fs_optim\n", sblock.fs_optim);
5768 printf("0x%x sblock.fs_state\n", sblock.fs_state);
5770 printf("0x%x sblock.fs_npsect\n", sblock.fs_npsect);
5772 printf("0x%x sblock.fs_si\n", sblock.fs_si);
5773 printf("0x%x sblock.fs_trackskew\n", sblock.fs_trackskew);
5774 printf("0x%x sblock.fs_id[0]\n", sblock.fs_id[0]);
5775 printf("0x%x sblock.fs_id[1]\n", sblock.fs_id[1]);
5776 printf("0x%x sblock.fs_csaddr\n", sblock.fs_csaddr);
5777 printf("0x%x sblock.fs_cssize\n", sblock.fs_cssize);
5778 printf("0x%x sblock.fs_cgsize\n", sblock.fs_cgsize);
5779 printf("0x%x sblock.fs_ntrak\n", sblock.fs_ntrak);
5780 printf("0x%x sblock.fs_nsect\n", sblock.fs_nsect);
5781 printf("0x%x sblock.fs_spc\n", sblock.fs_spc);
5782 printf("0x%x sblock.fs_ncyl\n", sblock.fs_ncyl);
5783 printf("0x%x sblock.fs_cpg\n", sblock.fs_cpg);
5784 printf("0x%x sblock.fs_ipg\n", sblock.fs_ipg);
5785 printf("0x%x sblock.fs_fpg\n", sblock.fs_fpg);
5786 printf("0x%x sblock.fs_cstotal\n", sblock.fs_cstotal);
5787 printf("0x%x sblock.fs_fmod\n", sblock.fs_fmod);
5788 printf("0x%x sblock.fs_clean\n", sblock.fs_clean);
5789 printf("0x%x sblock.fs_ronly\n", sblock.fs_ronly);
5790 printf("0x%x sblock.fs_flags\n", sblock.fs_flags);
5791 printf("0x%x sblock.fs_fsmnt\n", sblock.fs_fsmnt);
5792 printf("0x%x sblock.fs_cgrotor\n", sblock.fs_cgrotor);
5793 printf("0x%x sblock.fs_u.fs_csp\n", sblock.fs_u.fs_csp);
5794 printf("0x%x sblock.fs_cpc\n", sblock.fs_cpc);
5802 printf("0x%x sblock.fs_opostbl[%d][%d]\n",
5803 sblock.fs_opostbl[row][column],
5812 printf("0x%x sblock.fs_sparecon[%d]\n",
5813 sblock.fs_sparecon[row], row);
5816 printf("0x%x sblock.fs_version\n", sblock.fs_version);
5817 printf("0x%x sblock.fs_logbno\n", sblock.fs_logbno);
5818 printf("0x%x sblock.fs_reclaim\n", sblock.fs_reclaim);
5819 printf("0x%x sblock.fs_sparecon2\n", sblock.fs_sparecon2);
5821 printf("0x%x sblock.fs_npsect\n", sblock.fs_npsect);
5823 printf("0x%x sblock.fs_state\n", sblock.fs_state);
5825 printf("0x%llx sblock.fs_qbmask\n", sblock.fs_qbmask);
5826 printf("0x%llx sblock.fs_qfmask\n", sblock.fs_qfmask);
5827 printf("0x%x sblock.fs_postblformat\n", sblock.fs_postblformat);
5828 printf("0x%x sblock.fs_nrpos\n", sblock.fs_nrpos);
5829 printf("0x%x sblock.fs_postbloff\n", sblock.fs_postbloff);
5830 printf("0x%x sblock.fs_rotbloff\n", sblock.fs_rotbloff);
5831 printf("0x%x sblock.fs_magic\n", sblock.fs_magic);