xref: /freebsd/sbin/growfs/growfs.c (revision ddd5b8e9b4d8957fce018c520657cdfa4ecffad3)
1 /*
2  * Copyright (c) 1980, 1989, 1993 The Regents of the University of California.
3  * Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz
4  * Copyright (c) 2012 The FreeBSD Foundation
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Christoph Herrmann and Thomas-Henning von Kamptz, Munich and Frankfurt.
9  *
10  * Portions of this software were developed by Edward Tomasz Napierala
11  * under sponsorship from the FreeBSD Foundation.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. All advertising materials mentioning features or use of this software
22  *    must display the following acknowledgment:
23  *      This product includes software developed by the University of
24  *      California, Berkeley and its contributors, as well as Christoph
25  *      Herrmann and Thomas-Henning von Kamptz.
26  * 4. Neither the name of the University nor the names of its contributors
27  *    may be used to endorse or promote products derived from this software
28  *    without specific prior written permission.
29  *
30  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
31  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
34  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
36  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
37  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
38  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
39  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40  * SUCH DAMAGE.
41  *
42  * $TSHeader: src/sbin/growfs/growfs.c,v 1.5 2000/12/12 19:31:00 tomsoft Exp $
43  *
44  */
45 
46 #ifndef lint
47 static const char copyright[] =
48 "@(#) Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz\n\
49 Copyright (c) 1980, 1989, 1993 The Regents of the University of California.\n\
50 All rights reserved.\n";
51 #endif /* not lint */
52 
53 #include <sys/cdefs.h>
54 __FBSDID("$FreeBSD$");
55 
56 #include <sys/param.h>
57 #include <sys/ioctl.h>
58 #include <sys/stat.h>
59 #include <sys/disk.h>
60 #include <sys/ucred.h>
61 #include <sys/mount.h>
62 
63 #include <stdio.h>
64 #include <paths.h>
65 #include <ctype.h>
66 #include <err.h>
67 #include <fcntl.h>
68 #include <fstab.h>
69 #include <inttypes.h>
70 #include <limits.h>
71 #include <mntopts.h>
72 #include <paths.h>
73 #include <stdlib.h>
74 #include <stdint.h>
75 #include <string.h>
76 #include <time.h>
77 #include <unistd.h>
78 #include <ufs/ufs/dinode.h>
79 #include <ufs/ffs/fs.h>
80 #include <libutil.h>
81 
82 #include "debug.h"
83 
84 #ifdef FS_DEBUG
85 int	_dbg_lvl_ = (DL_INFO);	/* DL_TRC */
86 #endif /* FS_DEBUG */
87 
88 static union {
89 	struct fs	fs;
90 	char		pad[SBLOCKSIZE];
91 } fsun1, fsun2;
92 #define	sblock	fsun1.fs	/* the new superblock */
93 #define	osblock	fsun2.fs	/* the old superblock */
94 
95 /*
96  * Possible superblock locations ordered from most to least likely.
97  */
98 static int sblock_try[] = SBLOCKSEARCH;
99 static ufs2_daddr_t sblockloc;
100 
101 static union {
102 	struct cg	cg;
103 	char		pad[MAXBSIZE];
104 } cgun1, cgun2;
105 #define	acg	cgun1.cg	/* a cylinder cgroup (new) */
106 #define	aocg	cgun2.cg	/* an old cylinder group */
107 
108 static struct csum	*fscs;	/* cylinder summary */
109 
110 static void	growfs(int, int, unsigned int);
111 static void	rdfs(ufs2_daddr_t, size_t, void *, int);
112 static void	wtfs(ufs2_daddr_t, size_t, void *, int, unsigned int);
113 static int	charsperline(void);
114 static void	usage(void);
115 static int	isblock(struct fs *, unsigned char *, int);
116 static void	clrblock(struct fs *, unsigned char *, int);
117 static void	setblock(struct fs *, unsigned char *, int);
118 static void	initcg(int, time_t, int, unsigned int);
119 static void	updjcg(int, time_t, int, int, unsigned int);
120 static void	updcsloc(time_t, int, int, unsigned int);
121 static void	frag_adjust(ufs2_daddr_t, int);
122 static void	updclst(int);
123 static void	mount_reload(const struct statfs *stfs);
124 
125 /*
126  * Here we actually start growing the file system. We basically read the
127  * cylinder summary from the first cylinder group as we want to update
128  * this on the fly during our various operations. First we handle the
129  * changes in the former last cylinder group. Afterwards we create all new
130  * cylinder groups.  Now we handle the cylinder group containing the
131  * cylinder summary which might result in a relocation of the whole
132  * structure.  In the end we write back the updated cylinder summary, the
133  * new superblock, and slightly patched versions of the super block
134  * copies.
135  */
136 static void
137 growfs(int fsi, int fso, unsigned int Nflag)
138 {
139 	DBG_FUNC("growfs")
140 	time_t modtime;
141 	uint cylno;
142 	int i, j, width;
143 	char tmpbuf[100];
144 	static int randinit = 0;
145 
146 	DBG_ENTER;
147 
148 	if (!randinit) {
149 		randinit = 1;
150 		srandomdev();
151 	}
152 	time(&modtime);
153 
154 	/*
155 	 * Get the cylinder summary into the memory.
156 	 */
157 	fscs = (struct csum *)calloc((size_t)1, (size_t)sblock.fs_cssize);
158 	if (fscs == NULL)
159 		errx(1, "calloc failed");
160 	for (i = 0; i < osblock.fs_cssize; i += osblock.fs_bsize) {
161 		rdfs(fsbtodb(&osblock, osblock.fs_csaddr +
162 		    numfrags(&osblock, i)), (size_t)MIN(osblock.fs_cssize - i,
163 		    osblock.fs_bsize), (void *)(((char *)fscs) + i), fsi);
164 	}
165 
166 #ifdef FS_DEBUG
167 	{
168 		struct csum *dbg_csp;
169 		int dbg_csc;
170 		char dbg_line[80];
171 
172 		dbg_csp = fscs;
173 
174 		for (dbg_csc = 0; dbg_csc < osblock.fs_ncg; dbg_csc++) {
175 			snprintf(dbg_line, sizeof(dbg_line),
176 			    "%d. old csum in old location", dbg_csc);
177 			DBG_DUMP_CSUM(&osblock, dbg_line, dbg_csp++);
178 		}
179 	}
180 #endif /* FS_DEBUG */
181 	DBG_PRINT0("fscs read\n");
182 
183 	/*
184 	 * Do all needed changes in the former last cylinder group.
185 	 */
186 	updjcg(osblock.fs_ncg - 1, modtime, fsi, fso, Nflag);
187 
188 	/*
189 	 * Dump out summary information about file system.
190 	 */
191 #ifdef FS_DEBUG
192 #define B2MBFACTOR (1 / (1024.0 * 1024.0))
193 	printf("growfs: %.1fMB (%jd sectors) block size %d, fragment size %d\n",
194 	    (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,
195 	    (intmax_t)fsbtodb(&sblock, sblock.fs_size), sblock.fs_bsize,
196 	    sblock.fs_fsize);
197 	printf("\tusing %d cylinder groups of %.2fMB, %d blks, %d inodes.\n",
198 	    sblock.fs_ncg, (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
199 	    sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);
200 	if (sblock.fs_flags & FS_DOSOFTDEP)
201 		printf("\twith soft updates\n");
202 #undef B2MBFACTOR
203 #endif /* FS_DEBUG */
204 
205 	/*
206 	 * Now build the cylinders group blocks and
207 	 * then print out indices of cylinder groups.
208 	 */
209 	printf("super-block backups (for fsck -b #) at:\n");
210 	i = 0;
211 	width = charsperline();
212 
213 	/*
214 	 * Iterate for only the new cylinder groups.
215 	 */
216 	for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) {
217 		initcg(cylno, modtime, fso, Nflag);
218 		j = sprintf(tmpbuf, " %jd%s",
219 		    (intmax_t)fsbtodb(&sblock, cgsblock(&sblock, cylno)),
220 		    cylno < (sblock.fs_ncg - 1) ? "," : "" );
221 		if (i + j >= width) {
222 			printf("\n");
223 			i = 0;
224 		}
225 		i += j;
226 		printf("%s", tmpbuf);
227 		fflush(stdout);
228 	}
229 	printf("\n");
230 
231 	/*
232 	 * Do all needed changes in the first cylinder group.
233 	 * allocate blocks in new location
234 	 */
235 	updcsloc(modtime, fsi, fso, Nflag);
236 
237 	/*
238 	 * Now write the cylinder summary back to disk.
239 	 */
240 	for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
241 		wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
242 		    (size_t)MIN(sblock.fs_cssize - i, sblock.fs_bsize),
243 		    (void *)(((char *)fscs) + i), fso, Nflag);
244 	}
245 	DBG_PRINT0("fscs written\n");
246 
247 #ifdef FS_DEBUG
248 	{
249 		struct csum	*dbg_csp;
250 		int	dbg_csc;
251 		char	dbg_line[80];
252 
253 		dbg_csp = fscs;
254 		for (dbg_csc = 0; dbg_csc < sblock.fs_ncg; dbg_csc++) {
255 			snprintf(dbg_line, sizeof(dbg_line),
256 			    "%d. new csum in new location", dbg_csc);
257 			DBG_DUMP_CSUM(&sblock, dbg_line, dbg_csp++);
258 		}
259 	}
260 #endif /* FS_DEBUG */
261 
262 	/*
263 	 * Now write the new superblock back to disk.
264 	 */
265 	sblock.fs_time = modtime;
266 	wtfs(sblockloc, (size_t)SBLOCKSIZE, (void *)&sblock, fso, Nflag);
267 	DBG_PRINT0("sblock written\n");
268 	DBG_DUMP_FS(&sblock, "new initial sblock");
269 
270 	/*
271 	 * Clean up the dynamic fields in our superblock copies.
272 	 */
273 	sblock.fs_fmod = 0;
274 	sblock.fs_clean = 1;
275 	sblock.fs_ronly = 0;
276 	sblock.fs_cgrotor = 0;
277 	sblock.fs_state = 0;
278 	memset((void *)&sblock.fs_fsmnt, 0, sizeof(sblock.fs_fsmnt));
279 	sblock.fs_flags &= FS_DOSOFTDEP;
280 
281 	/*
282 	 * XXX
283 	 * The following fields are currently distributed from the superblock
284 	 * to the copies:
285 	 *     fs_minfree
286 	 *     fs_rotdelay
287 	 *     fs_maxcontig
288 	 *     fs_maxbpg
289 	 *     fs_minfree,
290 	 *     fs_optim
291 	 *     fs_flags regarding SOFTPDATES
292 	 *
293 	 * We probably should rather change the summary for the cylinder group
294 	 * statistics here to the value of what would be in there, if the file
295 	 * system were created initially with the new size. Therefor we still
296 	 * need to find an easy way of calculating that.
297 	 * Possibly we can try to read the first superblock copy and apply the
298 	 * "diffed" stats between the old and new superblock by still copying
299 	 * certain parameters onto that.
300 	 */
301 
302 	/*
303 	 * Write out the duplicate super blocks.
304 	 */
305 	for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
306 		wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
307 		    (size_t)SBLOCKSIZE, (void *)&sblock, fso, Nflag);
308 	}
309 	DBG_PRINT0("sblock copies written\n");
310 	DBG_DUMP_FS(&sblock, "new other sblocks");
311 
312 	DBG_LEAVE;
313 	return;
314 }
315 
316 /*
317  * This creates a new cylinder group structure, for more details please see
318  * the source of newfs(8), as this function is taken over almost unchanged.
319  * As this is never called for the first cylinder group, the special
320  * provisions for that case are removed here.
321  */
322 static void
323 initcg(int cylno, time_t modtime, int fso, unsigned int Nflag)
324 {
325 	DBG_FUNC("initcg")
326 	static caddr_t iobuf;
327 	long blkno, start;
328 	ino_t ino;
329 	ufs2_daddr_t i, cbase, dmax;
330 	struct ufs1_dinode *dp1;
331 	struct csum *cs;
332 	uint j, d, dupper, dlower;
333 
334 	if (iobuf == NULL && (iobuf = malloc(sblock.fs_bsize * 3)) == NULL)
335 		errx(37, "panic: cannot allocate I/O buffer");
336 
337 	/*
338 	 * Determine block bounds for cylinder group.
339 	 * Allow space for super block summary information in first
340 	 * cylinder group.
341 	 */
342 	cbase = cgbase(&sblock, cylno);
343 	dmax = cbase + sblock.fs_fpg;
344 	if (dmax > sblock.fs_size)
345 		dmax = sblock.fs_size;
346 	dlower = cgsblock(&sblock, cylno) - cbase;
347 	dupper = cgdmin(&sblock, cylno) - cbase;
348 	if (cylno == 0)	/* XXX fscs may be relocated */
349 		dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
350 	cs = &fscs[cylno];
351 	memset(&acg, 0, sblock.fs_cgsize);
352 	acg.cg_time = modtime;
353 	acg.cg_magic = CG_MAGIC;
354 	acg.cg_cgx = cylno;
355 	acg.cg_niblk = sblock.fs_ipg;
356 	acg.cg_initediblk = sblock.fs_ipg < 2 * INOPB(&sblock) ?
357 	    sblock.fs_ipg : 2 * INOPB(&sblock);
358 	acg.cg_ndblk = dmax - cbase;
359 	if (sblock.fs_contigsumsize > 0)
360 		acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
361 	start = &acg.cg_space[0] - (u_char *)(&acg.cg_firstfield);
362 	if (sblock.fs_magic == FS_UFS2_MAGIC) {
363 		acg.cg_iusedoff = start;
364 	} else {
365 		acg.cg_old_ncyl = sblock.fs_old_cpg;
366 		acg.cg_old_time = acg.cg_time;
367 		acg.cg_time = 0;
368 		acg.cg_old_niblk = acg.cg_niblk;
369 		acg.cg_niblk = 0;
370 		acg.cg_initediblk = 0;
371 		acg.cg_old_btotoff = start;
372 		acg.cg_old_boff = acg.cg_old_btotoff +
373 		    sblock.fs_old_cpg * sizeof(int32_t);
374 		acg.cg_iusedoff = acg.cg_old_boff +
375 		    sblock.fs_old_cpg * sizeof(u_int16_t);
376 	}
377 	acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
378 	acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);
379 	if (sblock.fs_contigsumsize > 0) {
380 		acg.cg_clustersumoff =
381 		    roundup(acg.cg_nextfreeoff, sizeof(u_int32_t));
382 		acg.cg_clustersumoff -= sizeof(u_int32_t);
383 		acg.cg_clusteroff = acg.cg_clustersumoff +
384 		    (sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);
385 		acg.cg_nextfreeoff = acg.cg_clusteroff +
386 		    howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
387 	}
388 	if (acg.cg_nextfreeoff > (unsigned)sblock.fs_cgsize) {
389 		/*
390 		 * This should never happen as we would have had that panic
391 		 * already on file system creation
392 		 */
393 		errx(37, "panic: cylinder group too big");
394 	}
395 	acg.cg_cs.cs_nifree += sblock.fs_ipg;
396 	if (cylno == 0)
397 		for (ino = 0; ino < ROOTINO; ino++) {
398 			setbit(cg_inosused(&acg), ino);
399 			acg.cg_cs.cs_nifree--;
400 		}
401 	/*
402 	 * For the old file system, we have to initialize all the inodes.
403 	 */
404 	if (sblock.fs_magic == FS_UFS1_MAGIC) {
405 		bzero(iobuf, sblock.fs_bsize);
406 		for (i = 0; i < sblock.fs_ipg / INOPF(&sblock);
407 		    i += sblock.fs_frag) {
408 			dp1 = (struct ufs1_dinode *)(void *)iobuf;
409 			for (j = 0; j < INOPB(&sblock); j++) {
410 				dp1->di_gen = random();
411 				dp1++;
412 			}
413 			wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
414 			    sblock.fs_bsize, iobuf, fso, Nflag);
415 		}
416 	}
417 	if (cylno > 0) {
418 		/*
419 		 * In cylno 0, beginning space is reserved
420 		 * for boot and super blocks.
421 		 */
422 		for (d = 0; d < dlower; d += sblock.fs_frag) {
423 			blkno = d / sblock.fs_frag;
424 			setblock(&sblock, cg_blksfree(&acg), blkno);
425 			if (sblock.fs_contigsumsize > 0)
426 				setbit(cg_clustersfree(&acg), blkno);
427 			acg.cg_cs.cs_nbfree++;
428 		}
429 		sblock.fs_dsize += dlower;
430 	}
431 	sblock.fs_dsize += acg.cg_ndblk - dupper;
432 	if ((i = dupper % sblock.fs_frag)) {
433 		acg.cg_frsum[sblock.fs_frag - i]++;
434 		for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
435 			setbit(cg_blksfree(&acg), dupper);
436 			acg.cg_cs.cs_nffree++;
437 		}
438 	}
439 	for (d = dupper; d + sblock.fs_frag <= acg.cg_ndblk;
440 	    d += sblock.fs_frag) {
441 		blkno = d / sblock.fs_frag;
442 		setblock(&sblock, cg_blksfree(&acg), blkno);
443 		if (sblock.fs_contigsumsize > 0)
444 			setbit(cg_clustersfree(&acg), blkno);
445 		acg.cg_cs.cs_nbfree++;
446 	}
447 	if (d < acg.cg_ndblk) {
448 		acg.cg_frsum[acg.cg_ndblk - d]++;
449 		for (; d < acg.cg_ndblk; d++) {
450 			setbit(cg_blksfree(&acg), d);
451 			acg.cg_cs.cs_nffree++;
452 		}
453 	}
454 	if (sblock.fs_contigsumsize > 0) {
455 		int32_t *sump = cg_clustersum(&acg);
456 		u_char *mapp = cg_clustersfree(&acg);
457 		int map = *mapp++;
458 		int bit = 1;
459 		int run = 0;
460 
461 		for (i = 0; i < acg.cg_nclusterblks; i++) {
462 			if ((map & bit) != 0)
463 				run++;
464 			else if (run != 0) {
465 				if (run > sblock.fs_contigsumsize)
466 					run = sblock.fs_contigsumsize;
467 				sump[run]++;
468 				run = 0;
469 			}
470 			if ((i & (CHAR_BIT - 1)) != CHAR_BIT - 1)
471 				bit <<= 1;
472 			else {
473 				map = *mapp++;
474 				bit = 1;
475 			}
476 		}
477 		if (run != 0) {
478 			if (run > sblock.fs_contigsumsize)
479 				run = sblock.fs_contigsumsize;
480 			sump[run]++;
481 		}
482 	}
483 	sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;
484 	sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
485 	sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
486 	sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
487 	*cs = acg.cg_cs;
488 
489 	memcpy(iobuf, &acg, sblock.fs_cgsize);
490 	memset(iobuf + sblock.fs_cgsize, '\0',
491 	    sblock.fs_bsize * 3 - sblock.fs_cgsize);
492 
493 	wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
494 	    sblock.fs_bsize * 3, iobuf, fso, Nflag);
495 	DBG_DUMP_CG(&sblock, "new cg", &acg);
496 
497 	DBG_LEAVE;
498 	return;
499 }
500 
501 /*
502  * Here we add or subtract (sign +1/-1) the available fragments in a given
503  * block to or from the fragment statistics. By subtracting before and adding
504  * after an operation on the free frag map we can easy update the fragment
505  * statistic, which seems to be otherwise a rather complex operation.
506  */
507 static void
508 frag_adjust(ufs2_daddr_t frag, int sign)
509 {
510 	DBG_FUNC("frag_adjust")
511 	int fragsize;
512 	int f;
513 
514 	DBG_ENTER;
515 
516 	fragsize = 0;
517 	/*
518 	 * Here frag only needs to point to any fragment in the block we want
519 	 * to examine.
520 	 */
521 	for (f = rounddown(frag, sblock.fs_frag);
522 	    f < roundup(frag + 1, sblock.fs_frag); f++) {
523 		/*
524 		 * Count contiguous free fragments.
525 		 */
526 		if (isset(cg_blksfree(&acg), f)) {
527 			fragsize++;
528 		} else {
529 			if (fragsize && fragsize < sblock.fs_frag) {
530 				/*
531 				 * We found something in between.
532 				 */
533 				acg.cg_frsum[fragsize] += sign;
534 				DBG_PRINT2("frag_adjust [%d]+=%d\n",
535 				    fragsize, sign);
536 			}
537 			fragsize = 0;
538 		}
539 	}
540 	if (fragsize && fragsize < sblock.fs_frag) {
541 		/*
542 		 * We found something.
543 		 */
544 		acg.cg_frsum[fragsize] += sign;
545 		DBG_PRINT2("frag_adjust [%d]+=%d\n", fragsize, sign);
546 	}
547 	DBG_PRINT2("frag_adjust [[%d]]+=%d\n", fragsize, sign);
548 
549 	DBG_LEAVE;
550 	return;
551 }
552 
553 /*
554  * Here we do all needed work for the former last cylinder group. It has to be
555  * changed in any case, even if the file system ended exactly on the end of
556  * this group, as there is some slightly inconsistent handling of the number
557  * of cylinders in the cylinder group. We start again by reading the cylinder
558  * group from disk. If the last block was not fully available, we first handle
559  * the missing fragments, then we handle all new full blocks in that file
560  * system and finally we handle the new last fragmented block in the file
561  * system.  We again have to handle the fragment statistics rotational layout
562  * tables and cluster summary during all those operations.
563  */
564 static void
565 updjcg(int cylno, time_t modtime, int fsi, int fso, unsigned int Nflag)
566 {
567 	DBG_FUNC("updjcg")
568 	ufs2_daddr_t cbase, dmax, dupper;
569 	struct csum *cs;
570 	int i, k;
571 	int j = 0;
572 
573 	DBG_ENTER;
574 
575 	/*
576 	 * Read the former last (joining) cylinder group from disk, and make
577 	 * a copy.
578 	 */
579 	rdfs(fsbtodb(&osblock, cgtod(&osblock, cylno)),
580 	    (size_t)osblock.fs_cgsize, (void *)&aocg, fsi);
581 	DBG_PRINT0("jcg read\n");
582 	DBG_DUMP_CG(&sblock, "old joining cg", &aocg);
583 
584 	memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
585 
586 	/*
587 	 * If the cylinder group had already its new final size almost
588 	 * nothing is to be done ... except:
589 	 * For some reason the value of cg_ncyl in the last cylinder group has
590 	 * to be zero instead of fs_cpg. As this is now no longer the last
591 	 * cylinder group we have to change that value now to fs_cpg.
592 	 */
593 
594 	if (cgbase(&osblock, cylno + 1) == osblock.fs_size) {
595 		if (sblock.fs_magic == FS_UFS1_MAGIC)
596 			acg.cg_old_ncyl = sblock.fs_old_cpg;
597 
598 		wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
599 		    (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
600 		DBG_PRINT0("jcg written\n");
601 		DBG_DUMP_CG(&sblock, "new joining cg", &acg);
602 
603 		DBG_LEAVE;
604 		return;
605 	}
606 
607 	/*
608 	 * Set up some variables needed later.
609 	 */
610 	cbase = cgbase(&sblock, cylno);
611 	dmax = cbase + sblock.fs_fpg;
612 	if (dmax > sblock.fs_size)
613 		dmax = sblock.fs_size;
614 	dupper = cgdmin(&sblock, cylno) - cbase;
615 	if (cylno == 0) /* XXX fscs may be relocated */
616 		dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
617 
618 	/*
619 	 * Set pointer to the cylinder summary for our cylinder group.
620 	 */
621 	cs = fscs + cylno;
622 
623 	/*
624 	 * Touch the cylinder group, update all fields in the cylinder group as
625 	 * needed, update the free space in the superblock.
626 	 */
627 	acg.cg_time = modtime;
628 	if ((unsigned)cylno == sblock.fs_ncg - 1) {
629 		/*
630 		 * This is still the last cylinder group.
631 		 */
632 		if (sblock.fs_magic == FS_UFS1_MAGIC)
633 			acg.cg_old_ncyl =
634 			    sblock.fs_old_ncyl % sblock.fs_old_cpg;
635 	} else {
636 		acg.cg_old_ncyl = sblock.fs_old_cpg;
637 	}
638 	DBG_PRINT2("jcg dbg: %d %u", cylno, sblock.fs_ncg);
639 #ifdef FS_DEBUG
640 	if (sblock.fs_magic == FS_UFS1_MAGIC)
641 		DBG_PRINT2("%d %u", acg.cg_old_ncyl, sblock.fs_old_cpg);
642 #endif
643 	DBG_PRINT0("\n");
644 	acg.cg_ndblk = dmax - cbase;
645 	sblock.fs_dsize += acg.cg_ndblk - aocg.cg_ndblk;
646 	if (sblock.fs_contigsumsize > 0)
647 		acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
648 
649 	/*
650 	 * Now we have to update the free fragment bitmap for our new free
651 	 * space.  There again we have to handle the fragmentation and also
652 	 * the rotational layout tables and the cluster summary.  This is
653 	 * also done per fragment for the first new block if the old file
654 	 * system end was not on a block boundary, per fragment for the new
655 	 * last block if the new file system end is not on a block boundary,
656 	 * and per block for all space in between.
657 	 *
658 	 * Handle the first new block here if it was partially available
659 	 * before.
660 	 */
661 	if (osblock.fs_size % sblock.fs_frag) {
662 		if (roundup(osblock.fs_size, sblock.fs_frag) <=
663 		    sblock.fs_size) {
664 			/*
665 			 * The new space is enough to fill at least this
666 			 * block
667 			 */
668 			j = 0;
669 			for (i = roundup(osblock.fs_size - cbase,
670 			    sblock.fs_frag) - 1; i >= osblock.fs_size - cbase;
671 			    i--) {
672 				setbit(cg_blksfree(&acg), i);
673 				acg.cg_cs.cs_nffree++;
674 				j++;
675 			}
676 
677 			/*
678 			 * Check if the fragment just created could join an
679 			 * already existing fragment at the former end of the
680 			 * file system.
681 			 */
682 			if (isblock(&sblock, cg_blksfree(&acg),
683 			    ((osblock.fs_size - cgbase(&sblock, cylno)) /
684 			     sblock.fs_frag))) {
685 				/*
686 				 * The block is now completely available.
687 				 */
688 				DBG_PRINT0("block was\n");
689 				acg.cg_frsum[osblock.fs_size % sblock.fs_frag]--;
690 				acg.cg_cs.cs_nbfree++;
691 				acg.cg_cs.cs_nffree -= sblock.fs_frag;
692 				k = rounddown(osblock.fs_size - cbase,
693 				    sblock.fs_frag);
694 				updclst((osblock.fs_size - cbase) /
695 				    sblock.fs_frag);
696 			} else {
697 				/*
698 				 * Lets rejoin a possible partially growed
699 				 * fragment.
700 				 */
701 				k = 0;
702 				while (isset(cg_blksfree(&acg), i) &&
703 				    (i >= rounddown(osblock.fs_size - cbase,
704 				    sblock.fs_frag))) {
705 					i--;
706 					k++;
707 				}
708 				if (k)
709 					acg.cg_frsum[k]--;
710 				acg.cg_frsum[k + j]++;
711 			}
712 		} else {
713 			/*
714 			 * We only grow by some fragments within this last
715 			 * block.
716 			 */
717 			for (i = sblock.fs_size - cbase - 1;
718 			    i >= osblock.fs_size - cbase; i--) {
719 				setbit(cg_blksfree(&acg), i);
720 				acg.cg_cs.cs_nffree++;
721 				j++;
722 			}
723 			/*
724 			 * Lets rejoin a possible partially growed fragment.
725 			 */
726 			k = 0;
727 			while (isset(cg_blksfree(&acg), i) &&
728 			    (i >= rounddown(osblock.fs_size - cbase,
729 			    sblock.fs_frag))) {
730 				i--;
731 				k++;
732 			}
733 			if (k)
734 				acg.cg_frsum[k]--;
735 			acg.cg_frsum[k + j]++;
736 		}
737 	}
738 
739 	/*
740 	 * Handle all new complete blocks here.
741 	 */
742 	for (i = roundup(osblock.fs_size - cbase, sblock.fs_frag);
743 	    i + sblock.fs_frag <= dmax - cbase;	/* XXX <= or only < ? */
744 	    i += sblock.fs_frag) {
745 		j = i / sblock.fs_frag;
746 		setblock(&sblock, cg_blksfree(&acg), j);
747 		updclst(j);
748 		acg.cg_cs.cs_nbfree++;
749 	}
750 
751 	/*
752 	 * Handle the last new block if there are stll some new fragments left.
753 	 * Here we don't have to bother about the cluster summary or the even
754 	 * the rotational layout table.
755 	 */
756 	if (i < (dmax - cbase)) {
757 		acg.cg_frsum[dmax - cbase - i]++;
758 		for (; i < dmax - cbase; i++) {
759 			setbit(cg_blksfree(&acg), i);
760 			acg.cg_cs.cs_nffree++;
761 		}
762 	}
763 
764 	sblock.fs_cstotal.cs_nffree +=
765 	    (acg.cg_cs.cs_nffree - aocg.cg_cs.cs_nffree);
766 	sblock.fs_cstotal.cs_nbfree +=
767 	    (acg.cg_cs.cs_nbfree - aocg.cg_cs.cs_nbfree);
768 	/*
769 	 * The following statistics are not changed here:
770 	 *     sblock.fs_cstotal.cs_ndir
771 	 *     sblock.fs_cstotal.cs_nifree
772 	 * As the statistics for this cylinder group are ready, copy it to
773 	 * the summary information array.
774 	 */
775 	*cs = acg.cg_cs;
776 
777 	/*
778 	 * Write the updated "joining" cylinder group back to disk.
779 	 */
780 	wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), (size_t)sblock.fs_cgsize,
781 	    (void *)&acg, fso, Nflag);
782 	DBG_PRINT0("jcg written\n");
783 	DBG_DUMP_CG(&sblock, "new joining cg", &acg);
784 
785 	DBG_LEAVE;
786 	return;
787 }
788 
789 /*
790  * Here we update the location of the cylinder summary. We have two possible
791  * ways of growing the cylinder summary:
792  * (1)	We can try to grow the summary in the current location, and relocate
793  *	possibly used blocks within the current cylinder group.
794  * (2)	Alternatively we can relocate the whole cylinder summary to the first
795  *	new completely empty cylinder group. Once the cylinder summary is no
796  *	longer in the beginning of the first cylinder group you should never
797  *	use a version of fsck which is not aware of the possibility to have
798  *	this structure in a non standard place.
799  * Option (2) is considered to be less intrusive to the structure of the file-
800  * system, so that's the one being used.
801  */
802 static void
803 updcsloc(time_t modtime, int fsi, int fso, unsigned int Nflag)
804 {
805 	DBG_FUNC("updcsloc")
806 	struct csum *cs;
807 	int ocscg, ncscg;
808 	ufs2_daddr_t d;
809 	int lcs = 0;
810 	int block;
811 
812 	DBG_ENTER;
813 
814 	if (howmany(sblock.fs_cssize, sblock.fs_fsize) ==
815 	    howmany(osblock.fs_cssize, osblock.fs_fsize)) {
816 		/*
817 		 * No new fragment needed.
818 		 */
819 		DBG_LEAVE;
820 		return;
821 	}
822 	ocscg = dtog(&osblock, osblock.fs_csaddr);
823 	cs = fscs + ocscg;
824 
825 	/*
826 	 * Read original cylinder group from disk, and make a copy.
827 	 * XXX	If Nflag is set in some very rare cases we now miss
828 	 *	some changes done in updjcg by reading the unmodified
829 	 *	block from disk.
830 	 */
831 	rdfs(fsbtodb(&osblock, cgtod(&osblock, ocscg)),
832 	    (size_t)osblock.fs_cgsize, (void *)&aocg, fsi);
833 	DBG_PRINT0("oscg read\n");
834 	DBG_DUMP_CG(&sblock, "old summary cg", &aocg);
835 
836 	memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
837 
838 	/*
839 	 * Touch the cylinder group, set up local variables needed later
840 	 * and update the superblock.
841 	 */
842 	acg.cg_time = modtime;
843 
844 	/*
845 	 * XXX	In the case of having active snapshots we may need much more
846 	 *	blocks for the copy on write. We need each block twice, and
847 	 *	also up to 8*3 blocks for indirect blocks for all possible
848 	 *	references.
849 	 */
850 	/*
851 	 * There is not enough space in the old cylinder group to
852 	 * relocate all blocks as needed, so we relocate the whole
853 	 * cylinder group summary to a new group. We try to use the
854 	 * first complete new cylinder group just created. Within the
855 	 * cylinder group we align the area immediately after the
856 	 * cylinder group information location in order to be as
857 	 * close as possible to the original implementation of ffs.
858 	 *
859 	 * First we have to make sure we'll find enough space in the
860 	 * new cylinder group. If not, then we currently give up.
861 	 * We start with freeing everything which was used by the
862 	 * fragments of the old cylinder summary in the current group.
863 	 * Now we write back the group meta data, read in the needed
864 	 * meta data from the new cylinder group, and start allocating
865 	 * within that group. Here we can assume, the group to be
866 	 * completely empty. Which makes the handling of fragments and
867 	 * clusters a lot easier.
868 	 */
869 	DBG_TRC;
870 	if (sblock.fs_ncg - osblock.fs_ncg < 2)
871 		errx(2, "panic: not enough space");
872 
873 	/*
874 	 * Point "d" to the first fragment not used by the cylinder
875 	 * summary.
876 	 */
877 	d = osblock.fs_csaddr + (osblock.fs_cssize / osblock.fs_fsize);
878 
879 	/*
880 	 * Set up last cluster size ("lcs") already here. Calculate
881 	 * the size for the trailing cluster just behind where "d"
882 	 * points to.
883 	 */
884 	if (sblock.fs_contigsumsize > 0) {
885 		for (block = howmany(d % sblock.fs_fpg, sblock.fs_frag),
886 		    lcs = 0; lcs < sblock.fs_contigsumsize; block++, lcs++) {
887 			if (isclr(cg_clustersfree(&acg), block))
888 				break;
889 		}
890 	}
891 
892 	/*
893 	 * Point "d" to the last frag used by the cylinder summary.
894 	 */
895 	d--;
896 
897 	DBG_PRINT1("d=%jd\n", (intmax_t)d);
898 	if ((d + 1) % sblock.fs_frag) {
899 		/*
900 		 * The end of the cylinder summary is not a complete
901 		 * block.
902 		 */
903 		DBG_TRC;
904 		frag_adjust(d % sblock.fs_fpg, -1);
905 		for (; (d + 1) % sblock.fs_frag; d--) {
906 			DBG_PRINT1("d=%jd\n", (intmax_t)d);
907 			setbit(cg_blksfree(&acg), d % sblock.fs_fpg);
908 			acg.cg_cs.cs_nffree++;
909 			sblock.fs_cstotal.cs_nffree++;
910 		}
911 		/*
912 		 * Point "d" to the last fragment of the last
913 		 * (incomplete) block of the cylinder summary.
914 		 */
915 		d++;
916 		frag_adjust(d % sblock.fs_fpg, 1);
917 
918 		if (isblock(&sblock, cg_blksfree(&acg),
919 		    (d % sblock.fs_fpg) / sblock.fs_frag)) {
920 			DBG_PRINT1("d=%jd\n", (intmax_t)d);
921 			acg.cg_cs.cs_nffree -= sblock.fs_frag;
922 			acg.cg_cs.cs_nbfree++;
923 			sblock.fs_cstotal.cs_nffree -= sblock.fs_frag;
924 			sblock.fs_cstotal.cs_nbfree++;
925 			if (sblock.fs_contigsumsize > 0) {
926 				setbit(cg_clustersfree(&acg),
927 				    (d % sblock.fs_fpg) / sblock.fs_frag);
928 				if (lcs < sblock.fs_contigsumsize) {
929 					if (lcs)
930 						cg_clustersum(&acg)[lcs]--;
931 					lcs++;
932 					cg_clustersum(&acg)[lcs]++;
933 				}
934 			}
935 		}
936 		/*
937 		 * Point "d" to the first fragment of the block before
938 		 * the last incomplete block.
939 		 */
940 		d--;
941 	}
942 
943 	DBG_PRINT1("d=%jd\n", (intmax_t)d);
944 	for (d = rounddown(d, sblock.fs_frag); d >= osblock.fs_csaddr;
945 	    d -= sblock.fs_frag) {
946 		DBG_TRC;
947 		DBG_PRINT1("d=%jd\n", (intmax_t)d);
948 		setblock(&sblock, cg_blksfree(&acg),
949 		    (d % sblock.fs_fpg) / sblock.fs_frag);
950 		acg.cg_cs.cs_nbfree++;
951 		sblock.fs_cstotal.cs_nbfree++;
952 		if (sblock.fs_contigsumsize > 0) {
953 			setbit(cg_clustersfree(&acg),
954 			    (d % sblock.fs_fpg) / sblock.fs_frag);
955 			/*
956 			 * The last cluster size is already set up.
957 			 */
958 			if (lcs < sblock.fs_contigsumsize) {
959 				if (lcs)
960 					cg_clustersum(&acg)[lcs]--;
961 				lcs++;
962 				cg_clustersum(&acg)[lcs]++;
963 			}
964 		}
965 	}
966 	*cs = acg.cg_cs;
967 
968 	/*
969 	 * Now write the former cylinder group containing the cylinder
970 	 * summary back to disk.
971 	 */
972 	wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)),
973 	    (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
974 	DBG_PRINT0("oscg written\n");
975 	DBG_DUMP_CG(&sblock, "old summary cg", &acg);
976 
977 	/*
978 	 * Find the beginning of the new cylinder group containing the
979 	 * cylinder summary.
980 	 */
981 	sblock.fs_csaddr = cgdmin(&sblock, osblock.fs_ncg);
982 	ncscg = dtog(&sblock, sblock.fs_csaddr);
983 	cs = fscs + ncscg;
984 
985 	/*
986 	 * If Nflag is specified, we would now read random data instead
987 	 * of an empty cg structure from disk. So we can't simulate that
988 	 * part for now.
989 	 */
990 	if (Nflag) {
991 		DBG_PRINT0("nscg update skipped\n");
992 		DBG_LEAVE;
993 		return;
994 	}
995 
996 	/*
997 	 * Read the future cylinder group containing the cylinder
998 	 * summary from disk, and make a copy.
999 	 */
1000 	rdfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
1001 	    (size_t)sblock.fs_cgsize, (void *)&aocg, fsi);
1002 	DBG_PRINT0("nscg read\n");
1003 	DBG_DUMP_CG(&sblock, "new summary cg", &aocg);
1004 
1005 	memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
1006 
1007 	/*
1008 	 * Allocate all complete blocks used by the new cylinder
1009 	 * summary.
1010 	 */
1011 	for (d = sblock.fs_csaddr; d + sblock.fs_frag <=
1012 	    sblock.fs_csaddr + (sblock.fs_cssize / sblock.fs_fsize);
1013 	    d += sblock.fs_frag) {
1014 		clrblock(&sblock, cg_blksfree(&acg),
1015 		    (d % sblock.fs_fpg) / sblock.fs_frag);
1016 		acg.cg_cs.cs_nbfree--;
1017 		sblock.fs_cstotal.cs_nbfree--;
1018 		if (sblock.fs_contigsumsize > 0) {
1019 			clrbit(cg_clustersfree(&acg),
1020 			    (d % sblock.fs_fpg) / sblock.fs_frag);
1021 		}
1022 	}
1023 
1024 	/*
1025 	 * Allocate all fragments used by the cylinder summary in the
1026 	 * last block.
1027 	 */
1028 	if (d < sblock.fs_csaddr + (sblock.fs_cssize / sblock.fs_fsize)) {
1029 		for (; d - sblock.fs_csaddr <
1030 		    sblock.fs_cssize/sblock.fs_fsize; d++) {
1031 			clrbit(cg_blksfree(&acg), d % sblock.fs_fpg);
1032 			acg.cg_cs.cs_nffree--;
1033 			sblock.fs_cstotal.cs_nffree--;
1034 		}
1035 		acg.cg_cs.cs_nbfree--;
1036 		acg.cg_cs.cs_nffree += sblock.fs_frag;
1037 		sblock.fs_cstotal.cs_nbfree--;
1038 		sblock.fs_cstotal.cs_nffree += sblock.fs_frag;
1039 		if (sblock.fs_contigsumsize > 0)
1040 			clrbit(cg_clustersfree(&acg),
1041 			    (d % sblock.fs_fpg) / sblock.fs_frag);
1042 
1043 		frag_adjust(d % sblock.fs_fpg, 1);
1044 	}
1045 	/*
1046 	 * XXX	Handle the cluster statistics here in the case this
1047 	 *	cylinder group is now almost full, and the remaining
1048 	 *	space is less then the maximum cluster size. This is
1049 	 *	probably not needed, as you would hardly find a file
1050 	 *	system which has only MAXCSBUFS+FS_MAXCONTIG of free
1051 	 *	space right behind the cylinder group information in
1052 	 *	any new cylinder group.
1053 	 */
1054 
1055 	/*
1056 	 * Update our statistics in the cylinder summary.
1057 	 */
1058 	*cs = acg.cg_cs;
1059 
1060 	/*
1061 	 * Write the new cylinder group containing the cylinder summary
1062 	 * back to disk.
1063 	 */
1064 	wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
1065 	    (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
1066 	DBG_PRINT0("nscg written\n");
1067 	DBG_DUMP_CG(&sblock, "new summary cg", &acg);
1068 
1069 	DBG_LEAVE;
1070 	return;
1071 }
1072 
1073 /*
1074  * Here we read some block(s) from disk.
1075  */
1076 static void
1077 rdfs(ufs2_daddr_t bno, size_t size, void *bf, int fsi)
1078 {
1079 	DBG_FUNC("rdfs")
1080 	ssize_t	n;
1081 
1082 	DBG_ENTER;
1083 
1084 	if (bno < 0)
1085 		err(32, "rdfs: attempting to read negative block number");
1086 	if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0)
1087 		err(33, "rdfs: seek error: %jd", (intmax_t)bno);
1088 	n = read(fsi, bf, size);
1089 	if (n != (ssize_t)size)
1090 		err(34, "rdfs: read error: %jd", (intmax_t)bno);
1091 
1092 	DBG_LEAVE;
1093 	return;
1094 }
1095 
1096 /*
1097  * Here we write some block(s) to disk.
1098  */
1099 static void
1100 wtfs(ufs2_daddr_t bno, size_t size, void *bf, int fso, unsigned int Nflag)
1101 {
1102 	DBG_FUNC("wtfs")
1103 	ssize_t	n;
1104 
1105 	DBG_ENTER;
1106 
1107 	if (Nflag) {
1108 		DBG_LEAVE;
1109 		return;
1110 	}
1111 	if (lseek(fso, (off_t)bno * DEV_BSIZE, SEEK_SET) < 0)
1112 		err(35, "wtfs: seek error: %ld", (long)bno);
1113 	n = write(fso, bf, size);
1114 	if (n != (ssize_t)size)
1115 		err(36, "wtfs: write error: %ld", (long)bno);
1116 
1117 	DBG_LEAVE;
1118 	return;
1119 }
1120 
1121 /*
1122  * Here we check if all frags of a block are free. For more details again
1123  * please see the source of newfs(8), as this function is taken over almost
1124  * unchanged.
1125  */
1126 static int
1127 isblock(struct fs *fs, unsigned char *cp, int h)
1128 {
1129 	DBG_FUNC("isblock")
1130 	unsigned char mask;
1131 
1132 	DBG_ENTER;
1133 
1134 	switch (fs->fs_frag) {
1135 	case 8:
1136 		DBG_LEAVE;
1137 		return (cp[h] == 0xff);
1138 	case 4:
1139 		mask = 0x0f << ((h & 0x1) << 2);
1140 		DBG_LEAVE;
1141 		return ((cp[h >> 1] & mask) == mask);
1142 	case 2:
1143 		mask = 0x03 << ((h & 0x3) << 1);
1144 		DBG_LEAVE;
1145 		return ((cp[h >> 2] & mask) == mask);
1146 	case 1:
1147 		mask = 0x01 << (h & 0x7);
1148 		DBG_LEAVE;
1149 		return ((cp[h >> 3] & mask) == mask);
1150 	default:
1151 		fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
1152 		DBG_LEAVE;
1153 		return (0);
1154 	}
1155 }
1156 
1157 /*
1158  * Here we allocate a complete block in the block map. For more details again
1159  * please see the source of newfs(8), as this function is taken over almost
1160  * unchanged.
1161  */
1162 static void
1163 clrblock(struct fs *fs, unsigned char *cp, int h)
1164 {
1165 	DBG_FUNC("clrblock")
1166 
1167 	DBG_ENTER;
1168 
1169 	switch ((fs)->fs_frag) {
1170 	case 8:
1171 		cp[h] = 0;
1172 		break;
1173 	case 4:
1174 		cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
1175 		break;
1176 	case 2:
1177 		cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
1178 		break;
1179 	case 1:
1180 		cp[h >> 3] &= ~(0x01 << (h & 0x7));
1181 		break;
1182 	default:
1183 		warnx("clrblock bad fs_frag %d", fs->fs_frag);
1184 		break;
1185 	}
1186 
1187 	DBG_LEAVE;
1188 	return;
1189 }
1190 
1191 /*
1192  * Here we free a complete block in the free block map. For more details again
1193  * please see the source of newfs(8), as this function is taken over almost
1194  * unchanged.
1195  */
1196 static void
1197 setblock(struct fs *fs, unsigned char *cp, int h)
1198 {
1199 	DBG_FUNC("setblock")
1200 
1201 	DBG_ENTER;
1202 
1203 	switch (fs->fs_frag) {
1204 	case 8:
1205 		cp[h] = 0xff;
1206 		break;
1207 	case 4:
1208 		cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
1209 		break;
1210 	case 2:
1211 		cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
1212 		break;
1213 	case 1:
1214 		cp[h >> 3] |= (0x01 << (h & 0x7));
1215 		break;
1216 	default:
1217 		warnx("setblock bad fs_frag %d", fs->fs_frag);
1218 		break;
1219 	}
1220 
1221 	DBG_LEAVE;
1222 	return;
1223 }
1224 
1225 /*
1226  * Figure out how many lines our current terminal has. For more details again
1227  * please see the source of newfs(8), as this function is taken over almost
1228  * unchanged.
1229  */
1230 static int
1231 charsperline(void)
1232 {
1233 	DBG_FUNC("charsperline")
1234 	int columns;
1235 	char *cp;
1236 	struct winsize ws;
1237 
1238 	DBG_ENTER;
1239 
1240 	columns = 0;
1241 	if (ioctl(0, TIOCGWINSZ, &ws) != -1)
1242 		columns = ws.ws_col;
1243 	if (columns == 0 && (cp = getenv("COLUMNS")))
1244 		columns = atoi(cp);
1245 	if (columns == 0)
1246 		columns = 80;	/* last resort */
1247 
1248 	DBG_LEAVE;
1249 	return (columns);
1250 }
1251 
1252 static int
1253 is_dev(const char *name)
1254 {
1255 	struct stat devstat;
1256 
1257 	if (stat(name, &devstat) != 0)
1258 		return (0);
1259 	if (!S_ISCHR(devstat.st_mode))
1260 		return (0);
1261 	return (1);
1262 }
1263 
1264 /*
1265  * Return mountpoint on which the device is currently mounted.
1266  */
1267 static const struct statfs *
1268 dev_to_statfs(const char *dev)
1269 {
1270 	struct stat devstat, mntdevstat;
1271 	struct statfs *mntbuf, *statfsp;
1272 	char device[MAXPATHLEN];
1273 	char *mntdevname;
1274 	int i, mntsize;
1275 
1276 	/*
1277 	 * First check the mounted filesystems.
1278 	 */
1279 	if (stat(dev, &devstat) != 0)
1280 		return (NULL);
1281 	if (!S_ISCHR(devstat.st_mode) && !S_ISBLK(devstat.st_mode))
1282 		return (NULL);
1283 
1284 	mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
1285 	for (i = 0; i < mntsize; i++) {
1286 		statfsp = &mntbuf[i];
1287 		mntdevname = statfsp->f_mntfromname;
1288 		if (*mntdevname != '/') {
1289 			strcpy(device, _PATH_DEV);
1290 			strcat(device, mntdevname);
1291 			mntdevname = device;
1292 		}
1293 		if (stat(mntdevname, &mntdevstat) == 0 &&
1294 		    mntdevstat.st_rdev == devstat.st_rdev)
1295 			return (statfsp);
1296 	}
1297 
1298 	return (NULL);
1299 }
1300 
1301 static const char *
1302 mountpoint_to_dev(const char *mountpoint)
1303 {
1304 	struct statfs *mntbuf, *statfsp;
1305 	struct fstab *fs;
1306 	int i, mntsize;
1307 
1308 	/*
1309 	 * First check the mounted filesystems.
1310 	 */
1311 	mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
1312 	for (i = 0; i < mntsize; i++) {
1313 		statfsp = &mntbuf[i];
1314 
1315 		if (strcmp(statfsp->f_mntonname, mountpoint) == 0)
1316 			return (statfsp->f_mntfromname);
1317 	}
1318 
1319 	/*
1320 	 * Check the fstab.
1321 	 */
1322 	fs = getfsfile(mountpoint);
1323 	if (fs != NULL)
1324 		return (fs->fs_spec);
1325 
1326 	return (NULL);
1327 }
1328 
1329 static const char *
1330 getdev(const char *name)
1331 {
1332 	static char device[MAXPATHLEN];
1333 	const char *cp, *dev;
1334 
1335 	if (is_dev(name))
1336 		return (name);
1337 
1338 	cp = strrchr(name, '/');
1339 	if (cp == 0) {
1340 		snprintf(device, sizeof(device), "%s%s", _PATH_DEV, name);
1341 		if (is_dev(device))
1342 			return (device);
1343 	}
1344 
1345 	dev = mountpoint_to_dev(name);
1346 	if (dev != NULL && is_dev(dev))
1347 		return (dev);
1348 
1349 	return (NULL);
1350 }
1351 
1352 /*
1353  * growfs(8) is a utility which allows to increase the size of an existing
1354  * ufs file system. Currently this can only be done on unmounted file system.
1355  * It recognizes some command line options to specify the new desired size,
1356  * and it does some basic checkings. The old file system size is determined
1357  * and after some more checks like we can really access the new last block
1358  * on the disk etc. we calculate the new parameters for the superblock. After
1359  * having done this we just call growfs() which will do the work.
1360  * We still have to provide support for snapshots. Therefore we first have to
1361  * understand what data structures are always replicated in the snapshot on
1362  * creation, for all other blocks we touch during our procedure, we have to
1363  * keep the old blocks unchanged somewhere available for the snapshots. If we
1364  * are lucky, then we only have to handle our blocks to be relocated in that
1365  * way.
1366  * Also we have to consider in what order we actually update the critical
1367  * data structures of the file system to make sure, that in case of a disaster
1368  * fsck(8) is still able to restore any lost data.
1369  * The foreseen last step then will be to provide for growing even mounted
1370  * file systems. There we have to extend the mount() system call to provide
1371  * userland access to the file system locking facility.
1372  */
1373 int
1374 main(int argc, char **argv)
1375 {
1376 	DBG_FUNC("main")
1377 	const char *device;
1378 	const struct statfs *statfsp;
1379 	uint64_t size = 0;
1380 	off_t mediasize;
1381 	int error, i, j, fsi, fso, ch, Nflag = 0, yflag = 0;
1382 	char *p, reply[5], oldsizebuf[6], newsizebuf[6];
1383 	void *testbuf;
1384 
1385 	DBG_ENTER;
1386 
1387 	while ((ch = getopt(argc, argv, "Ns:vy")) != -1) {
1388 		switch(ch) {
1389 		case 'N':
1390 			Nflag = 1;
1391 			break;
1392 		case 's':
1393 			size = (off_t)strtoumax(optarg, &p, 0);
1394 			if (p == NULL || *p == '\0')
1395 				size *= DEV_BSIZE;
1396 			else if (*p == 'b' || *p == 'B')
1397 				; /* do nothing */
1398 			else if (*p == 'k' || *p == 'K')
1399 				size <<= 10;
1400 			else if (*p == 'm' || *p == 'M')
1401 				size <<= 20;
1402 			else if (*p == 'g' || *p == 'G')
1403 				size <<= 30;
1404 			else if (*p == 't' || *p == 'T') {
1405 				size <<= 30;
1406 				size <<= 10;
1407 			} else
1408 				errx(1, "unknown suffix on -s argument");
1409 			break;
1410 		case 'v': /* for compatibility to newfs */
1411 			break;
1412 		case 'y':
1413 			yflag = 1;
1414 			break;
1415 		case '?':
1416 			/* FALLTHROUGH */
1417 		default:
1418 			usage();
1419 		}
1420 	}
1421 	argc -= optind;
1422 	argv += optind;
1423 
1424 	if (argc != 1)
1425 		usage();
1426 
1427 	/*
1428 	 * Now try to guess the device name.
1429 	 */
1430 	device = getdev(*argv);
1431 	if (device == NULL)
1432 		errx(1, "cannot find special device for %s", *argv);
1433 
1434 	statfsp = dev_to_statfs(device);
1435 
1436 	fsi = open(device, O_RDONLY);
1437 	if (fsi < 0)
1438 		err(1, "%s", device);
1439 
1440 	/*
1441 	 * Try to guess the slice size if not specified.
1442 	 */
1443 	if (ioctl(fsi, DIOCGMEDIASIZE, &mediasize) == -1)
1444 		err(1,"DIOCGMEDIASIZE");
1445 
1446 	/*
1447 	 * Check if that partition is suitable for growing a file system.
1448 	 */
1449 	if (mediasize < 1)
1450 		errx(1, "partition is unavailable");
1451 
1452 	/*
1453 	 * Read the current superblock, and take a backup.
1454 	 */
1455 	for (i = 0; sblock_try[i] != -1; i++) {
1456 		sblockloc = sblock_try[i] / DEV_BSIZE;
1457 		rdfs(sblockloc, (size_t)SBLOCKSIZE, (void *)&(osblock), fsi);
1458 		if ((osblock.fs_magic == FS_UFS1_MAGIC ||
1459 		    (osblock.fs_magic == FS_UFS2_MAGIC &&
1460 		    osblock.fs_sblockloc == sblock_try[i])) &&
1461 		    osblock.fs_bsize <= MAXBSIZE &&
1462 		    osblock.fs_bsize >= (int32_t) sizeof(struct fs))
1463 			break;
1464 	}
1465 	if (sblock_try[i] == -1)
1466 		errx(1, "superblock not recognized");
1467 	memcpy((void *)&fsun1, (void *)&fsun2, sizeof(fsun2));
1468 
1469 	DBG_OPEN("/tmp/growfs.debug"); /* already here we need a superblock */
1470 	DBG_DUMP_FS(&sblock, "old sblock");
1471 
1472 	/*
1473 	 * Determine size to grow to. Default to the device size.
1474 	 */
1475 	if (size == 0)
1476 		size = mediasize;
1477 	else {
1478 		if (size > (uint64_t)mediasize) {
1479 			humanize_number(oldsizebuf, sizeof(oldsizebuf), size,
1480 			    "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1481 			humanize_number(newsizebuf, sizeof(newsizebuf),
1482 			    mediasize,
1483 			    "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1484 
1485 			errx(1, "requested size %s is larger "
1486 			    "than the available %s", oldsizebuf, newsizebuf);
1487 		}
1488 	}
1489 
1490 	/*
1491 	 * Make sure the new size is a multiple of fs_fsize; /dev/ufssuspend
1492 	 * only supports fragment-aligned IO requests.
1493 	 */
1494 	size -= size % osblock.fs_fsize;
1495 
1496 	if (size <= (uint64_t)(osblock.fs_size * osblock.fs_fsize)) {
1497 		humanize_number(oldsizebuf, sizeof(oldsizebuf),
1498 		    osblock.fs_size * osblock.fs_fsize,
1499 		    "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1500 		humanize_number(newsizebuf, sizeof(newsizebuf), size,
1501 		    "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1502 
1503 		errx(1, "requested size %s is not larger than the current "
1504 		   "filesystem size %s", newsizebuf, oldsizebuf);
1505 	}
1506 
1507 	sblock.fs_size = dbtofsb(&osblock, size / DEV_BSIZE);
1508 	sblock.fs_providersize = dbtofsb(&osblock, mediasize / DEV_BSIZE);
1509 
1510 	/*
1511 	 * Are we really growing?
1512 	 */
1513 	if (osblock.fs_size >= sblock.fs_size) {
1514 		errx(1, "we are not growing (%jd->%jd)",
1515 		    (intmax_t)osblock.fs_size, (intmax_t)sblock.fs_size);
1516 	}
1517 
1518 	/*
1519 	 * Check if we find an active snapshot.
1520 	 */
1521 	if (yflag == 0) {
1522 		for (j = 0; j < FSMAXSNAP; j++) {
1523 			if (sblock.fs_snapinum[j]) {
1524 				errx(1, "active snapshot found in file system; "
1525 				    "please remove all snapshots before "
1526 				    "using growfs");
1527 			}
1528 			if (!sblock.fs_snapinum[j]) /* list is dense */
1529 				break;
1530 		}
1531 	}
1532 
1533 	if (yflag == 0 && Nflag == 0) {
1534 		if (statfsp != NULL && (statfsp->f_flags & MNT_RDONLY) == 0)
1535 			printf("Device is mounted read-write; resizing will "
1536 			    "result in temporary write suspension for %s.\n",
1537 			    statfsp->f_mntonname);
1538 		printf("It's strongly recommended to make a backup "
1539 		    "before growing the file system.\n"
1540 		    "OK to grow filesystem on %s", device);
1541 		if (statfsp != NULL)
1542 			printf(", mounted on %s,", statfsp->f_mntonname);
1543 		humanize_number(oldsizebuf, sizeof(oldsizebuf),
1544 		    osblock.fs_size * osblock.fs_fsize,
1545 		    "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1546 		humanize_number(newsizebuf, sizeof(newsizebuf),
1547 		    sblock.fs_size * sblock.fs_fsize,
1548 		    "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1549 		printf(" from %s to %s? [Yes/No] ", oldsizebuf, newsizebuf);
1550 		fflush(stdout);
1551 		fgets(reply, (int)sizeof(reply), stdin);
1552 		if (strcmp(reply, "Yes\n")){
1553 			printf("\nNothing done\n");
1554 			exit (0);
1555 		}
1556 	}
1557 
1558 	/*
1559 	 * Try to access our device for writing.  If it's not mounted,
1560 	 * or mounted read-only, simply open it; otherwise, use UFS
1561 	 * suspension mechanism.
1562 	 */
1563 	if (Nflag) {
1564 		fso = -1;
1565 	} else {
1566 		if (statfsp != NULL && (statfsp->f_flags & MNT_RDONLY) == 0) {
1567 			fso = open(_PATH_UFSSUSPEND, O_RDWR);
1568 			if (fso == -1)
1569 				err(1, "unable to open %s", _PATH_UFSSUSPEND);
1570 			error = ioctl(fso, UFSSUSPEND, &statfsp->f_fsid);
1571 			if (error != 0)
1572 				err(1, "UFSSUSPEND");
1573 		} else {
1574 			fso = open(device, O_WRONLY);
1575 			if (fso < 0)
1576 				err(1, "%s", device);
1577 		}
1578 	}
1579 
1580 	/*
1581 	 * Try to access our new last block in the file system.
1582 	 */
1583 	testbuf = malloc(sblock.fs_fsize);
1584 	if (testbuf == NULL)
1585 		err(1, "malloc");
1586 	rdfs((ufs2_daddr_t)((size - sblock.fs_fsize) / DEV_BSIZE),
1587 	    sblock.fs_fsize, testbuf, fsi);
1588 	wtfs((ufs2_daddr_t)((size - sblock.fs_fsize) / DEV_BSIZE),
1589 	    sblock.fs_fsize, testbuf, fso, Nflag);
1590 	free(testbuf);
1591 
1592 	/*
1593 	 * Now calculate new superblock values and check for reasonable
1594 	 * bound for new file system size:
1595 	 *     fs_size:    is derived from user input
1596 	 *     fs_dsize:   should get updated in the routines creating or
1597 	 *                 updating the cylinder groups on the fly
1598 	 *     fs_cstotal: should get updated in the routines creating or
1599 	 *                 updating the cylinder groups
1600 	 */
1601 
1602 	/*
1603 	 * Update the number of cylinders and cylinder groups in the file system.
1604 	 */
1605 	if (sblock.fs_magic == FS_UFS1_MAGIC) {
1606 		sblock.fs_old_ncyl =
1607 		    sblock.fs_size * sblock.fs_old_nspf / sblock.fs_old_spc;
1608 		if (sblock.fs_size * sblock.fs_old_nspf >
1609 		    sblock.fs_old_ncyl * sblock.fs_old_spc)
1610 			sblock.fs_old_ncyl++;
1611 	}
1612 	sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg);
1613 
1614 	/*
1615 	 * Allocate last cylinder group only if there is enough room
1616 	 * for at least one data block.
1617 	 */
1618 	if (sblock.fs_size % sblock.fs_fpg != 0 &&
1619 	    sblock.fs_size <= cgdmin(&sblock, sblock.fs_ncg - 1)) {
1620 		humanize_number(oldsizebuf, sizeof(oldsizebuf),
1621 		    (sblock.fs_size % sblock.fs_fpg) * sblock.fs_fsize,
1622 		    "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1623 		warnx("no room to allocate last cylinder group; "
1624 		    "leaving %s unused", oldsizebuf);
1625 		sblock.fs_ncg--;
1626 		if (sblock.fs_magic == FS_UFS1_MAGIC)
1627 			sblock.fs_old_ncyl = sblock.fs_ncg * sblock.fs_old_cpg;
1628 		sblock.fs_size = sblock.fs_ncg * sblock.fs_fpg;
1629 	}
1630 
1631 	/*
1632 	 * Update the space for the cylinder group summary information in the
1633 	 * respective cylinder group data area.
1634 	 */
1635 	sblock.fs_cssize =
1636 	    fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));
1637 
1638 	if (osblock.fs_size >= sblock.fs_size)
1639 		errx(1, "not enough new space");
1640 
1641 	DBG_PRINT0("sblock calculated\n");
1642 
1643 	/*
1644 	 * Ok, everything prepared, so now let's do the tricks.
1645 	 */
1646 	growfs(fsi, fso, Nflag);
1647 
1648 	close(fsi);
1649 	if (fso > -1) {
1650 		if (statfsp != NULL && (statfsp->f_flags & MNT_RDONLY) == 0) {
1651 			error = ioctl(fso, UFSRESUME);
1652 			if (error != 0)
1653 				err(1, "UFSRESUME");
1654 		}
1655 		error = close(fso);
1656 		if (error != 0)
1657 			err(1, "close");
1658 		if (statfsp != NULL && (statfsp->f_flags & MNT_RDONLY) != 0)
1659 			mount_reload(statfsp);
1660 	}
1661 
1662 	DBG_CLOSE;
1663 
1664 	DBG_LEAVE;
1665 	return (0);
1666 }
1667 
1668 /*
1669  * Dump a line of usage.
1670  */
1671 static void
1672 usage(void)
1673 {
1674 	DBG_FUNC("usage")
1675 
1676 	DBG_ENTER;
1677 
1678 	fprintf(stderr, "usage: growfs [-Ny] [-s size] special | filesystem\n");
1679 
1680 	DBG_LEAVE;
1681 	exit(1);
1682 }
1683 
1684 /*
1685  * This updates most parameters and the bitmap related to cluster. We have to
1686  * assume that sblock, osblock, acg are set up.
1687  */
1688 static void
1689 updclst(int block)
1690 {
1691 	DBG_FUNC("updclst")
1692 	static int lcs = 0;
1693 
1694 	DBG_ENTER;
1695 
1696 	if (sblock.fs_contigsumsize < 1) /* no clustering */
1697 		return;
1698 	/*
1699 	 * update cluster allocation map
1700 	 */
1701 	setbit(cg_clustersfree(&acg), block);
1702 
1703 	/*
1704 	 * update cluster summary table
1705 	 */
1706 	if (!lcs) {
1707 		/*
1708 		 * calculate size for the trailing cluster
1709 		 */
1710 		for (block--; lcs < sblock.fs_contigsumsize; block--, lcs++ ) {
1711 			if (isclr(cg_clustersfree(&acg), block))
1712 				break;
1713 		}
1714 	}
1715 	if (lcs < sblock.fs_contigsumsize) {
1716 		if (lcs)
1717 			cg_clustersum(&acg)[lcs]--;
1718 		lcs++;
1719 		cg_clustersum(&acg)[lcs]++;
1720 	}
1721 
1722 	DBG_LEAVE;
1723 	return;
1724 }
1725 
1726 static void
1727 mount_reload(const struct statfs *stfs)
1728 {
1729 	char errmsg[255];
1730 	struct iovec *iov;
1731 	int iovlen;
1732 
1733 	iov = NULL;
1734 	iovlen = 0;
1735 	*errmsg = '\0';
1736 	build_iovec(&iov, &iovlen, "fstype", __DECONST(char *, "ffs"), 4);
1737 	build_iovec(&iov, &iovlen, "fspath", __DECONST(char *, stfs->f_mntonname), (size_t)-1);
1738 	build_iovec(&iov, &iovlen, "errmsg", errmsg, sizeof(errmsg));
1739 	build_iovec(&iov, &iovlen, "update", NULL, 0);
1740 	build_iovec(&iov, &iovlen, "reload", NULL, 0);
1741 
1742 	if (nmount(iov, iovlen, stfs->f_flags) < 0) {
1743 		errmsg[sizeof(errmsg) - 1] = '\0';
1744 		err(9, "%s: cannot reload filesystem%s%s", stfs->f_mntonname,
1745 		    *errmsg != '\0' ? ": " : "", errmsg);
1746 	}
1747 }
1748