sbin/growfs/growfs.c

92 #define	sblock	fsun1.fs	/* the new superblock */
152 	fscs = (struct csum *)calloc((size_t)1, (size_t)sblock.fs_cssize);
189 	    (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,
190 	    (intmax_t)fsbtodb(&sblock, sblock.fs_size), sblock.fs_bsize,
191 	    sblock.fs_fsize);
193 	    sblock.fs_ncg, (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
194 	    sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);
195 	if (sblock.fs_flags & FS_DOSOFTDEP)
211 	for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) {
214 		    (intmax_t)fsbtodb(&sblock, cgsblock(&sblock, cylno)),
215 		    cylno < (sblock.fs_ncg - 1) ? "," : "" );
235 	for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
236 		wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
237 		    (size_t)MIN(sblock.fs_cssize - i, sblock.fs_bsize),
249 		for (dbg_csc = 0; dbg_csc < sblock.fs_ncg; dbg_csc++) {
252 			DBG_DUMP_CSUM(&sblock, dbg_line, dbg_csp++);
260 	sblock.fs_time = modtime;
261 	wtfs(sblockloc, (size_t)SBLOCKSIZE, (void *)&sblock, fso, Nflag);
262 	DBG_PRINT0("sblock written\n");
263 	DBG_DUMP_FS(&sblock, "new initial sblock");
268 	sblock.fs_fmod = 0;
269 	sblock.fs_clean = 1;
270 	sblock.fs_ronly = 0;
271 	sblock.fs_cgrotor = 0;
272 	sblock.fs_state = 0;
273 	memset((void *)&sblock.fs_fsmnt, 0, sizeof(sblock.fs_fsmnt));
274 	sblock.fs_flags &= FS_DOSOFTDEP;
300 	for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
301 		wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
302 		    (size_t)SBLOCKSIZE, (void *)&sblock, fso, Nflag);
304 	DBG_PRINT0("sblock copies written\n");
305 	DBG_DUMP_FS(&sblock, "new other sblocks");
329 	if (iobuf == NULL && (iobuf = malloc(sblock.fs_bsize * 3)) == NULL)
337 	cbase = cgbase(&sblock, cylno);
338 	dmax = cbase + sblock.fs_fpg;
339 	if (dmax > sblock.fs_size)
340 		dmax = sblock.fs_size;
341 	dlower = cgsblock(&sblock, cylno) - cbase;
342 	dupper = cgdmin(&sblock, cylno) - cbase;
344 		dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
346 	memset(&acg, 0, sblock.fs_cgsize);
350 	acg.cg_niblk = sblock.fs_ipg;
351 	acg.cg_initediblk = MIN(sblock.fs_ipg, 2 * INOPB(&sblock));
353 	if (sblock.fs_contigsumsize > 0)
354 		acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
356 	if (sblock.fs_magic == FS_UFS2_MAGIC) {
359 		acg.cg_old_ncyl = sblock.fs_old_cpg;
367 		    sblock.fs_old_cpg * sizeof(int32_t);
369 		    sblock.fs_old_cpg * sizeof(u_int16_t);
371 	acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
372 	acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);
373 	if (sblock.fs_contigsumsize > 0) {
378 		    (sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);
380 		    howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
382 	if (acg.cg_nextfreeoff > (unsigned)sblock.fs_cgsize) {
389 	acg.cg_cs.cs_nifree += sblock.fs_ipg;
398 	if (sblock.fs_magic == FS_UFS1_MAGIC) {
399 		bzero(iobuf, sblock.fs_bsize);
400 		for (i = 0; i < sblock.fs_ipg / INOPF(&sblock);
401 		    i += sblock.fs_frag) {
403 			for (j = 0; j < INOPB(&sblock); j++) {
407 			wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
408 			    sblock.fs_bsize, iobuf, fso, Nflag);
416 		for (d = 0; d < dlower; d += sblock.fs_frag) {
417 			blkno = d / sblock.fs_frag;
418 			setblock(&sblock, cg_blksfree(&acg), blkno);
419 			if (sblock.fs_contigsumsize > 0)
423 		sblock.fs_dsize += dlower;
425 	sblock.fs_dsize += acg.cg_ndblk - dupper;
426 	if ((i = dupper % sblock.fs_frag)) {
427 		acg.cg_frsum[sblock.fs_frag - i]++;
428 		for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
433 	for (d = dupper; d + sblock.fs_frag <= acg.cg_ndblk;
434 	    d += sblock.fs_frag) {
435 		blkno = d / sblock.fs_frag;
436 		setblock(&sblock, cg_blksfree(&acg), blkno);
437 		if (sblock.fs_contigsumsize > 0)
448 	if (sblock.fs_contigsumsize > 0) {
459 				if (run > sblock.fs_contigsumsize)
460 					run = sblock.fs_contigsumsize;
472 			if (run > sblock.fs_contigsumsize)
473 				run = sblock.fs_contigsumsize;
477 	sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;
478 	sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
479 	sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
480 	sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
483 	memcpy(iobuf, &acg, sblock.fs_cgsize);
484 	memset(iobuf + sblock.fs_cgsize, '\0',
485 	    sblock.fs_bsize * 3 - sblock.fs_cgsize);
487 	wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
488 	    sblock.fs_bsize * 3, iobuf, fso, Nflag);
489 	DBG_DUMP_CG(&sblock, "new cg", &acg);
515 	for (f = rounddown(frag, sblock.fs_frag);
516 	    f < roundup(frag + 1, sblock.fs_frag); f++) {
523 			if (fragsize && fragsize < sblock.fs_frag) {
534 	if (fragsize && fragsize < sblock.fs_frag) {
576 	DBG_DUMP_CG(&sblock, "old joining cg", &aocg);
589 		if (sblock.fs_magic == FS_UFS1_MAGIC)
590 			acg.cg_old_ncyl = sblock.fs_old_cpg;
592 		wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
593 		    (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
595 		DBG_DUMP_CG(&sblock, "new joining cg", &acg);
604 	cbase = cgbase(&sblock, cylno);
605 	dmax = cbase + sblock.fs_fpg;
606 	if (dmax > sblock.fs_size)
607 		dmax = sblock.fs_size;
608 	dupper = cgdmin(&sblock, cylno) - cbase;
610 		dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
622 	if ((unsigned)cylno == sblock.fs_ncg - 1) {
626 		if (sblock.fs_magic == FS_UFS1_MAGIC)
628 			    sblock.fs_old_ncyl % sblock.fs_old_cpg;
630 		acg.cg_old_ncyl = sblock.fs_old_cpg;
632 	DBG_PRINT2("jcg dbg: %d %u", cylno, sblock.fs_ncg);
634 	if (sblock.fs_magic == FS_UFS1_MAGIC)
635 		DBG_PRINT2("%d %u", acg.cg_old_ncyl, sblock.fs_old_cpg);
639 	sblock.fs_dsize += acg.cg_ndblk - aocg.cg_ndblk;
640 	if (sblock.fs_contigsumsize > 0)
641 		acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
655 	if (osblock.fs_size % sblock.fs_frag) {
656 		if (roundup(osblock.fs_size, sblock.fs_frag) <=
657 		    sblock.fs_size) {
664 			    sblock.fs_frag) - 1; i >= osblock.fs_size - cbase;
676 			if (isblock(&sblock, cg_blksfree(&acg),
677 			    ((osblock.fs_size - cgbase(&sblock, cylno)) /
678 			     sblock.fs_frag))) {
683 				acg.cg_frsum[osblock.fs_size % sblock.fs_frag]--;
685 				acg.cg_cs.cs_nffree -= sblock.fs_frag;
687 				    sblock.fs_frag);
689 				    sblock.fs_frag);
698 				    sblock.fs_frag))) {
711 			for (i = sblock.fs_size - cbase - 1;
723 			    sblock.fs_frag))) {
736 	for (i = roundup(osblock.fs_size - cbase, sblock.fs_frag);
737 	    i + sblock.fs_frag <= dmax - cbase;	/* XXX <= or only < ? */
738 	    i += sblock.fs_frag) {
739 		j = i / sblock.fs_frag;
740 		setblock(&sblock, cg_blksfree(&acg), j);
758 	sblock.fs_cstotal.cs_nffree +=
760 	sblock.fs_cstotal.cs_nbfree +=
764 	 *     sblock.fs_cstotal.cs_ndir
765 	 *     sblock.fs_cstotal.cs_nifree
774 	wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), (size_t)sblock.fs_cgsize,
777 	DBG_DUMP_CG(&sblock, "new joining cg", &acg);
808 	if (howmany(sblock.fs_cssize, sblock.fs_fsize) ==
828 	DBG_DUMP_CG(&sblock, "old summary cg", &aocg);
864 	if (sblock.fs_ncg - osblock.fs_ncg < 2)
878 	if (sblock.fs_contigsumsize > 0) {
879 		for (block = howmany(d % sblock.fs_fpg, sblock.fs_frag),
880 		    lcs = 0; lcs < sblock.fs_contigsumsize; block++, lcs++) {
892 	if ((d + 1) % sblock.fs_frag) {
898 		frag_adjust(d % sblock.fs_fpg, -1);
899 		for (; (d + 1) % sblock.fs_frag; d--) {
901 			setbit(cg_blksfree(&acg), d % sblock.fs_fpg);
903 			sblock.fs_cstotal.cs_nffree++;
910 		frag_adjust(d % sblock.fs_fpg, 1);
912 		if (isblock(&sblock, cg_blksfree(&acg),
913 		    (d % sblock.fs_fpg) / sblock.fs_frag)) {
915 			acg.cg_cs.cs_nffree -= sblock.fs_frag;
917 			sblock.fs_cstotal.cs_nffree -= sblock.fs_frag;
918 			sblock.fs_cstotal.cs_nbfree++;
919 			if (sblock.fs_contigsumsize > 0) {
921 				    (d % sblock.fs_fpg) / sblock.fs_frag);
922 				if (lcs < sblock.fs_contigsumsize) {
938 	for (d = rounddown(d, sblock.fs_frag); d >= osblock.fs_csaddr;
939 	    d -= sblock.fs_frag) {
942 		setblock(&sblock, cg_blksfree(&acg),
943 		    (d % sblock.fs_fpg) / sblock.fs_frag);
945 		sblock.fs_cstotal.cs_nbfree++;
946 		if (sblock.fs_contigsumsize > 0) {
948 			    (d % sblock.fs_fpg) / sblock.fs_frag);
952 			if (lcs < sblock.fs_contigsumsize) {
966 	wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)),
967 	    (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
969 	DBG_DUMP_CG(&sblock, "old summary cg", &acg);
975 	sblock.fs_csaddr = cgdmin(&sblock, osblock.fs_ncg);
976 	ncscg = dtog(&sblock, sblock.fs_csaddr);
994 	rdfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
995 	    (size_t)sblock.fs_cgsize, (void *)&aocg, fsi);
997 	DBG_DUMP_CG(&sblock, "new summary cg", &aocg);
1005 	for (d = sblock.fs_csaddr; d + sblock.fs_frag <=
1006 	    sblock.fs_csaddr + (sblock.fs_cssize / sblock.fs_fsize);
1007 	    d += sblock.fs_frag) {
1008 		clrblock(&sblock, cg_blksfree(&acg),
1009 		    (d % sblock.fs_fpg) / sblock.fs_frag);
1011 		sblock.fs_cstotal.cs_nbfree--;
1012 		if (sblock.fs_contigsumsize > 0) {
1014 			    (d % sblock.fs_fpg) / sblock.fs_frag);
1022 	if (d < sblock.fs_csaddr + (sblock.fs_cssize / sblock.fs_fsize)) {
1023 		for (; d - sblock.fs_csaddr <
1024 		    sblock.fs_cssize/sblock.fs_fsize; d++) {
1025 			clrbit(cg_blksfree(&acg), d % sblock.fs_fpg);
1027 			sblock.fs_cstotal.cs_nffree--;
1030 		acg.cg_cs.cs_nffree += sblock.fs_frag;
1031 		sblock.fs_cstotal.cs_nbfree--;
1032 		sblock.fs_cstotal.cs_nffree += sblock.fs_frag;
1033 		if (sblock.fs_contigsumsize > 0)
1035 			    (d % sblock.fs_fpg) / sblock.fs_frag);
1037 		frag_adjust(d % sblock.fs_fpg, 1);
1058 	wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
1059 	    (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
1061 	DBG_DUMP_CG(&sblock, "new summary cg", &acg);
1464 	DBG_DUMP_FS(&sblock, "old sblock");
1501 	sblock.fs_size = dbtofsb(&osblock, size / DEV_BSIZE);
1502 	sblock.fs_providersize = dbtofsb(&osblock, mediasize / DEV_BSIZE);
1507 	if (osblock.fs_size >= sblock.fs_size) {
1509 		    (intmax_t)osblock.fs_size, (intmax_t)sblock.fs_size);
1517 			if (sblock.fs_snapinum[j]) {
1522 			if (!sblock.fs_snapinum[j]) /* list is dense */
1541 		    sblock.fs_size * sblock.fs_fsize,
1577 	testbuf = malloc(sblock.fs_fsize);
1580 	rdfs((ufs2_daddr_t)((size - sblock.fs_fsize) / DEV_BSIZE),
1581 	    sblock.fs_fsize, testbuf, fsi);
1582 	wtfs((ufs2_daddr_t)((size - sblock.fs_fsize) / DEV_BSIZE),
1583 	    sblock.fs_fsize, testbuf, fso, Nflag);
1599 	if (sblock.fs_magic == FS_UFS1_MAGIC) {
1600 		sblock.fs_old_ncyl =
1601 		    sblock.fs_size * sblock.fs_old_nspf / sblock.fs_old_spc;
1602 		if (sblock.fs_size * sblock.fs_old_nspf >
1603 		    sblock.fs_old_ncyl * sblock.fs_old_spc)
1604 			sblock.fs_old_ncyl++;
1606 	sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg);
1612 	if (sblock.fs_size % sblock.fs_fpg != 0 &&
1613 	    sblock.fs_size <= cgdmin(&sblock, sblock.fs_ncg - 1)) {
1615 		    (sblock.fs_size % sblock.fs_fpg) * sblock.fs_fsize,
1619 		sblock.fs_ncg--;
1620 		if (sblock.fs_magic == FS_UFS1_MAGIC)
1621 			sblock.fs_old_ncyl = sblock.fs_ncg * sblock.fs_old_cpg;
1622 		sblock.fs_size = sblock.fs_ncg * sblock.fs_fpg;
1629 	sblock.fs_cssize =
1630 	    fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));
1632 	if (osblock.fs_size >= sblock.fs_size)
1635 	DBG_PRINT0("sblock calculated\n");
1680  * assume that sblock, osblock, acg are set up.
1690 	if (sblock.fs_contigsumsize < 1) /* no clustering */
1704 		for (block--; lcs < sblock.fs_contigsumsize; block--, lcs++ ) {
1709 	if (lcs < sblock.fs_contigsumsize) {