Lines Matching defs:newsb
87 static struct fs *newsb; /* copy to work with */
457 * summary info in newsb; it also writes out new inodes for the cg.
476 base = cgbase(newsb, cgn);
477 dlow = cgsblock(newsb, cgn) - base;
478 dhigh = cgdmin(newsb, cgn) - base;
479 dmax = newsb->fs_size - base;
480 if (dmax > newsb->fs_fpg)
481 dmax = newsb->fs_fpg;
489 memset(cg, 0, newsb->fs_cgsize);
490 if (newsb->fs_old_flags & FS_FLAGS_UPDATED)
491 cg->cg_time = newsb->fs_time;
494 cg->cg_niblk = newsb->fs_ipg;
498 cg->cg_time = newsb->fs_time;
499 cg->cg_initediblk = newsb->fs_ipg < 2 * FFS_INOPB(newsb) ?
500 newsb->fs_ipg : 2 * FFS_INOPB(newsb);
503 cg->cg_old_time = newsb->fs_time;
509 cg->cg_old_ncyl = newsb->fs_old_cpg;
511 if (cgn == newsb->fs_ncg - 1) {
512 if ((newsb->fs_old_flags & FS_FLAGS_UPDATED) == 0)
513 cg->cg_old_ncyl = newsb->fs_old_ncyl %
514 newsb->fs_old_cpg;
525 + (newsb->fs_old_cpg * sizeof(int32_t));
527 (newsb->fs_old_cpg * newsb->fs_old_nrpos * sizeof(int16_t));
529 cg->cg_freeoff = cg->cg_iusedoff + howmany(newsb->fs_ipg, NBBY);
530 if (newsb->fs_contigsumsize > 0) {
531 cg->cg_nclusterblks = cg->cg_ndblk / newsb->fs_frag;
533 howmany(newsb->fs_fpg, NBBY) - sizeof(int32_t);
537 ((newsb->fs_contigsumsize + 1) * sizeof(int32_t));
539 howmany(ffs_fragstoblks(newsb,newsb->fs_fpg), NBBY);
540 n = dlow / newsb->fs_frag;
543 cg_clustersum(cg, 0)[(n > newsb->fs_contigsumsize) ?
544 newsb->fs_contigsumsize : n]++;
548 howmany(newsb->fs_fpg, NBBY);
556 cg->cg_cs.cs_nifree = newsb->fs_ipg;
557 cg->cg_cs.cs_nbfree = dlow / newsb->fs_frag;
568 if ((newsb->fs_old_flags & FS_FLAGS_UPDATED) == 0) {
571 for (di = 0; di < dlow; di += newsb->fs_frag) {
572 old_cg_blktot(cg, 0)[old_cbtocylno(newsb, di)]++;
573 old_cg_blks(newsb, cg,
574 old_cbtocylno(newsb, di),
575 0)[old_cbtorpos(newsb, di)]++;
583 if (dhigh % newsb->fs_frag) {
584 n = newsb->fs_frag - (dhigh % newsb->fs_frag);
589 n = (dmax - dhigh) / newsb->fs_frag;
593 if (newsb->fs_contigsumsize > 0) {
594 i = dhigh / newsb->fs_frag;
596 cg_clustersum(cg, 0)[(n > newsb->fs_contigsumsize) ?
597 newsb->fs_contigsumsize : n]++;
601 old_cg_blktot(cg, 0)[old_cbtocylno(newsb,
603 old_cg_blks(newsb, cg,
604 old_cbtocylno(newsb, dhigh),
605 0)[old_cbtorpos(newsb,
608 dhigh += newsb->fs_frag;
619 newsb->fs_cstotal.cs_nffree += cg->cg_cs.cs_nffree;
620 newsb->fs_cstotal.cs_nbfree += cg->cg_cs.cs_nbfree;
621 newsb->fs_cstotal.cs_nifree += cg->cg_cs.cs_nifree;
624 writeat(FFS_FSBTODB(newsb, cgimin(newsb, cgn)), zinodes2,
628 writeat(FFS_FSBTODB(newsb, cgimin(newsb, cgn)), zinodes1,
629 newsb->fs_ipg * sizeof(*zinodes1));
639 * the block, or -1 if no space was found. Uses newsb for sb values,
669 cgn = dtog(newsb, hand);
670 fwc = dtogd(newsb, hand);
688 if (cgn >= newsb->fs_ncg) {
704 * first frag of the block, or -1 if no space was found. Uses newsb
721 cgn = dtog(newsb, hand);
722 fwc = dtogd(newsb, hand);
725 cgsize = ffs_blknum(newsb, cgs[cgn]->cg_ndblk);
727 if (blk_is_set(bits, fwc, newsb->fs_frag))
729 fwc += newsb->fs_frag;
730 hand += newsb->fs_frag;
734 if (cgn >= newsb->fs_ncg) {
742 cgsize = ffs_blknum(newsb, cgs[cgn]->cg_ndblk);
748 * Uses newsb for sb values, and assumes the cgs[] structures
763 cgn = hand / newsb->fs_ipg;
764 iwc = hand % newsb->fs_ipg;
772 if (iwc >= newsb->fs_ipg) {
775 if (cgn >= newsb->fs_ncg) {
795 cgn = dtog(newsb, fno);
796 set_bits(cg_blksfree(cgs[cgn], 0), dtogd(newsb, fno), 1);
808 cgn = dtog(newsb, fno);
809 clr_bits(cg_blksfree(cgs[cgn], 0), dtogd(newsb, fno), 1);
832 ntot = howmany(newsb->fs_cssize, newsb->fs_fsize);
833 nold = howmany(oldsb->fs_cssize, newsb->fs_fsize);
841 for ((i = newsb->fs_csaddr + ntot - 1), (j = nnew);
856 if (newsb->fs_csaddr + ntot <= newsb->fs_size) {
858 for ((i = newsb->fs_csaddr + nold), (j = nnew);
861 cgn = dtog(newsb, i);
863 dtogd(newsb, i)))
869 for ((i = newsb->fs_csaddr + ntot - nnew),
883 for (i = 0, f = newsb->fs_csaddr, t = newloc; i < ntot; i++, f++, t++) {
889 newsb->fs_csaddr = newloc;
892 * Recompute newsb->fs_dsize. Just scans all cgs, adding the number of
900 newsb->fs_dsize = 0;
901 for (i = 0; i < newsb->fs_ncg; i++) {
906 base = cgbase(newsb, i);
907 dlow = cgsblock(newsb, i) - base;
908 dhigh = cgdmin(newsb, i) - base;
909 dmax = newsb->fs_size - base;
910 if (dmax > newsb->fs_fpg)
911 dmax = newsb->fs_fpg;
912 newsb->fs_dsize += dlow + dmax - dhigh;
915 newsb->fs_dsize -= cgsblock(newsb, 0) - cgbase(newsb, 0);
917 newsb->fs_dsize -= howmany(newsb->fs_cssize, newsb->fs_fsize);
942 newsb->fs_size = FFS_DBTOFSB(newsb, newsize);
944 newsb->fs_ncg = howmany(newsb->fs_size, newsb->fs_fpg);
947 newsb->fs_old_ncyl = howmany(newsb->fs_size * NSPF(newsb),
948 newsb->fs_old_spc);
949 newsb->fs_ncg = howmany(newsb->fs_old_ncyl, newsb->fs_old_cpg);
957 if (cgdmin(newsb, newsb->fs_ncg - 1) > newsb->fs_size) {
958 newsb->fs_ncg--;
960 newsb->fs_size = newsb->fs_ncg * newsb->fs_fpg;
962 newsb->fs_old_ncyl = newsb->fs_ncg * newsb->fs_old_cpg;
963 newsb->fs_size = (newsb->fs_old_ncyl *
964 newsb->fs_old_spc) / NSPF(newsb);
969 (unsigned long int) FFS_FSBTODB(newsb, newsb->fs_size));
976 if (newsb->fs_size == oldsb->fs_size)
993 ", not growing.\n", newsb->fs_size, oldsb->fs_size);
999 " blocks.\n", oldsb->fs_size, newsb->fs_size);
1003 newsb->fs_time = timestamp();
1006 zinodes2 = alloconce(newsb->fs_ipg * sizeof(*zinodes2),
1008 memset(zinodes2, 0, newsb->fs_ipg * sizeof(*zinodes2));
1010 zinodes1 = alloconce(newsb->fs_ipg * sizeof(*zinodes1),
1012 memset(zinodes1, 0, newsb->fs_ipg * sizeof(*zinodes1));
1020 writeat(FFS_FSBTODB(newsb,newsb->fs_size - 1), &sbbuf, newsb->fs_fsize);
1023 newsb->fs_cssize = ffs_fragroundup(newsb,
1024 newsb->fs_ncg * sizeof(struct csum));
1025 if (newsb->fs_cssize > oldsb->fs_cssize)
1026 csums = nfrealloc(csums, newsb->fs_cssize, "new cg summary");
1029 if (newsb->fs_ncg > oldsb->fs_ncg) {
1031 cgs = nfrealloc(cgs, newsb->fs_ncg * sizeof(*cgs),
1033 cgflags = nfrealloc(cgflags, newsb->fs_ncg, "cg flags");
1035 newsb->fs_ncg - oldsb->fs_ncg);
1036 cgp = alloconce((newsb->fs_ncg - oldsb->fs_ncg) * cgblksz,
1038 for (i = oldsb->fs_ncg; i < newsb->fs_ncg; i++) {
1041 i - oldsb->fs_ncg, newsb->fs_ncg - oldsb->fs_ncg);
1058 newcgsize = newsb->fs_size - prevcgtop;
1059 if (newcgsize > newsb->fs_fpg)
1060 newcgsize = newsb->fs_fpg;
1115 sz = dblksize(newsb, di, ffs_lblkno(newsb, o), filesize);
1118 (*fn) (bn, ffs_numfrags(newsb, sz), nb, MDB_DATA);
1143 for (j = newsb->fs_bsize;
1145 j *= FFS_NINDIR(newsb), lev--);
1148 (*fn) (bn, newsb->fs_frag, newsb->fs_bsize, MDB_INDIR_PRE);
1149 readat(FFS_FSBTODB(newsb, bn), indirblks[lev], newsb->fs_bsize);
1154 for (i = 0; i < FFS_NINDIR(newsb); i++) {
1161 (*fn) (bn, newsb->fs_frag, newsb->fs_bsize, MDB_INDIR_POST);
1214 if (filesize <= newsb->fs_maxsymlinklen) {
1444 maxrun = sizeof(buf) / newsb->fs_fsize;
1584 ni = newsb->fs_ipg * newsb->fs_ncg;
1585 m = FFS_INOPB(newsb) - 1;
1630 writeat(FFS_FSBTODB(newsb, ino_to_fsba(newsb, i)),
1631 ibuf, newsb->fs_bsize);
1648 inum = newsb->fs_ipg * cg->cg_cgx;
1649 for (i = 0; i < newsb->fs_ipg; i++, inum++) {
1657 set_bits(cg_inosused(cgs[ino_to_cg(newsb, fi)], 0),
1658 fi % newsb->fs_ipg, 1);
1747 map_inodes(&dirmove_callback, newsb->fs_ncg, NULL);
1759 ", not shrinking.\n", newsb->fs_size, oldsb->fs_size);
1764 if (newsb->fs_ncg < 1)
1770 " blocks.\n", oldsb->fs_size, newsb->fs_size);
1777 newsb->fs_time = timestamp();
1782 newsb->fs_cssize = ffs_fragroundup(newsb,
1783 newsb->fs_ncg * sizeof(struct csum));
1786 for (i = newsb->fs_ncg; i < oldsb->fs_ncg; i++) {
1799 newsb->fs_cstotal.cs_ndir -= cgs[i]->cg_cs.cs_ndir;
1800 newsb->fs_cstotal.cs_nifree -= cgs[i]->cg_cs.cs_nifree;
1801 newsb->fs_cstotal.cs_nffree -= cgs[i]->cg_cs.cs_nffree;
1802 newsb->fs_cstotal.cs_nbfree -= cgs[i]->cg_cs.cs_nbfree;
1805 cgs[newsb->fs_ncg - 1]->cg_ndblk = newsb->fs_size -
1806 ((newsb->fs_ncg - 1) * newsb->fs_fpg);
1809 if (newsb->fs_size % newsb->fs_fpg) {
1813 cg = cgs[newsb->fs_ncg - 1];
1814 newcgsize = newsb->fs_size % newsb->fs_fpg;
1815 oldcgsize = oldsb->fs_size - ((newsb->fs_ncg - 1) &
1828 for (i = 0; i < newsb->fs_ncg; i++)
1842 for (i = newsb->fs_ncg; i < oldsb->fs_ncg; i++)
1850 for (i = 0; i < newsb->fs_ncg; i++)
1853 if ((newsb->fs_old_flags & FS_FLAGS_UPDATED) == 0)
1854 cgs[newsb->fs_ncg - 1]->cg_old_ncyl =
1855 newsb->fs_old_ncyl % newsb->fs_old_cpg;
1877 newsb->fs_cstotal.cs_nffree -= cg->cg_cs.cs_nffree;
1878 newsb->fs_cstotal.cs_nbfree -= cg->cg_cs.cs_nbfree;
1884 newsb->fs_old_cpg * sizeof(old_cg_blktot(cg, 0)[0]));
1885 memset(&old_cg_blks(newsb, cg, 0, 0)[0], 0,
1886 newsb->fs_old_cpg * newsb->fs_old_nrpos *
1887 sizeof(old_cg_blks(newsb, cg, 0, 0)[0]));
1888 if (newsb->fs_contigsumsize > 0) {
1889 cg->cg_nclusterblks = cg->cg_ndblk / newsb->fs_frag;
1891 newsb->fs_contigsumsize *
1895 howmany(newsb->fs_fpg / NSPB(newsb), NBBY));
1898 howmany((newsb->fs_old_cpg * newsb->fs_old_spc) /
1899 NSPB(newsb), NBBY));
1924 if (fwb >= newsb->fs_frag) {
1927 if (newsb->fs_contigsumsize > 0)
1931 old_cbtocylno(newsb,
1932 f - newsb->fs_frag)]++;
1933 old_cg_blks(newsb, cg,
1934 old_cbtocylno(newsb,
1935 f - newsb->fs_frag),
1936 0)[old_cbtorpos(newsb,
1937 f - newsb->fs_frag)]++;
1945 if (newsb->fs_contigsumsize > 0) {
1948 > newsb->fs_contigsumsize)
1949 ? newsb->fs_contigsumsize
1965 if ((blkrun > 0) && (newsb->fs_contigsumsize > 0)) {
1966 cg_clustersum(cg, 0)[(blkrun > newsb->fs_contigsumsize) ?
1967 newsb->fs_contigsumsize : blkrun]++;
1974 newsb->fs_cstotal.cs_nffree += cg->cg_cs.cs_nffree;
1975 newsb->fs_cstotal.cs_nbfree += cg->cg_cs.cs_nbfree;
1990 newsb->fs_cstotal.cs_ndir -= cg->cg_cs.cs_ndir;
1991 newsb->fs_cstotal.cs_nifree -= cg->cg_cs.cs_nifree;
1994 memset(&cg_inosused(cg, 0)[0], 0, howmany(newsb->fs_ipg, NBBY));
1995 inum = cgn * newsb->fs_ipg;
2003 for (; iwc < newsb->fs_ipg; iwc++, inum++) {
2017 newsb->fs_cstotal.cs_ndir += cg->cg_cs.cs_ndir;
2018 newsb->fs_cstotal.cs_nifree += cg->cg_cs.cs_nifree;
2029 for (i = 0; i < newsb->fs_ncg; i++) {
2031 i, newsb->fs_ncg - 1);
2043 ffs_cg_swap(cgs[i],cgs[i],newsb);
2044 writeat(FFS_FSBTODB(newsb, cgtod(newsb, i)), cgs[i],
2049 ffs_csum_swap(csums,csums,newsb->fs_cssize);
2050 writeat(FFS_FSBTODB(newsb, newsb->fs_csaddr), csums, newsb->fs_cssize);
2063 if (newsb->fs_magic == FS_UFS1_MAGIC &&
2064 (newsb->fs_old_flags & FS_FLAGS_UPDATED) == 0) {
2065 newsb->fs_old_time = newsb->fs_time;
2066 newsb->fs_old_size = newsb->fs_size;
2068 newsb->fs_old_dsize = newsb->fs_dsize;
2069 newsb->fs_old_cstotal.cs_ndir = newsb->fs_cstotal.cs_ndir;
2070 newsb->fs_old_cstotal.cs_nbfree = newsb->fs_cstotal.cs_nbfree;
2071 newsb->fs_old_cstotal.cs_nifree = newsb->fs_cstotal.cs_nifree;
2072 newsb->fs_old_cstotal.cs_nffree = newsb->fs_cstotal.cs_nffree;
2075 /* copy newsb back to oldsb, so we can use it for offsets if
2076 newsb has been swapped for writing to disk */
2077 memcpy(oldsb, newsb, SBLOCKSIZE);
2079 ffs_sb_swap(newsb,newsb);
2080 writeat(where / DEV_BSIZE, newsb, SBLOCKSIZE);
2084 writeat(FFS_FSBTODB(oldsb, cgsblock(oldsb, i)), newsb, SBLOCKSIZE);
2226 newsb = (struct fs *) (SBLOCKSIZE + (char *) &sbbuf);
2277 memcpy(newsb, oldsb, SBLOCKSIZE);