/usr/src/sbin/fsck_ffs/pass5.c

Bug Summary

File:	src/sbin/fsck_ffs/pass5.c
Warning:	line 279, column 6 Division by zero

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name pass5.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sbin/fsck_ffs/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/sbin/fsck_ffs/../fsck -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/fsck_ffs/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/sbin/fsck_ffs/pass5.c

1/*	$OpenBSD: pass5.c,v 1.50 2020/07/13 06:52:53 otto Exp $	*/
2/*	$NetBSD: pass5.c,v 1.16 1996/09/27 22:45:18 christos Exp $	*/
3 
4/*
5 * Copyright (c) 1980, 1986, 1993
6 *	The Regents of the University of California.  All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 *    may be used to endorse or promote products derived from this software
18 *    without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32 
33#include <sys/param.h>	/* MAXBSIZE roundup setbit */
34#include <sys/time.h>
35#include <sys/lock.h>
36#include <sys/ucred.h>
37#include <ufs/ffs/fs.h>
38#include <ufs/ufs/quota.h>
39#include <ufs/ufs/inode.h>
40#include <ufs/ffs/ffs_extern.h>
41#include <stdio.h>
42#include <string.h>
43#include <limits.h>
44 
45#include "fsutil.h"
46#include "fsck.h"
47#include "extern.h"
48 
49#define MINIMUM(a, b)(((a) < (b)) ? (a) : (b))	(((a) < (b)) ? (a) : (b))
50 
51static u_int info_cg;
52static u_int info_maxcg;
53 
54static int
55pass5_info(char *buf, size_t buflen)
56{
57	return (snprintf(buf, buflen, "phase 5, cg %u/%u",
58	    info_cg, info_maxcg) > 0);
59}
60 
61void
62pass5(void)
63{
64	int blk, frags, basesize, sumsize, mapsize, savednrpos=0;
65	u_int c;
66	int inomapsize, blkmapsize;
67	struct fs *fs = &sblock(*sblk.b_un.b_fs);
68	daddr_t dbase, dmax;
69	daddr_t d;
70	long i, k, rewritecg = 0;
71	ino_t j;
72	struct csum *cs;
73	struct csum_total cstotal;
74	struct inodesc idesc[3];
75	char buf[MAXBSIZE(64 * 1024)];
76	struct cg *newcg = (struct cg *)buf;
77	struct ocg *ocg = (struct ocg *)buf;
78	struct cg *cg;
79	struct bufarea *cgbp;
80 
81	memset(newcg, 0, (size_t)fs->fs_cgsize);
82	if (cvtlevel >= 3) {
1
Assuming 'cvtlevel' is < 3→
2
←
Taking false branch→
83		if (fs->fs_maxcontig < 2 && fs->fs_contigsumsize > 0) {
84			if (preen)
85				pwarn("DELETING CLUSTERING MAPS\n");
86			if (preen || reply("DELETE CLUSTERING MAPS")) {
87				fs->fs_contigsumsize = 0;
88				rewritecg = 1;
89				sbdirty()sblk.b_dirty = 1;
90			}
91		}
92		if (fs->fs_maxcontig > 1) {
93			char *doit = 0;
94 
95			if (fs->fs_contigsumsize < 1) {
96				doit = "CREAT";
97			} else if (fs->fs_contigsumsize < fs->fs_maxcontig &&
98				   fs->fs_contigsumsize < FS_MAXCONTIG16) {
99				doit = "EXPAND";
100			}
101			if (doit) {
102				i = fs->fs_contigsumsize;
103				fs->fs_contigsumsize =
104				    MINIMUM(fs->fs_maxcontig, FS_MAXCONTIG)(((fs->fs_maxcontig) < (16)) ? (fs->fs_maxcontig) : (
16));
105				if (CGSIZE(fs)(sizeof(struct cg) + sizeof(int32_t) + (fs)->fs_cpg * sizeof
(int32_t) + (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(int16_t
) + ((((fs)->fs_ipg) + ((8) - 1)) / (8)) + ((((fs)->fs_fpg
) + ((8) - 1)) / (8)) + ((fs)->fs_contigsumsize <= 0 ? 0
 : (fs)->fs_contigsumsize * sizeof(int32_t) + ((((((fs)->
fs_fpg) >> (fs)->fs_fragshift)) + ((8) - 1)) / (8)))
) > fs->fs_bsize) {
106					pwarn("CANNOT %s CLUSTER MAPS\n", doit);
107					fs->fs_contigsumsize = i;
108				} else if (preen ||
109				    reply("CREATE CLUSTER MAPS")) {
110					if (preen)
111						pwarn("%sING CLUSTER MAPS\n",
112						    doit);
113					fs->fs_cgsize =
114					    fragroundup(fs, CGSIZE(fs))((((sizeof(struct cg) + sizeof(int32_t) + (fs)->fs_cpg * sizeof
(int32_t) + (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(int16_t
) + ((((fs)->fs_ipg) + ((8) - 1)) / (8)) + ((((fs)->fs_fpg
) + ((8) - 1)) / (8)) + ((fs)->fs_contigsumsize <= 0 ? 0
 : (fs)->fs_contigsumsize * sizeof(int32_t) + ((((((fs)->
fs_fpg) >> (fs)->fs_fragshift)) + ((8) - 1)) / (8)))
)) + (fs)->fs_qfmask) & (fs)->fs_fmask);
115					rewritecg = 1;
116					sbdirty()sblk.b_dirty = 1;
117				}
118			}
119		}
120	}
121	switch ((int)fs->fs_postblformat) {
3
←
Control jumps to 'case 1:'  at line 136→
122 
123	case FS_42POSTBLFMT-1:
124		basesize = (char *)(&ocg->cg_btot[0]) -
125		    (char *)(&ocg->cg_firstfield);
126		sumsize = &ocg->cg_iused[0] - (u_int8_t *)(&ocg->cg_btot[0]);
127		mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)(((fs->fs_fpg) + ((8) - 1)) / (8))] -
128			(u_char *)&ocg->cg_iused[0];
129		blkmapsize = howmany(fs->fs_fpg, NBBY)(((fs->fs_fpg) + ((8) - 1)) / (8));
130		inomapsize = sizeof(ocg->cg_iused);
131		ocg->cg_magic = CG_MAGIC0x090255;
132		savednrpos = fs->fs_nrpos;
133		fs->fs_nrpos = 8;
134		break;
135 
136	case FS_DYNAMICPOSTBLFMT1:
137		if (sblock(*sblk.b_un.b_fs).fs_magic == FS_UFS2_MAGIC0x19540119) {
4
←
Assuming field 'fs_magic' is not equal to FS_UFS2_MAGIC→
5
←
Taking false branch→
138			newcg->cg_iusedoff = sizeof(struct cg);
139		} else {
140			newcg->cg_btotoff = sizeof(struct cg);
141			newcg->cg_boff = newcg->cg_btotoff +
142			    fs->fs_cpg * sizeof(int32_t);
143			newcg->cg_iusedoff = newcg->cg_boff + fs->fs_cpg *
144			    fs->fs_nrpos * sizeof(int16_t);
145		}
146		inomapsize = howmany(fs->fs_ipg, CHAR_BIT)(((fs->fs_ipg) + ((8) - 1)) / (8));
147		newcg->cg_freeoff = newcg->cg_iusedoff + inomapsize;
148		blkmapsize = howmany(fs->fs_fpg, CHAR_BIT)(((fs->fs_fpg) + ((8) - 1)) / (8));
149		newcg->cg_nextfreeoff = newcg->cg_freeoff + blkmapsize;
150		if (fs->fs_contigsumsize > 0) {
6
←
Assuming field 'fs_contigsumsize' is <= 0→
7
←
Taking false branch→
151			newcg->cg_clustersumoff = newcg->cg_nextfreeoff -
152			    sizeof(int32_t);
153			newcg->cg_clustersumoff =
154			    roundup(newcg->cg_clustersumoff, sizeof(int32_t))((((newcg->cg_clustersumoff)+((sizeof(int32_t))-1))/(sizeof
(int32_t)))*(sizeof(int32_t)));
155			newcg->cg_clusteroff = newcg->cg_clustersumoff +
156			    (fs->fs_contigsumsize + 1) * sizeof(int32_t);
157			newcg->cg_nextfreeoff = newcg->cg_clusteroff +
158			    howmany(fragstoblks(fs, fs->fs_fpg), CHAR_BIT)(((((fs->fs_fpg) >> (fs)->fs_fragshift)) + ((8) -
 1)) / (8));
159		}
160		newcg->cg_magic = CG_MAGIC0x090255;
161		basesize = sizeof(struct cg);
162		sumsize = newcg->cg_iusedoff - newcg->cg_btotoff;
163		mapsize = newcg->cg_nextfreeoff - newcg->cg_iusedoff;
164		break;
8
←
 Execution continues on line 171→
165 
166	default:
167		inomapsize = blkmapsize = sumsize = 0;
168		errexit("UNKNOWN ROTATIONAL TABLE FORMAT %d\n",
169			fs->fs_postblformat);
170	}
171	memset(&idesc[0], 0, sizeof idesc);
172	for (i = 0; i < 3; i++)
9
←
Loop condition is true.  Entering loop body→
10
←
Loop condition is true.  Entering loop body→
11
←
Loop condition is true.  Entering loop body→
12
←
Loop condition is false. Execution continues on line 174→
173		idesc[i].id_type = ADDR2;
174	memset(&cstotal, 0, sizeof(struct csum_total));
175	dmax = blknum(fs, fs->fs_size + fs->fs_frag - 1)((fs->fs_size + fs->fs_frag - 1) &~ ((fs)->fs_frag
 - 1));
176	for (d = fs->fs_size; d < dmax; d++)
13
←
Assuming 'd' is >= 'dmax'→
14
←
Loop condition is false. Execution continues on line 178→
177		setbmap(d)((blockmap)[(d)>>3] |= 1<<((d)&(8 -1)));
178	info_cg = 0;
179	info_maxcg = fs->fs_ncg;
180	info_fn = pass5_info;
181	for (c = 0; c < fs->fs_ncg; c++) {
15
←
Assuming 'c' is < field 'fs_ncg'→
16
←
Loop condition is true.  Entering loop body→
182		info_cg = c;
183		cgbp = cglookup(c);
184		cg = cgbp->b_un.b_cg;
185		if (!cg_chkmagic(cg)((cg)->cg_magic == 0x090255 || ((struct ocg *)(cg))->cg_magic
 == 0x090255))
17
←
Assuming field 'cg_magic' is not equal to 590421→
18
←
Assuming field 'cg_magic' is not equal to 590421→
19
←
Taking true branch→
186			pfatal("CG %u: BAD MAGIC NUMBER\n", c);
187		dbase = cgbase(fs, c)((daddr_t)(fs)->fs_fpg * (c));
188		dmax = dbase + fs->fs_fpg;
189		if (dmax > fs->fs_size)
20
←
Assuming 'dmax' is <= field 'fs_size'→
21
←
Taking false branch→
190			dmax = fs->fs_size;
191		newcg->cg_time = cg->cg_time;
192		newcg->cg_ffs2_time = cg->cg_ffs2_time;
193		newcg->cg_cgx = c;
194		if (c == fs->fs_ncg - 1)
22
←
Assuming the condition is false→
23
←
Taking false branch→
195			newcg->cg_ncyl = fs->fs_ncyl % fs->fs_cpg;
196		else
197			newcg->cg_ncyl = fs->fs_cpg;
198		newcg->cg_ndblk = dmax - dbase;
199		if (fs->fs_contigsumsize23.1
Field 'fs_contigsumsize' is <= 0
 > 0)
24
←
Taking false branch→
200			newcg->cg_nclusterblks = newcg->cg_ndblk / fs->fs_frag;
201		newcg->cg_cs.cs_ndir = 0;
202		newcg->cg_cs.cs_nffree = 0;
203		newcg->cg_cs.cs_nbfree = 0;
204		newcg->cg_cs.cs_nifree = fs->fs_ipg;
205		if (cg->cg_rotor < newcg->cg_ndblk)
25
←
Assuming field 'cg_rotor' is >= field 'cg_ndblk'→
26
←
Taking false branch→
206			newcg->cg_rotor = cg->cg_rotor;
207		else
208			newcg->cg_rotor = 0;
209		if (cg->cg_frotor26.1
Field 'cg_frotor' is >= 0
 >= 0 && cg->cg_frotor < newcg->cg_ndblk)
27
←
Assuming field 'cg_frotor' is >= field 'cg_ndblk'→
28
←
Taking false branch→
210			newcg->cg_frotor = cg->cg_frotor;
211		else
212			newcg->cg_frotor = 0;
213		newcg->cg_irotor = 0;
214		if (fs->fs_magic == FS_UFS1_MAGIC0x011954) {
29
←
Assuming field 'fs_magic' is not equal to FS_UFS1_MAGIC→
30
←
Taking false branch→
215			newcg->cg_initediblk = 0;
216			newcg->cg_niblk = cg->cg_niblk;
217			if (cg->cg_irotor >= 0 &&
218			    cg->cg_irotor < fs->fs_ipg)
219				newcg->cg_irotor = cg->cg_irotor;
220		} else {
221			newcg->cg_ncyl = 0;
222			if (cg->cg_initediblk > fs->fs_ipg)
31
←
Assuming field 'cg_initediblk' is <= field 'fs_ipg'→
32
←
Taking false branch→
223				newcg->cg_initediblk = fs->fs_ipg;
224			else
225				newcg->cg_initediblk = cg->cg_initediblk;
226			newcg->cg_ffs2_niblk = fs->fs_ipg;
227			if (cg->cg_irotor32.1
Field 'cg_irotor' is >= 0
 >= 0 &&
34
←
Taking false branch→
228			    cg->cg_irotor < newcg->cg_ffs2_niblk)
33
←
Assuming field 'cg_irotor' is >= field 'cg_ffs2_niblk'→
229				newcg->cg_irotor = cg->cg_irotor;
230		}
231		memset(&newcg->cg_frsum[0], 0, sizeof newcg->cg_frsum);
232		memset(cg_inosused(newcg)(((newcg)->cg_magic != 0x090255) ? (((struct ocg *)(newcg)
)->cg_iused) : ((u_int8_t *)((u_int8_t *)(newcg) + (newcg)
->cg_iusedoff))), 0, (size_t)(mapsize));
35
←
'?' condition is false→
233		if (fs->fs_postblformat == FS_42POSTBLFMT-1)
36
←
Taking false branch→
234			ocg->cg_magic = CG_MAGIC0x090255;
235		j = fs->fs_ipg * c;
236		for (i = 0; i < inostathead[c].il_numalloced; j++, i++) {
37
←
Assuming 'i' is >= field 'il_numalloced'→
38
←
Loop condition is false. Execution continues on line 261→
237			switch (GET_ISTATE(j)(inoinfo(j)->ino_state)) {
238 
239			case USTATE01:
240				break;
241 
242			case DSTATE03:
243			case DCLEAR05:
244			case DFOUND04:
245				newcg->cg_cs.cs_ndir++;
246				/* FALLTHROUGH */
247 
248			case FSTATE02:
249			case FCLEAR06:
250				newcg->cg_cs.cs_nifree--;
251				setbit(cg_inosused(newcg), i)(((((newcg)->cg_magic != 0x090255) ? (((struct ocg *)(newcg
))->cg_iused) : ((u_int8_t *)((u_int8_t *)(newcg) + (newcg
)->cg_iusedoff))))[(i)>>3] |= 1<<((i)&(8 -
1)));
252				break;
253 
254			default:
255				if (j < ROOTINO((ufsino_t)2))
256					break;
257				errexit("BAD STATE %d FOR INODE I=%llu\n",
258				    GET_ISTATE(j)(inoinfo(j)->ino_state), (unsigned long long)j);
259			}
260		}
261		if (c38.1
'c' is equal to 0
 == 0)
39
←
Taking true branch→
262			for (i = 0; i < ROOTINO((ufsino_t)2); i++) {
40
←
Loop condition is true.  Entering loop body→
43
←
Loop condition is true.  Entering loop body→
45
←
Loop condition is false. Execution continues on line 266→
263				setbit(cg_inosused(newcg), i)(((((newcg)->cg_magic != 0x090255) ? (((struct ocg *)(newcg
))->cg_iused) : ((u_int8_t *)((u_int8_t *)(newcg) + (newcg
)->cg_iusedoff))))[(i)>>3] |= 1<<((i)&(8 -
1)));
41
←
Assuming field 'cg_magic' is not equal to 590421→
42
←
'?' condition is true→
44
←
'?' condition is true→
264				newcg->cg_cs.cs_nifree--;
265			}
266		for (i = 0, d = dbase;
47
←
Loop condition is true.  Entering loop body→
65
←
Loop condition is true.  Entering loop body→
267		     d < dmax;
46
←
Assuming 'd' is < 'dmax'→
64
←
Assuming 'd' is < 'dmax'→
268		     d += fs->fs_frag, i += fs->fs_frag) {
269			frags = 0;
270			for (j = 0; j < fs->fs_frag; j++) {
48
←
Assuming 'j' is < field 'fs_frag'→
49
←
Loop condition is true.  Entering loop body→
53
←
Assuming 'j' is < field 'fs_frag'→
54
←
Loop condition is true.  Entering loop body→
58
←
Assuming 'j' is >= field 'fs_frag'→
59
←
Loop condition is false. Execution continues on line 276→
66
←
Assuming 'j' is >= field 'fs_frag'→
67
←
Loop condition is false. Execution continues on line 276→
271				if (testbmap(d + j)((blockmap)[(d + j)>>3] & (1<<((d + j)&(8
 -1)))))
50
←
Assuming the condition is false→
51
←
Taking false branch→
55
←
Assuming the condition is true→
56
←
Taking true branch→
272					continue;
57
←
 Execution continues on line 270→
273				setbit(cg_blksfree(newcg), i + j)(((((newcg)->cg_magic != 0x090255) ? (((struct ocg *)(newcg
))->cg_free) : ((u_int8_t *)((u_int8_t *)(newcg) + (newcg)
->cg_freeoff))))[(i + j)>>3] |= 1<<((i + j)&
(8 -1)));
52
←
'?' condition is true→
274				frags++;
275			}
276			if (frags59.1
'frags' is not equal to field 'fs_frag'
 == fs->fs_frag) {
60
←
Taking false branch→
68
←
Assuming 'frags' is equal to field 'fs_frag'→
69
←
Taking true branch→
277				newcg->cg_cs.cs_nbfree++;
278				if (fs->fs_contigsumsize > 0)
70
←
Assuming field 'fs_contigsumsize' is > 0→
71
←
Taking true branch→
279					setbit(cg_clustersfree(newcg),((((u_int8_t *)((u_int8_t *)(newcg) + (newcg)->cg_clusteroff
)))[(i / fs->fs_frag)>>3] |= 1<<((i / fs->fs_frag
)&(8 -1)))
72
←
Division by zero
280					    i / fs->fs_frag)((((u_int8_t *)((u_int8_t *)(newcg) + (newcg)->cg_clusteroff
)))[(i / fs->fs_frag)>>3] |= 1<<((i / fs->fs_frag
)&(8 -1)));
281			} else if (frags60.1
'frags' is > 0
 > 0) {
61
←
Taking true branch→
282				newcg->cg_cs.cs_nffree += frags;
283				blk = blkmap(fs, cg_blksfree(newcg), i)((((((newcg)->cg_magic != 0x090255) ? (((struct ocg *)(newcg
))->cg_free) : ((u_int8_t *)((u_int8_t *)(newcg) + (newcg)
->cg_freeoff))))[(i) / 8] >> ((i) % 8)) & (0xff >>
 (8 - (fs)->fs_frag)));
62
←
'?' condition is true→
284				ffs_fragacct(fs, blk, newcg->cg_frsum, 1);
63
←
Value assigned to field 'fs_frag'→
285			}
286		}
287		if (fs->fs_contigsumsize > 0) {
288			int32_t *sump = cg_clustersum(newcg)((int32_t *)((u_int8_t *)(newcg) + (newcg)->cg_clustersumoff
));
289			u_char *mapp = cg_clustersfree(newcg)((u_int8_t *)((u_int8_t *)(newcg) + (newcg)->cg_clusteroff
));
290			int map = *mapp++;
291			int bit = 1;
292			int run = 0;
293 
294			for (i = 0; i < newcg->cg_nclusterblks; i++) {
295				if ((map & bit) != 0) {
296					run++;
297				} else if (run != 0) {
298					if (run > fs->fs_contigsumsize)
299						run = fs->fs_contigsumsize;
300					sump[run]++;
301					run = 0;
302				}
303				if ((i & (NBBY8 - 1)) != (NBBY8 - 1)) {
304					bit <<= 1;
305				} else {
306					map = *mapp++;
307					bit = 1;
308				}
309			}
310			if (run != 0) {
311				if (run > fs->fs_contigsumsize)
312					run = fs->fs_contigsumsize;
313				sump[run]++;
314			}
315		}
316		cstotal.cs_nffree += newcg->cg_cs.cs_nffree;
317		cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree;
318		cstotal.cs_nifree += newcg->cg_cs.cs_nifree;
319		cstotal.cs_ndir += newcg->cg_cs.cs_ndir;
320		cs = &fs->fs_cs(fs, c)fs_csp[c];
321		if (memcmp(&newcg->cg_cs, cs, sizeof *cs) != 0 &&
322		    dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
323			memcpy(cs, &newcg->cg_cs, sizeof *cs);
324			sbdirty()sblk.b_dirty = 1;
325		}
326		if (rewritecg) {
327			memcpy(cg, newcg, (size_t)fs->fs_cgsize);
328			dirty(cgbp)(cgbp)->b_dirty = 1;
329			continue;
330		}
331		if (memcmp(newcg, cg, basesize) &&
332		    dofix(&idesc[2], "SUMMARY INFORMATION BAD")) {
333			memcpy(cg, newcg, (size_t)basesize);
334			dirty(cgbp)(cgbp)->b_dirty = 1;
335		}
336		if (usedsoftdep) {
337			for (i = 0; i < inomapsize; i++) {
338				j = cg_inosused(newcg)(((newcg)->cg_magic != 0x090255) ? (((struct ocg *)(newcg)
)->cg_iused) : ((u_int8_t *)((u_int8_t *)(newcg) + (newcg)
->cg_iusedoff)))[i];
339				if ((cg_inosused(cg)(((cg)->cg_magic != 0x090255) ? (((struct ocg *)(cg))->
cg_iused) : ((u_int8_t *)((u_int8_t *)(cg) + (cg)->cg_iusedoff
)))[i] & j) == j)
340					continue;
341				for (k = 0; k < NBBY8; k++) {
342					if ((j & (1 << k)) == 0)
343						continue;
344					if (cg_inosused(cg)(((cg)->cg_magic != 0x090255) ? (((struct ocg *)(cg))->
cg_iused) : ((u_int8_t *)((u_int8_t *)(cg) + (cg)->cg_iusedoff
)))[i] & (1 << k))
345						continue;
346					pwarn("ALLOCATED INODE %llu MARKED FREE\n",
347					      ((ino_t)c * fs->fs_ipg + i * 8) + k);
348				}
349			}
350			for (i = 0; i < blkmapsize; i++) {
351				j = cg_blksfree(cg)(((cg)->cg_magic != 0x090255) ? (((struct ocg *)(cg))->
cg_free) : ((u_int8_t *)((u_int8_t *)(cg) + (cg)->cg_freeoff
)))[i];
352				if ((cg_blksfree(newcg)(((newcg)->cg_magic != 0x090255) ? (((struct ocg *)(newcg)
)->cg_free) : ((u_int8_t *)((u_int8_t *)(newcg) + (newcg)->
cg_freeoff)))[i] & j) == j)
353					continue;
354				for (k = 0; k < NBBY8; k++) {
355					if ((j & (1 << k)) == 0)
356						continue;
357					if (cg_blksfree(newcg)(((newcg)->cg_magic != 0x090255) ? (((struct ocg *)(newcg)
)->cg_free) : ((u_int8_t *)((u_int8_t *)(newcg) + (newcg)->
cg_freeoff)))[i] & (1 << k))
358						continue;
359					pwarn("ALLOCATED FRAG %lld MARKED FREE\n",
360					      ((long long)c * fs->fs_fpg + i * 8) + k);
361				}
362			}
363		}
364		if (memcmp(cg_inosused(newcg)(((newcg)->cg_magic != 0x090255) ? (((struct ocg *)(newcg)
)->cg_iused) : ((u_int8_t *)((u_int8_t *)(newcg) + (newcg)
->cg_iusedoff))), cg_inosused(cg)(((cg)->cg_magic != 0x090255) ? (((struct ocg *)(cg))->
cg_iused) : ((u_int8_t *)((u_int8_t *)(cg) + (cg)->cg_iusedoff
))),
365			   mapsize) != 0 &&
366		    dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
367			memmove(cg_inosused(cg)(((cg)->cg_magic != 0x090255) ? (((struct ocg *)(cg))->
cg_iused) : ((u_int8_t *)((u_int8_t *)(cg) + (cg)->cg_iusedoff
))), cg_inosused(newcg)(((newcg)->cg_magic != 0x090255) ? (((struct ocg *)(newcg)
)->cg_iused) : ((u_int8_t *)((u_int8_t *)(newcg) + (newcg)
->cg_iusedoff))),
368				(size_t)mapsize);
369			dirty(cgbp)(cgbp)->b_dirty = 1;
370		}
371	}
372	info_fn = NULL((void *)0);
373	if (fs->fs_postblformat == FS_42POSTBLFMT-1)
374		fs->fs_nrpos = savednrpos;
375 
376	sumsize = sizeof(cstotal) - sizeof(cstotal.cs_spare);
377	if (memcmp(&cstotal, &fs->fs_cstotal, sumsize) != 0
378	    && dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
379		memcpy(&fs->fs_cstotal, &cstotal, sumsize);
380		fs->fs_ronly = 0;
381		fs->fs_fmod = 0;
382		sbdirty()sblk.b_dirty = 1;
383	}
384}