 @@ -1,14 +1,14 @@
-/*	$NetBSD: resize_ffs.c,v 1.31 2011/08/15 02:22:46 dholland Exp $	*/
+/*	$NetBSD: resize_ffs.c,v 1.32 2011/08/27 16:34:57 christos Exp $	*/
 /* From sources sent on February 17, 2003 */
 /*-
  * As its sole author, I explicitly place this code in the public
  *  domain.  Anyone may use it for any purpose (though I would
  *  appreciate credit where it is due).
+ *
  *					der Mouse
+ *
  *			       mouse@rodents.montreal.qc.ca
  *		     7D C8 61 52 5D E7 2D 39  4E F1 31 3E E8 B3 27 4B
  */
 /*
  * resize_ffs:
 @@ -26,27 +26,27 @@
  *  depending on gcc-specific features, notably nested function
  *  definitions (which in at least a few cases depend on the lexical
  *  scoping gcc provides, so they can't be trivially moved outside).
+ *
  * Many thanks go to John Kohl <jtk@NetBSD.org> for finding bugs: the
  *  one responsible for the "realloccgblk: can't find blk in cyl"
  *  problem and a more minor one which left fs_dsize wrong when
  *  shrinking.  (These actually indicate bugs in fsck too - it should
  *  have caught and fixed them.)
+ *
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: resize_ffs.c,v 1.31 2011/08/15 02:22:46 dholland Exp $");
+__RCSID("$NetBSD: resize_ffs.c,v 1.32 2011/08/27 16:34:57 christos Exp $");
 #include <sys/disk.h>
 #include <sys/disklabel.h>
 #include <sys/dkio.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <sys/param.h>		/* MAXFRAG */
 #include <ufs/ffs/fs.h>
 #include <ufs/ffs/ffs_extern.h>
 #include <ufs/ufs/dir.h>
 #include <ufs/ufs/dinode.h>
 #include <ufs/ufs/ufs_bswap.h>	/* ufs_rw32 */
 @@ -312,27 +312,27 @@ alloconce(size_t nb, const char *tag)
 	    (unsigned long int) nb, tag);
+}
 /*
  * Load the cgs and csums off disk.  Also allocates the space to load
  *  them into and initializes the per-cg flags.
  */
 static void
 loadcgs(void)
+{
 	int cg;
 	char *cgp;
 	cgblksz = roundup(oldsb->fs_cgsize, oldsb->fs_fsize);
-	cgs = nfmalloc(oldsb->fs_ncg * sizeof(struct cg *), "cg pointers");
+	cgs = nfmalloc(oldsb->fs_ncg * sizeof(*cgs), "cg pointers");
 	cgp = alloconce(oldsb->fs_ncg * cgblksz, "cgs");
 	cgflags = nfmalloc(oldsb->fs_ncg, "cg flags");
 	csums = nfmalloc(oldsb->fs_cssize, "cg summary");
 	for (cg = 0; cg < oldsb->fs_ncg; cg++) {
 		cgs[cg] = (struct cg *) cgp;
 		readat(fsbtodb(oldsb, cgtod(oldsb, cg)), cgp, cgblksz);
 		if (needswap)
 			ffs_cg_swap(cgs[cg],cgs[cg],oldsb);
 		cgflags[cg] = 0;
 		cgp += cgblksz;
+	}
 	readat(fsbtodb(oldsb, oldsb->fs_csaddr), csums, oldsb->fs_cssize);
 	if (needswap)
 @@ -601,27 +601,27 @@ initcg(int cgn)
 		if (i) {
 			cg->cg_frsum[i]++;
 			cg->cg_cs.cs_nffree += i;
+		}
+	}
 	/* Update the csum info. */
 	csums[cgn] = cg->cg_cs;
 	newsb->fs_cstotal.cs_nffree += cg->cg_cs.cs_nffree;
 	newsb->fs_cstotal.cs_nbfree += cg->cg_cs.cs_nbfree;
 	newsb->fs_cstotal.cs_nifree += cg->cg_cs.cs_nifree;
 	if (is_ufs2 == 0)
 		/* Write out the cleared inodes. */
 		writeat(fsbtodb(newsb, cgimin(newsb, cgn)), zinodes,
-		    newsb->fs_ipg * sizeof(struct ufs1_dinode));
+		    newsb->fs_ipg * sizeof(*zinodes));
 	/* Dirty the cg. */
 	cgflags[cgn] |= CGF_DIRTY;
+}
 /*
  * Find free space, at least nfrags consecutive frags of it.  Pays no
  *  attention to block boundaries, but refuses to straddle cg
  *  boundaries, even if the disk blocks involved are in fact
  *  consecutive.  Return value is the frag number of the first frag of
  *  the block, or -1 if no space was found.  Uses newsb for sb values,
  *  and assumes the cgs[] structures correctly describe the area to be
  *  searched.
+ *
  * XXX is there a bug lurking in the ignoring of block boundaries by
 @@ -852,30 +852,28 @@ csum_fixup(void)
 			 * 'em and we're all done.  */
 			for ((i = newsb->fs_csaddr + ntot - nnew),
 				 (j = nnew); j > 0; i++, j--) {
 				alloc_frag(i);
+			}
 			return;
+		}
+	}
 	/* We have to move the csum info, sigh.  Look for new space, free old
 	 * space, and allocate new.  Update fs_csaddr.  We don't copy anything
 	 * on disk at this point; the csum info will be written to the
 	 * then-current fs_csaddr as part of the final flush. */
 	newloc = find_freespace(ntot);
-	if (newloc < 0) {
+	if (newloc < 0)
-		printf("Sorry, no space available for new csums\n");
+		errx(EXIT_FAILURE, "Sorry, no space available for new csums");
 		exit(EXIT_FAILURE);
 	for (i = 0, f = newsb->fs_csaddr, t = newloc; i < ntot; i++, f++, t++) {
 		if (i < nold) {
 			free_frag(f);
+		}
 		alloc_frag(t);
+	}
 	newsb->fs_csaddr = newloc;
+}
 /*
  * Recompute newsb->fs_dsize.  Just scans all cgs, adding the number of
  *  data blocks in that cg to the total.
  */
 static void
 @@ -916,36 +914,35 @@ timestamp(void)
 	return (t);
+}
 /*
  * Grow the file system.
  */
 static void
 grow(void)
+{
 	int i;
 	/* Update the timestamp. */
 	newsb->fs_time = timestamp();
 	/* Allocate and clear the new-inode area, in case we add any cgs. */
-	zinodes = alloconce(newsb->fs_ipg * sizeof(struct ufs1_dinode),
+	zinodes = alloconce(newsb->fs_ipg * sizeof(*zinodes), "zeroed inodes");
-                            "zeroed inodes");
+	memset(zinodes, 0, newsb->fs_ipg * sizeof(*zinodes));
 	memset(zinodes, 0, newsb->fs_ipg * sizeof(struct ufs1_dinode));
 	/* Update the size. */
 	newsb->fs_size = dbtofsb(newsb, newsize);
 	/* Did we actually not grow?  (This can happen if newsize is less than
 	 * a frag larger than the old size - unlikely, but no excuse to
 	 * misbehave if it happens.) */
 	if (newsb->fs_size == oldsb->fs_size) {
-		printf("New fs size %"PRIu64" = odl fs size %"PRIu64
+		printf("New fs size %"PRIu64" = old fs size %"PRIu64
 		    ", not growing.\n", newsb->fs_size, oldsb->fs_size);
 		return;
+	}
 	/* Check that the new last sector (frag, actually) is writable.  Since
 	 * it's at least one frag larger than it used to be, we know we aren't
 	 * overwriting anything important by this.  (The choice of sbbuf as
 	 * what to write is irrelevant; it's just something handy that's known
 	 * to be at least one frag in size.) */
 	writeat(fsbtodb(newsb,newsb->fs_size - 1), &sbbuf, newsb->fs_fsize);
 	if (is_ufs2)
 		newsb->fs_ncg = howmany(newsb->fs_size, newsb->fs_fpg);
 	else {
 		/* Update fs_old_ncyl and fs_ncg. */
 @@ -967,27 +964,27 @@ grow(void)
 		printf("Warning: last cylinder group is too small;\n");
 		printf("    dropping it.  New size = %lu.\n",
 		    (unsigned long int) fsbtodb(newsb, newsb->fs_size));
+	}
 	/* Find out how big the csum area is, and realloc csums if bigger. */
 	newsb->fs_cssize = fragroundup(newsb,
 	    newsb->fs_ncg * sizeof(struct csum));
 	if (newsb->fs_cssize > oldsb->fs_cssize)
 		csums = nfrealloc(csums, newsb->fs_cssize, "new cg summary");
 	/* If we're adding any cgs, realloc structures and set up the new
 	   cgs. */
 	if (newsb->fs_ncg > oldsb->fs_ncg) {
 		char *cgp;
-		cgs = nfrealloc(cgs, newsb->fs_ncg * sizeof(struct cg *),
+		cgs = nfrealloc(cgs, newsb->fs_ncg * sizeof(*cgs),
                                 "cg pointers");
 		cgflags = nfrealloc(cgflags, newsb->fs_ncg, "cg flags");
 		memset(cgflags + oldsb->fs_ncg, 0,
 		    newsb->fs_ncg - oldsb->fs_ncg);
 		cgp = alloconce((newsb->fs_ncg - oldsb->fs_ncg) * cgblksz,
                                 "cgs");
 		for (i = oldsb->fs_ncg; i < newsb->fs_ncg; i++) {
 			cgs[i] = (struct cg *) cgp;
 			initcg(i);
 			cgp += cgblksz;
+		}
 		cgs[oldsb->fs_ncg - 1]->cg_old_ncyl = oldsb->fs_old_cpg;
 		cgflags[oldsb->fs_ncg - 1] |= CGF_DIRTY;
 @@ -1218,52 +1215,51 @@ loadinodes(void)
 	for (ino = 0,imax = oldsb->fs_ipg * oldsb->fs_ncg; ino < imax; ) {
 		readat(fsbtodb(oldsb, ino_to_fsba(oldsb, ino)), ibuf,
 		    oldsb->fs_bsize);
 		for (i = 0; i < oldsb->fs_inopb; i++) {
 			if (is_ufs2) {
 				if (needswap) {
 					ffs_dinode2_swap(&(dp2[i]), &(dp2[i]));
 					for (j = 0; j < NDADDR + NIADDR; j++)
 						dp2[i].di_db[j] =
 						    bswap32(dp2[i].di_db[j]);
+				}
 				memcpy(&inodes[ino].dp2, &dp2[i],
-				    sizeof(struct ufs2_dinode));
+				    sizeof(inodes[ino].dp2));
 			} else {
 				if (needswap) {
 					ffs_dinode1_swap(&(dp1[i]), &(dp1[i]));
 					for (j = 0; j < NDADDR + NIADDR; j++)
 						dp1[i].di_db[j] =
 						    bswap32(dp1[i].di_db[j]);
+				}
 				memcpy(&inodes[ino].dp1, &dp1[i],
-				    sizeof(struct ufs1_dinode));
+				    sizeof(inodes[ino].dp1));
+			}
 			    if (++ino > imax)
 				    errx(EXIT_FAILURE,
 					"Exceeded number of inodes");
+		}
+	}
+}
 /*
  * Report a file-system-too-full problem.
  */
-static void
+__dead static void
 toofull(void)
+{
-	printf("Sorry, would run out of data blocks\n");
+	errx(EXIT_FAILURE, "Sorry, would run out of data blocks");
 	exit(EXIT_FAILURE);
+}
 /*
  * Record a desire to move "n" frags from "from" to "to".
  */
 static void
 mark_move(unsigned int from, unsigned int to, unsigned int n)
+{
 	for (; n > 0; n--)
 		blkmove[from++] = to++;
+}
 /* Helper function - evict n frags, starting with start (cg-relative).
  * The free bitmap is scanned, unallocated frags are ignored, and
  * each block of consecutive allocated frags is moved as a unit.
 @@ -1574,31 +1570,29 @@ flush_inodes(void)
  *  for the considerations in question.
  */
 static void
 evict_inodes(struct cg * cg)
+{
 	int inum;
 	int i;
 	int fi;
 	inum = newsb->fs_ipg * cg->cg_cgx;
 	for (i = 0; i < newsb->fs_ipg; i++, inum++) {
 		if (DIP(inodes + inum,di_mode) != 0) {
 			fi = find_freeinode();
-			if (fi < 0) {
+			if (fi < 0)
-				printf("Sorry, inodes evaporated - "
+				errx(EXIT_FAILURE, "Sorry, inodes evaporated - "
-				    "file system probably needs fsck\n");
+				    "file system probably needs fsck");
 				exit(EXIT_FAILURE);
 			inomove[inum] = fi;
 			clr_bits(cg_inosused(cg, 0), i, 1);
 			set_bits(cg_inosused(cgs[ino_to_cg(newsb, fi)], 0),
 			    fi % newsb->fs_ipg, 1);
+		}
+	}
+}
 /*
  * Move inodes from old locations to new.  Does not actually write
  *  anything to disk; just copies in-core and sets dirty bits.
+ *
  * We have to be careful here for reasons similar to those mentioned in
  *  the comment header on perform_data_move, above: for the sake of
 @@ -1710,31 +1704,29 @@ shrink(void)
 		newsb->fs_ncg--;
 		if (is_ufs2 == 0) {
 			newsb->fs_old_ncyl = newsb->fs_ncg * newsb->fs_old_cpg;
 			newsb->fs_size = (newsb->fs_old_ncyl *
 			    newsb->fs_old_spc) / NSPF(newsb);
 		} else
 			newsb->fs_size = newsb->fs_ncg * newsb->fs_fpg;
 		printf("Warning: last cylinder group is too small;\n");
 		printf("    dropping it.  New size = %lu.\n",
 		    (unsigned long int) fsbtodb(newsb, newsb->fs_size));
+	}
 	/* Let's make sure we're not being shrunk into oblivion. */
-	if (newsb->fs_ncg < 1) {
+	if (newsb->fs_ncg < 1)
-		printf("Size too small - file system would "
+		errx(EXIT_FAILURE, "Size too small - file system would "
-		    "have no cylinders\n");
+		    "have no cylinders");
 		exit(EXIT_FAILURE);
 	/* Initialize for block motion. */
 	blkmove_init();
 	/* Update csum size, then fix up for the new size */
 	newsb->fs_cssize = fragroundup(newsb,
 	    newsb->fs_ncg * sizeof(struct csum));
 	csum_fixup();
 	/* Evict data from any cgs being wholly eliminated */
 	for (i = newsb->fs_ncg; i < oldsb->fs_ncg; i++) {
 		int base;
 		int dlow;
 		int dhigh;
 		int dmax;
 		base = cgbase(oldsb, i);
 @@ -1768,30 +1760,28 @@ shrink(void)
 		evict_data(cg, newcgsize, oldcgsize - newcgsize);
 		clr_bits(cg_blksfree(cg, 0), newcgsize, oldcgsize - newcgsize);
+	}
 	/* Find out whether we would run out of inodes.  (Note we
 	 * haven't actually done anything to the file system yet; all
 	 * those evict_data calls just update blkmove.) */
+	{
 		int slop;
 		slop = 0;
 		for (i = 0; i < newsb->fs_ncg; i++)
 			slop += cgs[i]->cg_cs.cs_nifree;
 		for (; i < oldsb->fs_ncg; i++)
 			slop -= oldsb->fs_ipg - cgs[i]->cg_cs.cs_nifree;
-		if (slop < 0) {
+		if (slop < 0)
-			printf("Sorry, would run out of inodes\n");
+			errx(EXIT_FAILURE, "Sorry, would run out of inodes");
 			exit(EXIT_FAILURE);
+	}
 	/* Copy data, then update pointers to data.  See the comment
 	 * header on perform_data_move for ordering considerations. */
 	perform_data_move();
 	update_for_data_move();
 	/* Now do inodes.  Initialize, evict, move, update - see the
 	 * comment header on perform_inode_move. */
 	inomove_init();
 	for (i = newsb->fs_ncg; i < oldsb->fs_ncg; i++)
 		evict_inodes(cgs[i]);
 	perform_inode_move();
 	flush_inodes();
 	update_for_inode_move();
 @@ -2155,31 +2145,29 @@ main(int argc, char **argv)
 		oldsb->fs_csaddr = oldsb->fs_old_csaddr;
 		oldsb->fs_size = oldsb->fs_old_size;
 		oldsb->fs_dsize = oldsb->fs_old_dsize;
 		oldsb->fs_cstotal.cs_ndir = oldsb->fs_old_cstotal.cs_ndir;
 		oldsb->fs_cstotal.cs_nbfree = oldsb->fs_old_cstotal.cs_nbfree;
 		oldsb->fs_cstotal.cs_nifree = oldsb->fs_old_cstotal.cs_nifree;
 		oldsb->fs_cstotal.cs_nffree = oldsb->fs_old_cstotal.cs_nffree;
 		/* any others? */
 		printf("Resizing with ffsv1 superblock\n");
+	}
 	oldsb->fs_qbmask = ~(int64_t) oldsb->fs_bmask;
 	oldsb->fs_qfmask = ~(int64_t) oldsb->fs_fmask;
-	if (oldsb->fs_ipg % INOPB(oldsb)) {
+	if (oldsb->fs_ipg % INOPB(oldsb))
-		(void)fprintf(stderr, "ipg[%d] %% INOPB[%d] != 0\n",
+		errx(EXIT_FAILURE, "ipg[%d] %% INOPB[%d] != 0",
 		    (int) oldsb->fs_ipg, (int) INOPB(oldsb));
 		exit(EXIT_FAILURE);
 	/* The superblock is bigger than struct fs (there are trailing
 	 * tables, of non-fixed size); make sure we copy the whole
 	 * thing.  SBLOCKSIZE may be an over-estimate, but we do this
 	 * just once, so being generous is cheap. */
 	memcpy(newsb, oldsb, SBLOCKSIZE);
 	loadcgs();
 	if (newsize > fsbtodb(oldsb, oldsb->fs_size)) {
 		grow();
 	} else if (newsize < fsbtodb(oldsb, oldsb->fs_size)) {
 		if (is_ufs2)
 			errx(EXIT_FAILURE,"shrinking not supported for ufs2");
 		shrink();
+	}

 @@ -1,41 +1,40 @@
-.\"     $NetBSD: resize_ffs.8,v 1.10 2011/01/05 02:18:15 riz Exp $
+.\"     $NetBSD: resize_ffs.8,v 1.11 2011/08/27 16:34:57 christos Exp $
 .\"
 .\" As its sole author, I explicitly place this man page in the public
 .\" domain.  Anyone may use it in any way for any purpose (though I would
 .\" appreciate credit where it is due).
 .\"
 .\" /~\ The ASCII                           der Mouse
 .\" \ / Ribbon Campaign
 .\"  X  Against HTML               mouse@rodents.montreal.qc.ca
 .\" / \ Email!           7D C8 61 52 5D E7 2D 39  4E F1 31 3E E8 B3 27 4B
 .\"
 .Dd January 4, 2011
 .Dt RESIZE_FFS 8
 .Os
 .Sh NAME
 .Nm resize_ffs
 .Nd resize a file system on disk or in a file
 .Sh SYNOPSIS
 .Nm
 .Op Fl y
 .Op Fl s Ar size
 .Ar special
 .Sh DESCRIPTION
 .Nm
 resizes a file system.
 .Ar special
-is the name of the raw disk device or file where the file system resides;
+is the name of the raw disk device or file where the file system resides.
 (Sectors are almost always 512 bytes, and
 .Nm
 can both grow and shrink file systems.
 When growing, the disk device
 must of course be large enough to contain the new file system;
 .Nm
 simply extends the file system data structures into the new space.
 When shrinking,
 .Nm
 assumes this.
 It will not work correctly for file systems with other sector sizes.)
 .Nm
 has to copy anything that currently resides in the space being shrunk
 away; there must be enough space free on the file system for this to
 @@ -50,26 +49,28 @@ check the file system with
 If no
 .Fl s
 option is provided,
 .Nm
 will grow the file system to the underlying device size which is
 determined from
 .Ar special .
 .Pp
 The options are as follows:
 .Bl -tag -width indent
 .It Fl s
 Specify the file system size to which the file system should be
 resized.
 The size is given as the count of disk sectors, usually 512 bytes. To see the
 exact value, have a look at the disk specification or the disklabel.
 Mostly used to shrink file systems.
 .It Fl y
 Disable sanity questions made by
 .Nm .
 .El
 .Sh WARNING
 .Em Interrupting
 .Nm
 .Em "may leave your file system in an inconsistent state and require a"
 .Em "restore from backup."
 It attempts to write in the proper order to avoid problems, but as it is
 still considered experimental, you should take great care when using it.
 .Pp