mkfs: factor the crap out of the code

index 7bb6408f9b77..e16e73f86cbc 100644
@@ -428,6 +428,8 @@ struct opt_params lopts = {
 		{ .index = L_INTERNAL,
 		  .conflicts = { L_FILE,
 				 L_DEV,
+				 L_SECTLOG,
+				 L_SECTSIZE,
 				 LAST_CONFLICT },
 		  .minval = 0,
 		  .maxval = 1,

@@ -469,6 +471,7 @@ struct opt_params lopts = {
 		},
 		{ .index = L_SECTLOG,
 		  .conflicts = { L_SECTSIZE,
+				 L_INTERNAL,
 				 LAST_CONFLICT },
 		  .minval = XFS_MIN_SECTORSIZE_LOG,
 		  .maxval = XFS_MAX_SECTORSIZE_LOG,

@@ -476,6 +479,7 @@ struct opt_params lopts = {
 		},
 		{ .index = L_SECTSIZE,
 		  .conflicts = { L_SECTLOG,
+				 L_INTERNAL,
 				 LAST_CONFLICT },
 		  .convert = true,
 		  .is_power_2 = true,

index e16e73f86cbc..43f631a647b4 100644
@@ -24,11 +24,11 @@
 /*
  * Prototypes for internal functions.
  */
-static void conflict(char opt, char *tab[], int oldidx, int newidx);
+static void conflict(char opt, const char *tab[], int oldidx, int newidx);
 static void illegal(const char *value, const char *opt);
 static __attribute__((noreturn)) void usage (void);
-static __attribute__((noreturn)) void reqval(char opt, char *tab[], int idx);
-static void respec(char opt, char *tab[], int idx);
+static __attribute__((noreturn)) void reqval(char opt, const char *tab[], int idx);
+static void respec(char opt, const char *tab[], int idx);
 static void unknown(char opt, char *s);
 static int  ispow2(unsigned int i);
 

@@ -1287,7 +1287,7 @@ check_opt(
 		fprintf(stderr,
 	("Developer screwed up option parsing (%d/%d)! Please report!\n"),
 			sp->index, index);
-		reqval(opts->name, (char **)opts->subopts, index);
+		reqval(opts->name, opts->subopts, index);
 	}
 
 	/*

@@ -1300,11 +1300,11 @@ check_opt(
 	 */
 	if (!str_seen) {
 		if (sp->seen)
-			respec(opts->name, (char **)opts->subopts, index);
+			respec(opts->name, opts->subopts, index);
 		sp->seen = true;
 	} else {
 		if (sp->str_seen)
-			respec(opts->name, (char **)opts->subopts, index);
+			respec(opts->name, opts->subopts, index);
 		sp->str_seen = true;
 	}
 

@@ -1316,7 +1316,7 @@ check_opt(
 			break;
 		if (opts->subopt_params[conflict_opt].seen ||
 		    opts->subopt_params[conflict_opt].str_seen)
-			conflict(opts->name, (char **)opts->subopts,
+			conflict(opts->name, opts->subopts,
 				 conflict_opt, index);
 	}
 }

@@ -1334,7 +1334,7 @@ getnum(
 	/* empty strings might just return a default value */
 	if (!str || *str == '\0') {
 		if (sp->defaultval == SUBOPT_NEEDS_VAL)
-			reqval(opts->name, (char **)opts->subopts, index);
+			reqval(opts->name, opts->subopts, index);
 		return sp->defaultval;
 	}
 

@@ -1390,7 +1390,7 @@ getstr(
 
 	/* empty strings for string options are not valid */
 	if (!str || *str == '\0')
-		reqval(opts->name, (char **)opts->subopts, index);
+		reqval(opts->name, opts->subopts, index);
 	return str;
 }
 

@@ -1786,7 +1786,7 @@ main(
 					break;
 				case M_UUID:
 					if (!value || *value == '\0')
-						reqval('m', subopts, M_UUID);
+						reqval('m', (const char **)subopts, M_UUID);
 					if (platform_uuid_parse(value, &uuid))
 						illegal(optarg, "m uuid");
 					break;

@@ -1900,7 +1900,7 @@ main(
 				case S_LOG:
 				case S_SECTLOG:
 					if (lssflag)
-						conflict('s', subopts,
+						conflict('s', (const char **)subopts,
 							 S_SECTSIZE, S_SECTLOG);
 					sectorlog = getnum(value, &sopts,
 							   S_SECTLOG);

@@ -1912,7 +1912,7 @@ main(
 				case S_SIZE:
 				case S_SECTSIZE:
 					if (lslflag)
-						conflict('s', subopts, S_SECTLOG,
+						conflict('s', (const char **)subopts, S_SECTLOG,
 							 S_SECTSIZE);
 					sectorsize = getnum(value, &sopts,
 							    S_SECTSIZE);

@@ -3368,7 +3368,7 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 static void
 conflict(
 	char		opt,
-	char		*tab[],
+	const char	*tab[],
 	int		oldidx,
 	int		newidx)
 {

@@ -3397,7 +3397,7 @@ ispow2(
 static void __attribute__((noreturn))
 reqval(
 	char		opt,
-	char		*tab[],
+	const char	*tab[],
 	int		idx)
 {
 	fprintf(stderr, _("-%c %s option requires a value\n"), opt, tab[idx]);

@@ -3407,7 +3407,7 @@ reqval(
 static void
 respec(
 	char		opt,
-	char		*tab[],
+	const char	*tab[],
 	int		idx)
 {
 	fprintf(stderr, "-%c ", opt);

index e5e152378c2c..b77819b1adcc 100644
@@ -95,7 +95,7 @@ extern uint32_t crc32c_le(uint32_t crc, unsigned char const *p, size_t len);
 /*
  * Argument structure for libxfs_init().
  */
-typedef struct {
+typedef struct libxfs_xinit {
 				/* input parameters */
 	char            *volname;       /* pathname of volume */
 	char            *dname;         /* pathname of data "subvolume" */

119 lines not on this page · raw message

index 2b264ec32974..022fb84016f6 100644
@@ -1467,6 +1467,136 @@ getstr(
 	return str;
 }
 
+static int
+block_opts_parser(
+	struct opt_params	*opts,
+	int			subopt,
+	char			*value,
+	struct cli_params	*cli)
+{
+	return 0;
+}
+
+static int
+data_opts_parser(
+	struct opt_params	*opts,
+	int			subopt,
+	char			*value,
+	struct cli_params	*cli)
+{
+	return 0;
+}
+
+static int
+inode_opts_parser(
+	struct opt_params	*opts,
+	int			subopt,
+	char			*value,
+	struct cli_params	*cli)
+{
+	return 0;
+}
+
+static int
+log_opts_parser(
+	struct opt_params	*opts,
+	int			subopt,
+	char			*value,
+	struct cli_params	*cli)
+{
+	return 0;
+}
+
+static int
+meta_opts_parser(
+	struct opt_params	*opts,
+	int			subopt,
+	char			*value,
+	struct cli_params	*cli)
+{
+	return 0;
+}
+
+static int
+naming_opts_parser(
+	struct opt_params	*opts,
+	int			subopt,
+	char			*value,
+	struct cli_params	*cli)
+{
+	return 0;
+}
+
+static int
+rtdev_opts_parser(
+	struct opt_params	*opts,
+	int			subopt,
+	char			*value,
+	struct cli_params	*cli)
+{
+	return 0;
+}
+
+static int
+sector_opts_parser(
+	struct opt_params	*opts,
+	int			subopt,
+	char			*value,
+	struct cli_params	*cli)
+{
+	return 0;
+}
+
+struct subopts {
+	char		opt;
+	struct opt_params *opts;
+	int		(*parser)();
+} subopt_tab[] = {
+	{ 'b', &bopts, block_opts_parser },
+	{ 'd', &dopts, data_opts_parser },
+	{ 'i', &iopts, inode_opts_parser },
+	{ 'l', &lopts, log_opts_parser },
+	{ 'm', &mopts, meta_opts_parser },
+	{ 'n', &nopts, naming_opts_parser },
+	{ 'r', &ropts, rtdev_opts_parser },
+	{ 's', &sopts, sector_opts_parser },
+	{ '\0', NULL, NULL },
+};
+
+static void
+parse_subopts(
+	char		opt,
+	char		*arg,
+	struct cli_params *cli)
+{
+	struct subopts	*sop = &subopt_tab[0];
+	char		*p;
+	int		ret = 0;
+
+	while (sop->opts) {
+		if (sop->opt == opt)
+			break;
+		sop++;
+	}
+
+	/* should never happen */
+	if (!sop->opts)
+		return;
+
+	p = arg;
+	while (*p != '\0') {
+		char	**subopts = (char **)sop->opts->subopts;
+		char	*value;
+		int	subopt;
+
+		subopt = getsubopt(&p, subopts, &value);
+
+		ret = (sop->parser)(sop->opts, subopt, value, cli);
+		if (ret)
+			unknown(opt, value);
+	}
+}
+
 int
 main(
 	int			argc,

index 022fb84016f6..40de7ea9bfa8 100644
@@ -1474,6 +1474,19 @@ block_opts_parser(
 	char			*value,
 	struct cli_params	*cli)
 {
+	int			blocklog;
+
+	switch (subopt) {
+	case B_LOG:
+		blocklog = getnum(value, opts, B_LOG);
+		cli->blocksize = 1 << blocklog;
+		break;
+	case B_SIZE:
+		cli->blocksize = getnum(value, opts, B_SIZE);
+		break;
+	default:
+		return -EINVAL;
+	}
 	return 0;
 }
 

@@ -1706,6 +1719,7 @@ main(
 		.rmapbt = false,
 		.reflink = false,
 	};
+	struct cli_params	cli = {};
 
 	platform_uuid_generate(&uuid);
 	progname = basename(argv[0]);

@@ -1745,27 +1759,14 @@ main(
 			force_overwrite = 1;
 			break;
 		case 'b':
-			p = optarg;
-			while (*p != '\0') {
-				char	**subopts = (char **)bopts.subopts;
-				char	*value;
-
-				switch (getsubopt(&p, subopts, &value)) {
-				case B_LOG:
-					blocklog = getnum(value, &bopts, B_LOG);
-					blocksize = 1 << blocklog;
-					blflag = 1;
-					break;
-				case B_SIZE:
-					blocksize = getnum(value, &bopts,
-							   B_SIZE);
-					blocklog = libxfs_highbit32(blocksize);
-					bsflag = 1;
-					break;
-				default:
-					unknown('b', value);
-				}
-			}
+			parse_subopts(c, optarg, &cli);
+
+			/* temp don't break code */
+			blocksize = cli.blocksize;
+			blocklog = libxfs_highbit32(blocksize);
+			blflag = cli_opt_set(&bopts, B_LOG);
+			bsflag = cli_opt_set(&bopts, B_SIZE);
+			/* end temp don't break code */
 			break;
 		case 'd':
 			p = optarg;

index 40de7ea9bfa8..c92abc9a6bf3 100644
@@ -1497,6 +1497,65 @@ data_opts_parser(
 	char			*value,
 	struct cli_params	*cli)
 {
+	int			sectorlog;
+
+	switch (subopt) {
+	case D_AGCOUNT:
+		cli->agcount = getnum(value, opts, D_AGCOUNT);
+		break;
+	case D_AGSIZE:
+		cli->agsize = getstr(value, opts, D_AGSIZE);
+		break;
+	case D_FILE:
+		cli->xi->disfile = getnum(value, opts, D_FILE);
+		break;
+	case D_NAME:
+		cli->xi->dname = getstr(value, opts, D_NAME);
+		break;
+	case D_SIZE:
+		cli->dsize = getstr(value, opts, D_SIZE);
+		break;
+	case D_SUNIT:
+		cli->dsunit = getnum(value, opts, D_SUNIT);
+		break;
+	case D_SWIDTH:
+		cli->dswidth = getnum(value, opts, D_SWIDTH);
+		break;
+	case D_SU:
+		cli->dsu = getstr(value, opts, D_SU);
+		break;
+	case D_SW:
+		cli->dsw = getnum(value, opts, D_SW);
+		break;
+	case D_NOALIGN:
+		cli->sb_feat.nodalign = getnum(value, opts, D_NOALIGN);
+		break;
+	case D_SECTLOG:
+		if (cli->sectorsize)
+			conflict('d', opts->subopts, D_SECTSIZE, D_SECTLOG);
+		sectorlog = getnum(value, opts, D_SECTLOG);
+		cli->sectorsize = 1 << sectorlog;
+		break;
+	case D_SECTSIZE:
+		if (cli->sectorsize)
+			conflict('d', opts->subopts, D_SECTSIZE, D_SECTLOG);
+		cli->sectorsize = getnum(value, opts, D_SECTSIZE);
+		break;
+	case D_RTINHERIT:
+		if (getnum(value, opts, D_RTINHERIT))
+			cli->fsx.fsx_xflags |= XFS_DIFLAG_RTINHERIT;
+		break;
+	case D_PROJINHERIT:
+		cli->fsx.fsx_projid = getnum(value, opts, D_PROJINHERIT);
+		cli->fsx.fsx_xflags |= XFS_DIFLAG_PROJINHERIT;
+		break;
+	case D_EXTSZINHERIT:
+		cli->fsx.fsx_extsize = getnum(value, opts, D_EXTSZINHERIT);
+		cli->fsx.fsx_xflags |= XFS_DIFLAG_EXTSZINHERIT;
+		break;
+	default:
+		return -EINVAL;
+	}
 	return 0;
 }
 

@@ -1719,7 +1778,9 @@ main(
 		.rmapbt = false,
 		.reflink = false,
 	};
-	struct cli_params	cli = {};
+	struct cli_params	cli = {
+		.xi = &xi,
+	};
 
 	platform_uuid_generate(&uuid);
 	progname = basename(argv[0]);

@@ -1769,87 +1830,37 @@ main(
 			/* end temp don't break code */
 			break;
 		case 'd':
-			p = optarg;
-			while (*p != '\0') {
-				char	**subopts = (char **)dopts.subopts;
-				char	*value;
+			parse_subopts(c, optarg, &cli);
 
-				switch (getsubopt(&p, subopts, &value)) {
-				case D_AGCOUNT:
-					agcount = getnum(value, &dopts,
-							 D_AGCOUNT);
-					daflag = 1;
-					break;
-				case D_AGSIZE:
-					agsize = getnum(value, &dopts, D_AGSIZE);
-					dasize = 1;
-					break;
-				case D_FILE:
-					xi.disfile = getnum(value, &dopts,
-							    D_FILE);
-					break;
-				case D_NAME:
-					xi.dname = getstr(value, &dopts, D_NAME);
-					break;
-				case D_SIZE:
-					dsize = getstr(value, &dopts, D_SIZE);
-					break;
-				case D_SUNIT:
-					dsunit = getnum(value, &dopts, D_SUNIT);
-					dsflag = 1;
-					break;
-				case D_SWIDTH:
-					dswidth = getnum(value, &dopts,
-							 D_SWIDTH);
-					dsflag = 1;
-					break;
-				case D_SU:
-					dsu = getnum(value, &dopts, D_SU);
-					dsflag = 1;
-					break;
-				case D_SW:
-					dsw = getnum(value, &dopts, D_SW);
-					dsflag = 1;
-					break;
-				case D_NOALIGN:
-					nodsflag = getnum(value, &dopts,
-								D_NOALIGN);
-					break;
-				case D_SECTLOG:
-					sectorlog = getnum(value, &dopts,
-							   D_SECTLOG);
-					sectorsize = 1 << sectorlog;
-					slflag = 1;
-					break;
-				case D_SECTSIZE:
-					sectorsize = getnum(value, &dopts,
-							    D_SECTSIZE);
-					sectorlog =
-						libxfs_highbit32(sectorsize);
-					ssflag = 1;
-					break;
-				case D_RTINHERIT:
-					c = getnum(value, &dopts, D_RTINHERIT);
-					if (c)
-						fsx.fsx_xflags |=
-							XFS_DIFLAG_RTINHERIT;
-					break;
-				case D_PROJINHERIT:
-					fsx.fsx_projid = getnum(value, &dopts,
-								D_PROJINHERIT);
-					fsx.fsx_xflags |=
-						XFS_DIFLAG_PROJINHERIT;
-					break;
-				case D_EXTSZINHERIT:
-					fsx.fsx_extsize = getnum(value, &dopts,
-								 D_EXTSZINHERIT);
-					fsx.fsx_xflags |=
-						XFS_DIFLAG_EXTSZINHERIT;
-					break;
-				default:
-					unknown('d', value);
-				}
+			/* temp don't break code */
+			agcount = cli.agcount;
+			if (cli_opt_set(&dopts, D_AGSIZE)) {
+				agsize = getnum(cli.agsize, &dopts, D_AGSIZE);
+				dasize = 1;
+			}
+			daflag = cli_opt_set(&dopts, D_AGCOUNT);
+
+			dsunit = cli.dsunit;
+			dswidth = cli.dswidth;
+			dsw = cli.dsw;
+			if (cli_opt_set(&dopts, D_SU)) {
+				dsu = getnum(cli.dsu, &dopts, D_SU);
+				dsflag = 1;
 			}
+			dsflag |= cli_opt_set(&dopts, D_SW) ||
+				  cli_opt_set(&dopts, D_SUNIT) ||
+				  cli_opt_set(&dopts, D_SWIDTH);
+			nodsflag = cli_opt_set(&dopts, D_NOALIGN);
+
+			sectorsize = cli.sectorsize;
+			sectorlog = libxfs_highbit32(sectorsize);
+			slflag = cli_opt_set(&dopts, D_SECTLOG);
+			ssflag = cli_opt_set(&dopts, D_SECTSIZE);
+
+			fsx.fsx_xflags |= cli.fsx.fsx_xflags;
+			fsx.fsx_projid = cli.fsx.fsx_projid;
+			fsx.fsx_extsize = cli.fsx.fsx_extsize;
+			/* end temp don't break code */
 			break;
 		case 'i':
 			p = optarg;

index c92abc9a6bf3..d702010c2854 100644
@@ -1566,6 +1566,37 @@ inode_opts_parser(
 	char			*value,
 	struct cli_params	*cli)
 {
+	int			inodelog;
+
+	switch (subopt) {
+	case I_ALIGN:
+		cli->sb_feat.inode_align = getnum(value, &iopts, I_ALIGN);
+		break;
+	case I_LOG:
+		inodelog = getnum(value, &iopts, I_LOG);
+		cli->inodesize = 1 << inodelog;
+		break;
+	case I_MAXPCT:
+		cli->imaxpct = getnum(value, &iopts, I_MAXPCT);
+		break;
+	case I_PERBLOCK:
+		cli->inopblock = getnum(value, &iopts, I_PERBLOCK);
+		break;
+	case I_SIZE:
+		cli->inodesize = getnum(value, &iopts, I_SIZE);
+		break;
+	case I_ATTR:
+		cli->sb_feat.attr_version = getnum(value, &iopts, I_ATTR);
+		break;
+	case I_PROJID32BIT:
+		cli->sb_feat.projid16bit = !getnum(value, &iopts, I_PROJID32BIT);
+		break;
+	case I_SPINODES:
+		cli->sb_feat.spinodes = getnum(value, &iopts, I_SPINODES);
+		break;
+	default:
+		return -EINVAL;
+	}
 	return 0;
 }
 

@@ -1780,6 +1811,7 @@ main(
 	};
 	struct cli_params	cli = {
 		.xi = &xi,
+		.sb_feat = sb_feat,
 	};
 
 	platform_uuid_generate(&uuid);

@@ -1863,53 +1895,19 @@ main(
 			/* end temp don't break code */
 			break;
 		case 'i':
-			p = optarg;
-			while (*p != '\0') {
-				char	**subopts = (char **)iopts.subopts;
-				char	*value;
+			parse_subopts(c, optarg, &cli);
 
-				switch (getsubopt(&p, subopts, &value)) {
-				case I_ALIGN:
-					sb_feat.inode_align = getnum(value,
-								&iopts, I_ALIGN);
-					break;
-				case I_LOG:
-					inodelog = getnum(value, &iopts, I_LOG);
-					isize = 1 << inodelog;
-					ilflag = 1;
-					break;
-				case I_MAXPCT:
-					imaxpct = getnum(value, &iopts,
-							 I_MAXPCT);
-					imflag = 1;
-					break;
-				case I_PERBLOCK:
-					inopblock = getnum(value, &iopts,
-							   I_PERBLOCK);
-					ipflag = 1;
-					break;
-				case I_SIZE:
-					isize = getnum(value, &iopts, I_SIZE);
-					inodelog = libxfs_highbit32(isize);
-					isflag = 1;
-					break;
-				case I_ATTR:
-					sb_feat.attr_version =
-						getnum(value, &iopts, I_ATTR);
-					break;
-				case I_PROJID32BIT:
-					sb_feat.projid16bit =
-						!getnum(value, &iopts,
-							I_PROJID32BIT);
-					break;
-				case I_SPINODES:
-					sb_feat.spinodes = getnum(value,
-							&iopts, I_SPINODES);
-					break;
-				default:
-					unknown('i', value);
-				}
-			}
+			/* temp don't break code */
+			isize = cli.inodesize;
+			inodelog = libxfs_highbit32(isize);
+			inopblock = cli.inopblock;
+			ilflag = cli_opt_set(&iopts, I_LOG);
+			isflag = cli_opt_set(&iopts, I_SIZE);
+			ipflag = cli_opt_set(&iopts, I_PERBLOCK);
+
+			imaxpct = cli.imaxpct;
+			imflag = cli_opt_set(&iopts, I_MAXPCT);
+			/* end temp don't break code */
 			break;
 		case 'l':
 			p = optarg;

@@ -2157,6 +2155,10 @@ main(
 	} else
 		dfile = xi.dname;
 
+	/* temp don't break code */
+	sb_feat = cli.sb_feat;
+	/* end temp don't break code */
+
 	/*
 	 * Blocksize and sectorsize first, other things depend on them
 	 * For RAID4/5/6 we want to align sector size and block size,

index d702010c2854..8e42fe0301fb 100644
@@ -1607,6 +1607,48 @@ log_opts_parser(
 	char			*value,
 	struct cli_params	*cli)
 {
+	int			lsectorlog;
+
+	switch (subopt) {
+	case L_AGNUM:
+		cli->logagno = getnum(value, &lopts, L_AGNUM);
+		break;
+	case L_FILE:
+		cli->xi->lisfile = getnum(value, &lopts, L_FILE);
+		break;
+	case L_INTERNAL:
+		cli->loginternal = getnum(value, &lopts, L_INTERNAL);
+		break;
+	case L_SU:
+		cli->lsu = getstr(value, &lopts, L_SU);
+		break;
+	case L_SUNIT:
+		cli->lsunit = getnum(value, &lopts, L_SUNIT);
+		break;
+	case L_NAME:
+	case L_DEV:
+		cli->xi->logname = getstr(value, &lopts, L_NAME);
+		cli->loginternal = 0;
+		break;
+	case L_VERSION:
+		cli->sb_feat.log_version = getnum(value, &lopts, L_VERSION);
+		break;
+	case L_SIZE:
+		cli->logsize = getstr(value, &lopts, L_SIZE);
+		break;
+	case L_SECTLOG:
+		lsectorlog = getnum(value, &lopts, L_SECTLOG);
+		cli->lsectorsize = 1 << lsectorlog;
+		break;
+	case L_SECTSIZE:
+		cli->lsectorsize = getnum(value, &lopts, L_SECTSIZE);
+		break;
+	case L_LAZYSBCNTR:
+		cli->sb_feat.lazy_sb_counters = getnum(value, &lopts, L_LAZYSBCNTR);
+		break;
+	default:
+		return -EINVAL;
+	}
 	return 0;
 }
 

@@ -1910,70 +1952,31 @@ main(
 			/* end temp don't break code */
 			break;
 		case 'l':
-			p = optarg;
-			while (*p != '\0') {
-				char	**subopts = (char **)lopts.subopts;
-				char	*value;
+			parse_subopts(c, optarg, &cli);
 
-				switch (getsubopt(&p, subopts, &value)) {
-				case L_AGNUM:
-					logagno = getnum(value, &lopts, L_AGNUM);
-					laflag = 1;
-					break;
-				case L_FILE:
-					xi.lisfile = getnum(value, &lopts,
-							    L_FILE);
-					break;
-				case L_INTERNAL:
-					loginternal = getnum(value, &lopts,
-							     L_INTERNAL);
-					liflag = 1;
-					break;
-				case L_SU:
-					lsu = getnum(value, &lopts, L_SU);
-					lsuflag = 1;
-					break;
-				case L_SUNIT:
-					lsunit = getnum(value, &lopts, L_SUNIT);
-					lsunitflag = 1;
-					break;
-				case L_NAME:
-				case L_DEV:
-					logfile = getstr(value, &lopts, L_NAME);
-					xi.logname = logfile;
-					ldflag = 1;
-					loginternal = 0;
-					break;
-				case L_VERSION:
-					sb_feat.log_version =
-						getnum(value, &lopts, L_VERSION);
-					lvflag = 1;
-					break;
-				case L_SIZE:
-					logsize = getstr(value, &lopts, L_SIZE);
-					break;
-				case L_SECTLOG:
-					lsectorlog = getnum(value, &lopts,
-							    L_SECTLOG);
-					lsectorsize = 1 << lsectorlog;
-					lslflag = 1;
-					break;
-				case L_SECTSIZE:
-					lsectorsize = getnum(value, &lopts,
-							     L_SECTSIZE);
-					lsectorlog =
-						libxfs_highbit32(lsectorsize);
-					lssflag = 1;
-					break;
-				case L_LAZYSBCNTR:
-					sb_feat.lazy_sb_counters =
-							getnum(value, &lopts,
-							       L_LAZYSBCNTR);
-					break;
-				default:
-					unknown('l', value);
-				}
+			/* temp don't break code */
+			logagno = cli.logagno;
+			loginternal = cli.loginternal;
+			logfile = xi.logname;
+			logsize = cli.logsize;
+			lsectorsize = cli.lsectorsize;
+			lsectorlog = libxfs_highbit32(lsectorsize);
+
+			lsunit = cli.lsunit;
+			lsunitflag = cli_opt_set(&lopts, L_SUNIT);
+			if (cli_opt_set(&lopts, L_SU)) {
+				lsu = getnum(cli.lsu, &lopts, L_SU);
+				lsuflag = 1;
 			}
+
+			laflag = cli_opt_set(&lopts, L_AGNUM);
+			liflag = cli_opt_set(&lopts, L_INTERNAL);
+			ldflag = cli_opt_set(&lopts, L_NAME) ||
+				 cli_opt_set(&lopts, L_DEV);
+			lvflag = cli_opt_set(&lopts, L_VERSION);
+			lslflag = cli_opt_set(&lopts, L_SECTLOG);
+			lssflag = cli_opt_set(&lopts, L_SECTSIZE);
+			/* end temp don't break code */
 			break;
 		case 'L':
 			if (strlen(optarg) > sizeof(sbp->sb_fname))

index 8e42fe0301fb..7b967ffe6893 100644
@@ -1659,6 +1659,30 @@ meta_opts_parser(
 	char			*value,
 	struct cli_params	*cli)
 {
+	switch (subopt) {
+	case M_CRC:
+		cli->sb_feat.crcs_enabled = getnum(value, &mopts, M_CRC);
+		if (cli->sb_feat.crcs_enabled)
+			cli->sb_feat.dirftype = true;
+		break;
+	case M_FINOBT:
+		cli->sb_feat.finobt = getnum(value, &mopts, M_FINOBT);
+		break;
+	case M_UUID:
+		if (!value || *value == '\0')
+			reqval('m', opts->subopts, M_UUID);
+		if (platform_uuid_parse(value, &cli->uuid))
+			illegal(value, "m uuid");
+		break;
+	case M_RMAPBT:
+		cli->sb_feat.rmapbt = getnum(value, &mopts, M_RMAPBT);
+		break;
+	case M_REFLINK:
+		cli->sb_feat.reflink = getnum(value, &mopts, M_REFLINK);
+		break;
+	default:
+		return -EINVAL;
+	}
 	return 0;
 }
 

@@ -1984,40 +2008,11 @@ main(
 			label = optarg;
 			break;
 		case 'm':
-			p = optarg;
-			while (*p != '\0') {
-				char	**subopts = (char **)mopts.subopts;
-				char	*value;
+			parse_subopts(c, optarg, &cli);
 
-				switch (getsubopt(&p, subopts, &value)) {
-				case M_CRC:
-					sb_feat.crcs_enabled =
-						getnum(value, &mopts, M_CRC);
-					if (sb_feat.crcs_enabled)
-						sb_feat.dirftype = true;
-					break;
-				case M_FINOBT:
-					sb_feat.finobt = getnum(
-						value, &mopts, M_FINOBT);
-					break;
-				case M_UUID:
-					if (!value || *value == '\0')
-						reqval('m', (const char **)subopts, M_UUID);
-					if (platform_uuid_parse(value, &uuid))
-						illegal(optarg, "m uuid");
-					break;
-				case M_RMAPBT:
-					sb_feat.rmapbt = getnum(
-						value, &mopts, M_RMAPBT);
-					break;
-				case M_REFLINK:
-					sb_feat.reflink = getnum(
-						value, &mopts, M_REFLINK);
-					break;
-				default:
-					unknown('m', value);
-				}
-			}
+			/* temp don't break code */
+			platform_uuid_copy(&uuid, &cli.uuid);
+			/* end temp don't break code */
 			break;
 		case 'n':
 			p = optarg;

index 7b967ffe6893..e3ee1f1c87fc 100644
@@ -1693,6 +1693,28 @@ naming_opts_parser(
 	char			*value,
 	struct cli_params	*cli)
 {
+	switch (subopt) {
+	case N_LOG:
+		cli->dirblocklog = getnum(value, opts, N_LOG);
+		break;
+	case N_SIZE:
+		cli->dirblocksize = getstr(value, opts, N_SIZE);
+		break;
+	case N_VERSION:
+		value = getstr(value, &nopts, N_VERSION);
+		if (!strcasecmp(value, "ci")) {
+			/* ASCII CI mode */
+			cli->sb_feat.nci = true;
+		} else {
+			cli->sb_feat.dir_version = getnum(value, opts, N_VERSION);
+		}
+		break;
+	case N_FTYPE:
+		cli->sb_feat.dirftype = getnum(value, opts, N_FTYPE);
+		break;
+	default:
+		return -EINVAL;
+	}
 	return 0;
 }
 

@@ -2015,45 +2037,15 @@ main(
 			/* end temp don't break code */
 			break;
 		case 'n':
-			p = optarg;
-			while (*p != '\0') {
-				char	**subopts = (char **)nopts.subopts;
-				char	*value;
+			parse_subopts(c, optarg, &cli);
 
-				switch (getsubopt(&p, subopts, &value)) {
-				case N_LOG:
-					dirblocklog = getnum(value, &nopts,
-							     N_LOG);
-					dirblocksize = 1 << dirblocklog;
-					nlflag = 1;
-					break;
-				case N_SIZE:
-					dirblocksize = getnum(value, &nopts,
-							      N_SIZE);
-					dirblocklog =
-						libxfs_highbit32(dirblocksize);
-					nsflag = 1;
-					break;
-				case N_VERSION:
-					value = getstr(value, &nopts, N_VERSION);
-					if (!strcasecmp(value, "ci")) {
-						/* ASCII CI mode */
-						sb_feat.nci = true;
-					} else {
-						sb_feat.dir_version =
-							getnum(value, &nopts,
-							       N_VERSION);
-					}
-					nvflag = 1;
-					break;
-				case N_FTYPE:
-					sb_feat.dirftype = getnum(value, &nopts,
-								  N_FTYPE);
-					break;
-				default:
-					unknown('n', value);
-				}
-			}
+			/* temp don't break code */
+			if ((nsflag = cli_opt_set(&nopts, N_SIZE)))
+				dirblocksize = getnum(cli.dirblocksize, &nopts, N_SIZE);
+			dirblocklog = cli.dirblocklog;
+
+			nlflag = cli_opt_set(&nopts, N_LOG);
+			/* end temp don't break code */
 			break;
 		case 'N':
 			Nflag = 1;

index e3ee1f1c87fc..87505c61aa79 100644
@@ -1725,6 +1725,26 @@ rtdev_opts_parser(
 	char			*value,
 	struct cli_params	*cli)
 {
+	switch (subopt) {
+	case R_EXTSIZE:
+		cli->rtextsize = getstr(value, &ropts, R_EXTSIZE);
+		break;
+	case R_FILE:
+		cli->xi->risfile = getnum(value, &ropts, R_FILE);
+		break;
+	case R_NAME:
+	case R_DEV:
+		cli->xi->rtname = getstr(value, &ropts, R_NAME);
+		break;
+	case R_SIZE:
+		cli->rtsize = getstr(value, &ropts, R_SIZE);
+		break;
+	case R_NOALIGN:
+		cli->sb_feat.nortalign = getnum(value, &ropts, R_NOALIGN);
+		break;
+	default:
+		return -EINVAL;
+	}
 	return 0;
 }
 

@@ -2062,36 +2082,13 @@ main(
 			qflag = 1;
 			break;
 		case 'r':
-			p = optarg;
-			while (*p != '\0') {
-				char	**subopts = (char **)ropts.subopts;
-				char	*value;
+			parse_subopts(c, optarg, &cli);
 
-				switch (getsubopt(&p, subopts, &value)) {
-				case R_EXTSIZE:
-					rtextsize = getstr(value, &ropts,
-							   R_EXTSIZE);
-					break;
-				case R_FILE:
-					xi.risfile = getnum(value, &ropts,
-							    R_FILE);
-					break;
-				case R_NAME:
-				case R_DEV:
-					xi.rtname = getstr(value, &ropts,
-							   R_NAME);
-					break;
-				case R_SIZE:
-					rtsize = getstr(value, &ropts, R_SIZE);
-					break;
-				case R_NOALIGN:
-					norsflag = getnum(value, &ropts,
-								R_NOALIGN);
-					break;
-				default:
-					unknown('r', value);
-				}
-			}
+			/* temp don't break code */
+			rtextsize = cli.rtextsize;
+			rtsize = cli.rtsize;
+			norsflag = cli.sb_feat.nortalign;
+			/* end temp don't break code */
 			break;
 		case 's':
 			p = optarg;

index 87505c61aa79..5a646b89cd0f 100644
@@ -1755,6 +1755,27 @@ sector_opts_parser(
 	char			*value,
 	struct cli_params	*cli)
 {
+	int			sectorlog;
+
+	switch (subopt) {
+	case S_LOG:
+	case S_SECTLOG:
+		if (cli->sectorsize)
+			conflict('s', opts->subopts, S_SECTSIZE, S_SECTLOG);
+		sectorlog = getnum(value, &sopts, S_SECTLOG);
+		cli->sectorsize = 1 << sectorlog;
+		cli->lsectorsize = cli->sectorsize;
+		break;
+	case S_SIZE:
+	case S_SECTSIZE:
+		if (cli->sectorsize)
+			conflict('s', opts->subopts, S_SECTLOG, S_SECTSIZE);
+		cli->sectorsize = getnum(value, &sopts, S_SECTSIZE);
+		cli->lsectorsize = cli->sectorsize;
+		break;
+	default:
+		return -EINVAL;
+	}
 	return 0;
 }
 

@@ -1881,7 +1902,6 @@ main(
 	int			nvflag;
 	int			Nflag;
 	int			discard = 1;
-	char			*p;
 	char			*protofile;
 	char			*protostring;
 	int			qflag;

@@ -2091,41 +2111,18 @@ main(
 			/* end temp don't break code */
 			break;
 		case 's':
-			p = optarg;
-			while (*p != '\0') {
-				char	**subopts = (char **)sopts.subopts;
-				char	*value;
-
-				switch (getsubopt(&p, subopts, &value)) {
-				case S_LOG:
-				case S_SECTLOG:
-					if (lssflag)
-						conflict('s', (const char **)subopts,
-							 S_SECTSIZE, S_SECTLOG);
-					sectorlog = getnum(value, &sopts,
-							   S_SECTLOG);
-					lsectorlog = sectorlog;
-					sectorsize = 1 << sectorlog;
-					lsectorsize = sectorsize;
-					lslflag = slflag = 1;
-					break;
-				case S_SIZE:
-				case S_SECTSIZE:
-					if (lslflag)
-						conflict('s', (const char **)subopts, S_SECTLOG,
-							 S_SECTSIZE);
-					sectorsize = getnum(value, &sopts,
-							    S_SECTSIZE);
-					lsectorsize = sectorsize;
-					sectorlog =
-						libxfs_highbit32(sectorsize);
-					lsectorlog = sectorlog;
-					lssflag = ssflag = 1;
-					break;
-				default:
-					unknown('s', value);
-				}
-			}
+			parse_subopts(c, optarg, &cli);
+
+			/* temp don't break code */
+			sectorsize = cli.sectorsize;
+			lsectorlog = libxfs_highbit32(sectorsize);
+			lsectorsize = cli.lsectorsize;
+			lsectorlog = libxfs_highbit32(lsectorsize);
+			lslflag = slflag = cli_opt_set(&sopts, S_LOG) ||
+					   cli_opt_set(&sopts, S_SECTLOG);
+
+			lssflag = ssflag = cli_opt_set(&sopts, S_SIZE) ||
+					   cli_opt_set(&sopts, S_SECTSIZE);
 			break;
 		case 'V':
 			printf(_("%s version %s\n"), progname, VERSION);

index 5a646b89cd0f..b92c3316358f 100644
@@ -799,6 +799,58 @@ struct cli_params {
 	struct libxfs_xinit	*xi;
 };
 
+/*
+ * Calculated filesystem feature and geometry information.
+ *
+ * This structure contains the information we will use to create the on-disk
+ * filesystem from. The validation and calculation code uses it to store all the
+ * temporary and final config state for the filesystem.
+ *
+ * The information in this structure will contain a mix of validated CLI input
+ * variables, default feature state and calculated values that are needed to
+ * construct the superblock and other on disk features. These are all in one
+ * place so that we don't have to pass handfuls of seemingly arbitrary variables
+ * around to different functions to do teh work we need to do.
+ */
+struct mkfs_params {
+	int		blocksize;
+	int		blocklog;
+	int		sectorsize;
+	int		sectorlog;
+	int		lsectorsize;
+	int		lsectorlog;
+	int		dirblocksize;
+	int		dirblocklog;
+	int		inodesize;
+	int		inodelog;
+	int		inopblock;
+
+	uint64_t	dblocks;
+	uint64_t	logblocks;
+	uint64_t	rtblocks;
+	uint64_t	rtextblocks;
+	uint64_t	rtextents;
+	uint64_t	rtbmblocks;	/* rt bitmap blocks */
+
+	int		dsunit;		/* in FSBs */
+	int		dswidth;	/* in FSBs */
+	int		lsunit;		/* in FSBs */
+
+	uint64_t	agsize;
+	uint64_t	agcount;
+
+	int		imaxpct;
+
+	bool		loginternal;
+	uint64_t	logstart;
+	uint64_t	logagno;
+
+	uuid_t		uuid;
+	char		*label;
+
+	struct sb_feat_args	sb_feat;
+};
+
 #define TERABYTES(count, blog)	((uint64_t)(count) << (40 - (blog)))
 #define GIGABYTES(count, blog)	((uint64_t)(count) << (30 - (blog)))
 #define MEGABYTES(count, blog)	((uint64_t)(count) << (20 - (blog)))

@@ -1941,6 +1993,7 @@ main(
 		.xi = &xi,
 		.sb_feat = sb_feat,
 	};
+	struct mkfs_params	cfg = {};
 
 	platform_uuid_generate(&uuid);
 	progname = basename(argv[0]);

@@ -2965,6 +3018,39 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 	}
 	validate_log_size(logblocks, blocklog, min_logblocks);
 
+	/* Temp support code  to set up mkfs cfg parameters */
+	cfg.blocksize = blocksize;
+	cfg.blocklog = blocklog;
+	cfg.sectorsize = sectorsize;
+	cfg.sectorlog = sectorlog;
+	cfg.lsectorsize = lsectorsize;
+	cfg.lsectorlog = lsectorlog;
+	cfg.dirblocksize = dirblocksize;
+	cfg.dirblocklog = dirblocklog;
+	cfg.inodesize = isize;
+	cfg.inodelog = inodelog;
+	cfg.inopblock = inopblock;
+
+	cfg.dblocks = dblocks;
+	cfg.logblocks = logblocks;
+	cfg.rtblocks = rtblocks;
+	cfg.rtextblocks = rtextblocks;
+	cfg.rtextents = rtextents;
+	cfg.rtbmblocks = nbmblocks;
+	cfg.dsunit = dsunit;
+	cfg.dswidth = dswidth;
+	cfg.lsunit = lsunit;
+	cfg.agsize = agsize;
+	cfg.agcount = agcount;
+	cfg.imaxpct = imaxpct;
+	cfg.loginternal = loginternal;
+	cfg.logstart = logstart;
+	cfg.logagno = logagno;
+	cfg.label = label;
+	platform_uuid_copy(&cfg.uuid, &uuid);
+	memcpy(&cfg.sb_feat, &sb_feat, sizeof(sb_feat));
+	/* end temp support code */
+
 	if (!qflag || Nflag) {
 		printf(_(
 		   "meta-data=%-22s isize=%-6d agcount=%lld, agsize=%lld blks\n"

@@ -2994,6 +3080,7 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 			exit(0);
 	}
 
+
 	if (label)
 		strncpy(sbp->sb_fname, label, sizeof(sbp->sb_fname));
 	sbp->sb_magicnum = XFS_SB_MAGIC;

index b92c3316358f..4c67062047d9 100644
@@ -1881,6 +1881,40 @@ parse_subopts(
 	}
 }
 
+static void
+print_mkfs_cfg(
+	struct mkfs_params	*cfg,
+	char			*dfile,
+	char			*logfile,
+	char			*rtfile)
+{
+	struct sb_feat_args	*fp = &cfg->sb_feat;
+
+	printf(_(
+"meta-data=%-22s isize=%-6d agcount=%lld, agsize=%lld blks\n"
+"         =%-22s sectsz=%-5u attr=%u, projid32bit=%u\n"
+"         =%-22s crc=%-8u finobt=%u, sparse=%u, rmapbt=%u, reflink=%u\n"
+"data     =%-22s bsize=%-6u blocks=%llu, imaxpct=%u\n"
+"         =%-22s sunit=%-6u swidth=%u blks\n"
+"naming   =version %-14u bsize=%-6u ascii-ci=%d ftype=%d\n"
+"log      =%-22s bsize=%-6d blocks=%lld, version=%d\n"
+"         =%-22s sectsz=%-5u sunit=%d blks, lazy-count=%d\n"
+"realtime =%-22s extsz=%-6d blocks=%lld, rtextents=%lld\n"),
+		dfile, cfg->inodesize, (long long)cfg->agcount,
+			(long long)cfg->agsize,
+		"", cfg->sectorsize, fp->attr_version, !fp->projid16bit,
+		"", fp->crcs_enabled, fp->finobt, fp->spinodes, fp->rmapbt,
+			fp->reflink,
+		"", cfg->blocksize, (long long)cfg->dblocks, cfg->imaxpct,
+		"", cfg->dsunit, cfg->dswidth,
+		fp->dir_version, cfg->dirblocksize, fp->nci, fp->dirftype,
+		logfile, cfg->blocksize, (long long)cfg->logblocks,
+			fp->log_version,
+		"", cfg->lsectorsize, cfg->lsunit, fp->lazy_sb_counters,
+		rtfile, (int)cfg->rtextblocks << cfg->blocklog,
+			(long long)cfg->rtblocks, (long long)cfg->rtextents);
+}
+
 int
 main(
 	int			argc,

@@ -3052,35 +3086,11 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 	/* end temp support code */
 
 	if (!qflag || Nflag) {
-		printf(_(
-		   "meta-data=%-22s isize=%-6d agcount=%lld, agsize=%lld blks\n"
-		   "         =%-22s sectsz=%-5u attr=%u, projid32bit=%u\n"
-		   "         =%-22s crc=%-8u finobt=%u, sparse=%u, rmapbt=%u, reflink=%u\n"
-		   "data     =%-22s bsize=%-6u blocks=%llu, imaxpct=%u\n"
-		   "         =%-22s sunit=%-6u swidth=%u blks\n"
-		   "naming   =version %-14u bsize=%-6u ascii-ci=%d ftype=%d\n"
-		   "log      =%-22s bsize=%-6d blocks=%lld, version=%d\n"
-		   "         =%-22s sectsz=%-5u sunit=%d blks, lazy-count=%d\n"
-		   "realtime =%-22s extsz=%-6d blocks=%lld, rtextents=%lld\n"),
-			dfile, isize, (long long)agcount, (long long)agsize,
-			"", sectorsize, sb_feat.attr_version,
-				    !sb_feat.projid16bit,
-			"", sb_feat.crcs_enabled, sb_feat.finobt, sb_feat.spinodes,
-			sb_feat.rmapbt, sb_feat.reflink,
-			"", blocksize, (long long)dblocks, imaxpct,
-			"", dsunit, dswidth,
-			sb_feat.dir_version, dirblocksize, sb_feat.nci,
-				sb_feat.dirftype,
-			logfile, 1 << blocklog, (long long)logblocks,
-			sb_feat.log_version, "", lsectorsize, lsunit,
-				sb_feat.lazy_sb_counters,
-			rtfile, rtextblocks << blocklog,
-			(long long)rtblocks, (long long)rtextents);
+		print_mkfs_cfg(&cfg, dfile, logfile, rtfile);
 		if (Nflag)
 			exit(0);
 	}
 
-
 	if (label)
 		strncpy(sbp->sb_fname, label, sizeof(sbp->sb_fname));
 	sbp->sb_magicnum = XFS_SB_MAGIC;

index 4c67062047d9..0e115bf3cf4d 100644
@@ -1915,6 +1915,84 @@ print_mkfs_cfg(
 			(long long)cfg->rtblocks, (long long)cfg->rtextents);
 }
 
+/*
+ * Format everything from the generated config into the superblock that
+ * will be used to initialise the on-disk superblock. This is the in-memory
+ * copy, so no need to care about endian swapping here.
+ */
+static void
+setup_superblock(
+	struct mkfs_params	*cfg,
+	struct xfs_mount	*mp,
+	struct xfs_sb		*sbp)
+{
+	if (cfg->label)
+		strncpy(sbp->sb_fname, cfg->label, sizeof(sbp->sb_fname));
+
+	sbp->sb_magicnum = XFS_SB_MAGIC;
+	sbp->sb_blocksize = cfg->blocksize;
+	sbp->sb_dblocks = cfg->dblocks;
+	sbp->sb_rblocks = cfg->rtblocks;
+	sbp->sb_rextents = cfg->rtextents;
+	platform_uuid_copy(&sbp->sb_uuid, &cfg->uuid);
+	/* Only in memory; libxfs expects this as if read from disk */
+	platform_uuid_copy(&sbp->sb_meta_uuid, &cfg->uuid);
+	sbp->sb_logstart = cfg->logstart;
+	sbp->sb_rootino = sbp->sb_rbmino = sbp->sb_rsumino = NULLFSINO;
+	sbp->sb_rextsize = cfg->rtextblocks;
+	sbp->sb_agcount = (xfs_agnumber_t)cfg->agcount;
+	sbp->sb_rbmblocks = cfg->rtbmblocks;
+	sbp->sb_logblocks = (xfs_extlen_t)cfg->logblocks;
+	sbp->sb_sectsize = (uint16_t)cfg->sectorsize;
+	sbp->sb_inodesize = (uint16_t)cfg->inodesize;
+	sbp->sb_inopblock = (uint16_t)(cfg->blocksize / cfg->inodesize);
+	sbp->sb_sectlog = (uint8_t)cfg->sectorlog;
+	sbp->sb_inodelog = (uint8_t)cfg->inodelog;
+	sbp->sb_inopblog = (uint8_t)(cfg->blocklog - cfg->inodelog);
+	sbp->sb_rextslog = (uint8_t)(cfg->rtextents ?
+			libxfs_highbit32((unsigned int)cfg->rtextents) : 0);
+	sbp->sb_inprogress = 1;	/* mkfs is in progress */
+	sbp->sb_imax_pct = cfg->imaxpct;
+	sbp->sb_icount = 0;
+	sbp->sb_ifree = 0;
+	sbp->sb_fdblocks = cfg->dblocks -
+			   cfg->agcount * libxfs_prealloc_blocks(mp) -
+			   (cfg->loginternal ? cfg->logblocks : 0);
+	sbp->sb_frextents = 0;	/* will do a free later */
+	sbp->sb_uquotino = sbp->sb_gquotino = sbp->sb_pquotino = 0;
+	sbp->sb_qflags = 0;
+	sbp->sb_unit = cfg->dsunit;
+	sbp->sb_width = cfg->dswidth;
+	sbp->sb_dirblklog = cfg->dirblocklog - cfg->blocklog;
+
+	/*
+	 * log stripe unit is stored in bytes on disk and cannot be zero
+	 * for v2 logs.
+	 */
+	if (cfg->sb_feat.log_version == 2) {
+		int	lsunit = (cfg->lsunit == 0) ? 1 : cfg->lsunit;
+
+		sbp->sb_logsunit = XFS_FSB_TO_B(mp, lsunit);;
+	} else
+		sbp->sb_logsunit = 0;
+
+	if (cfg->sb_feat.inode_align) {
+		int	cluster_size = XFS_INODE_BIG_CLUSTER_SIZE;
+		if (cfg->sb_feat.crcs_enabled)
+			cluster_size *= cfg->inodesize / XFS_DINODE_MIN_SIZE;
+		sbp->sb_inoalignmt = cluster_size >> cfg->blocklog;
+	} else
+		sbp->sb_inoalignmt = 0;
+
+	if (cfg->lsectorsize != BBSIZE || cfg->sectorsize != BBSIZE) {
+		sbp->sb_logsectlog = (uint8_t)cfg->lsectorlog;
+		sbp->sb_logsectsize = (uint16_t)cfg->lsectorsize;
+	} else {
+		sbp->sb_logsectlog = 0;
+		sbp->sb_logsectsize = 0;
+	}
+}
+
 int
 main(
 	int			argc,

@@ -3091,65 +3169,10 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 			exit(0);
 	}
 
-	if (label)
-		strncpy(sbp->sb_fname, label, sizeof(sbp->sb_fname));
-	sbp->sb_magicnum = XFS_SB_MAGIC;
-	sbp->sb_blocksize = blocksize;
-	sbp->sb_dblocks = dblocks;
-	sbp->sb_rblocks = rtblocks;
-	sbp->sb_rextents = rtextents;
-	platform_uuid_copy(&sbp->sb_uuid, &uuid);
-	/* Only in memory; libxfs expects this as if read from disk */
-	platform_uuid_copy(&sbp->sb_meta_uuid, &uuid);
-	sbp->sb_logstart = logstart;
-	sbp->sb_rootino = sbp->sb_rbmino = sbp->sb_rsumino = NULLFSINO;
-	sbp->sb_rextsize = rtextblocks;
-	sbp->sb_agcount = (xfs_agnumber_t)agcount;
-	sbp->sb_rbmblocks = nbmblocks;
-	sbp->sb_logblocks = (xfs_extlen_t)logblocks;
-	sbp->sb_sectsize = (uint16_t)sectorsize;
-	sbp->sb_inodesize = (uint16_t)isize;
-	sbp->sb_inopblock = (uint16_t)(blocksize / isize);
-	sbp->sb_sectlog = (uint8_t)sectorlog;
-	sbp->sb_inodelog = (uint8_t)inodelog;
-	sbp->sb_inopblog = (uint8_t)(blocklog - inodelog);
-	sbp->sb_rextslog =
-		(uint8_t)(rtextents ?
-			libxfs_highbit32((unsigned int)rtextents) : 0);
-	sbp->sb_inprogress = 1;	/* mkfs is in progress */
-	sbp->sb_imax_pct = imaxpct;
-	sbp->sb_icount = 0;
-	sbp->sb_ifree = 0;
-	sbp->sb_fdblocks = dblocks - agcount * libxfs_prealloc_blocks(mp) -
-		(loginternal ? logblocks : 0);
-	sbp->sb_frextents = 0;	/* will do a free later */
-	sbp->sb_uquotino = sbp->sb_gquotino = sbp->sb_pquotino = 0;
-	sbp->sb_qflags = 0;
-	sbp->sb_unit = dsunit;
-	sbp->sb_width = dswidth;
-	sbp->sb_dirblklog = dirblocklog - blocklog;
-	if (sb_feat.log_version == 2) {	/* This is stored in bytes */
-		lsunit = (lsunit == 0) ? 1 : XFS_FSB_TO_B(mp, lsunit);
-		sbp->sb_logsunit = lsunit;
-	} else
-		sbp->sb_logsunit = 0;
-	if (sb_feat.inode_align) {
-		int	cluster_size = XFS_INODE_BIG_CLUSTER_SIZE;
-		if (sb_feat.crcs_enabled)
-			cluster_size *= isize / XFS_DINODE_MIN_SIZE;
-		sbp->sb_inoalignmt = cluster_size >> blocklog;
-		sb_feat.inode_align = sbp->sb_inoalignmt != 0;
-	} else
-		sbp->sb_inoalignmt = 0;
-	if (lsectorsize != BBSIZE || sectorsize != BBSIZE) {
-		sbp->sb_logsectlog = (uint8_t)lsectorlog;
-		sbp->sb_logsectsize = (uint16_t)lsectorsize;
-	} else {
-		sbp->sb_logsectlog = 0;
-		sbp->sb_logsectsize = 0;
-	}
-
-	sb_set_features(&mp->m_sb, &sb_feat, sectorsize, lsectorsize, dsunit);
+	/*
+	 * Finish setting up the superblock state ready for formatting.
+	 */
+	setup_superblock(&cfg, mp, sbp);
 
 	if (force_overwrite)
 		zero_old_xfs_structures(&xi, sbp);

index 0e115bf3cf4d..2438e50d3f33 100644
@@ -1993,6 +1993,97 @@ setup_superblock(
 	}
 }
 
+/*
+ * Sanitise the data and log devices and prepare them so libxfs can mount the
+ * device successfully. Also check we can access the rt device if configured.
+ */
+static void
+prepare_devices(
+	struct mkfs_params	*cfg,
+	struct libxfs_xinit	*xi,
+	struct xfs_mount	*mp,
+	struct xfs_sb		*sbp,
+	bool			clear_stale)
+{
+	struct xfs_buf		*buf;
+	int			whack_blks = BTOBB(WHACK_SIZE);
+
+	/*
+	 * If there's an old XFS filesystem on the device with enough intact
+	 * information that we can parse the superblock, there's enough
+	 * information on disk to confuse a future xfs_repair call. To avoid
+	 * this, whack all the old secondary superblocks that we can find.
+	 */
+	if (clear_stale)
+		zero_old_xfs_structures(xi, sbp);
+
+	/*
+	 * If the data device is a file, grow out the file to its final size if
+	 * needed so that the reads for the end of the device in the mount code
+	 * will succeed.
+	 */
+	if (xi->disfile &&
+	    xi->dsize * xi->dbsize < cfg->dblocks * cfg->blocksize) {
+		if (ftruncate(xi->dfd, cfg->dblocks * cfg->blocksize) < 0) {
+			fprintf(stderr,
+				_("%s: Growing the data section failed\n"),
+				progname);
+			exit(1);
+		}
+
+		/* update size to be able to whack blocks correctly */
+		xi->dsize = BTOBB(cfg->dblocks * cfg->blocksize);
+	}
+
+	/*
+	 * Zero out the end to obliterate any old MD RAID (or other) metadata at
+	 * the end of the device.  (MD sb is ~64k from the end, take out a wider
+	 * swath to be sure)
+	 */
+	buf = libxfs_getbuf(mp->m_ddev_targp, (xi->dsize - whack_blks),
+			    whack_blks);
+	memset(XFS_BUF_PTR(buf), 0, WHACK_SIZE);
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+	libxfs_purgebuf(buf);
+
+	/*
+	 * Now zero out the beginning of the device, to obliterate any old
+	 * filesystem signatures out there.  This should take care of
+	 * swap (somewhere around the page size), jfs (32k),
+	 * ext[2,3] and reiserfs (64k) - and hopefully all else.
+	 */
+	buf = libxfs_getbuf(mp->m_ddev_targp, 0, whack_blks);
+	memset(XFS_BUF_PTR(buf), 0, WHACK_SIZE);
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+	libxfs_purgebuf(buf);
+
+	/* OK, now write the superblock... */
+	buf = libxfs_getbuf(mp->m_ddev_targp, XFS_SB_DADDR, XFS_FSS_TO_BB(mp, 1));
+	buf->b_ops = &xfs_sb_buf_ops;
+	memset(XFS_BUF_PTR(buf), 0, cfg->sectorsize);
+	libxfs_sb_to_disk((void *)XFS_BUF_PTR(buf), sbp);
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+	libxfs_purgebuf(buf);
+
+	/* ...and zero the log.... */
+	libxfs_log_clear(mp->m_logdev_targp, NULL,
+			 XFS_FSB_TO_DADDR(mp, cfg->logstart),
+			 (xfs_extlen_t)XFS_FSB_TO_BB(mp, cfg->logblocks),
+			 &sbp->sb_uuid, cfg->sb_feat.log_version,
+			 sbp->sb_logsunit, XLOG_FMT, XLOG_INIT_CYCLE, false);
+
+	/* finally, check we can write the last block in the realtime area */
+	if (mp->m_rtdev_targp->dev && cfg->rtblocks > 0) {
+		buf = libxfs_getbuf(mp->m_rtdev_targp,
+				    XFS_FSB_TO_BB(mp, cfg->rtblocks - 1LL),
+				    BTOBB(cfg->blocksize));
+		memset(XFS_BUF_PTR(buf), 0, cfg->blocksize);
+		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+		libxfs_purgebuf(buf);
+	}
+
+}
+
 int
 main(
 	int			argc,

@@ -3174,65 +3265,17 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 	 */
 	setup_superblock(&cfg, mp, sbp);
 
-	if (force_overwrite)
-		zero_old_xfs_structures(&xi, sbp);
-
 	/*
-	 * Zero out the beginning of the device, to obliterate any old
-	 * filesystem signatures out there.  This should take care of
-	 * swap (somewhere around the page size), jfs (32k),
-	 * ext[2,3] and reiserfs (64k) - and hopefully all else.
+	 * we need the libxfs buffer cache from here on in.
 	 */
 	libxfs_buftarg_init(mp, xi.ddev, xi.logdev, xi.rtdev);
-	buf = libxfs_getbuf(mp->m_ddev_targp, 0, BTOBB(WHACK_SIZE));
-	memset(XFS_BUF_PTR(buf), 0, WHACK_SIZE);
-	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-	libxfs_purgebuf(buf);
-
-	/* OK, now write the superblock */
-	buf = libxfs_getbuf(mp->m_ddev_targp, XFS_SB_DADDR, XFS_FSS_TO_BB(mp, 1));
-	buf->b_ops = &xfs_sb_buf_ops;
-	memset(XFS_BUF_PTR(buf), 0, sectorsize);
-	libxfs_sb_to_disk((void *)XFS_BUF_PTR(buf), sbp);
-	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-	libxfs_purgebuf(buf);
-
-	/*
-	 * If the data area is a file, then grow it out to its final size
-	 * if needed so that the reads for the end of the device in the mount
-	 * code will succeed.
-	 */
-	if (xi.disfile && xi.dsize * xi.dbsize < dblocks * blocksize) {
-		if (ftruncate(xi.dfd, dblocks * blocksize) < 0) {
-			fprintf(stderr,
-				_("%s: Growing the data section failed\n"),
-				progname);
-			exit(1);
-		}
-	}
-
-	/*
-	 * Zero out the end of the device, to obliterate any
-	 * old MD RAID (or other) metadata at the end of the device.
-	 * (MD sb is ~64k from the end, take out a wider swath to be sure)
-	 */
-	if (!xi.disfile) {
-		buf = libxfs_getbuf(mp->m_ddev_targp,
-				    (xi.dsize - BTOBB(WHACK_SIZE)),
-				    BTOBB(WHACK_SIZE));
-		memset(XFS_BUF_PTR(buf), 0, WHACK_SIZE);
-		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-		libxfs_purgebuf(buf);
-	}
 
 	/*
-	 * Zero the log....
+	 * Before we mount the filesystem we need to make sure the devices have
+	 * enough of the filesystem structure on them that allows libxfs to
+	 * mount.
 	 */
-	libxfs_log_clear(mp->m_logdev_targp, NULL,
-		XFS_FSB_TO_DADDR(mp, logstart),
-		(xfs_extlen_t)XFS_FSB_TO_BB(mp, logblocks),
-		&sbp->sb_uuid, sb_feat.log_version, lsunit, XLOG_FMT, XLOG_INIT_CYCLE, false);
-
+	prepare_devices(&cfg, &xi, mp, sbp, force_overwrite);
 	mp = libxfs_mount(mp, sbp, xi.ddev, xi.logdev, xi.rtdev, 0);
 	if (mp == NULL) {
 		fprintf(stderr, _("%s: filesystem failed to initialize\n"),

@@ -3576,24 +3619,6 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 	}
 
 	/*
-	 * Touch last block, make fs the right size if it's a file.
-	 */
-	buf = libxfs_getbuf(mp->m_ddev_targp,
-		(xfs_daddr_t)XFS_FSB_TO_BB(mp, dblocks - 1LL), bsize);
-	memset(XFS_BUF_PTR(buf), 0, blocksize);
-	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-
-	/*
-	 * Make sure we can write the last block in the realtime area.
-	 */
-	if (mp->m_rtdev_targp->dev && rtblocks > 0) {
-		buf = libxfs_getbuf(mp->m_rtdev_targp,
-				XFS_FSB_TO_BB(mp, rtblocks - 1LL), bsize);
-		memset(XFS_BUF_PTR(buf), 0, blocksize);
-		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-	}
-
-	/*
 	 * BNO, CNT free block list
 	 */
 	for (agno = 0; agno < agcount; agno++) {

index 2438e50d3f33..13af1ef1cd41 100644
@@ -2084,22 +2084,401 @@ prepare_devices(
 
 }
 
+/*
+ * XXX: this code is mostly common with the kernel growfs code.
+ * These initialisations should be pulled into libxfs to keep the
+ * kernel/userspace header initialisation code the same.
+ */
+static void
+initialise_ag_headers(
+	struct mkfs_params	*cfg,
+	struct xfs_mount	*mp,
+	struct xfs_sb		*sbp,
+	xfs_agnumber_t		agno,
+	int			*worst_freelist)
+{
+	struct xfs_perag	*pag = libxfs_perag_get(mp, agno);
+	struct xfs_agfl		*agfl;
+	struct xfs_agf		*agf;
+	struct xfs_agi		*agi;
+	struct xfs_buf		*buf;
+	struct xfs_btree_block	*block;
+	struct xfs_alloc_rec	*arec;
+	struct xfs_alloc_rec	*nrec;
+	int			bucket;
+	uint64_t		agsize = cfg->agsize;
+	xfs_agblock_t		agblocks;
+	bool			is_log_ag = false;
+	int			c;
+
+	if (cfg->loginternal && agno == cfg->logagno)
+		is_log_ag = true;
+
+	/*
+	 * Superblock.
+	 */
+	buf = libxfs_getbuf(mp->m_ddev_targp,
+			XFS_AG_DADDR(mp, agno, XFS_SB_DADDR),
+			XFS_FSS_TO_BB(mp, 1));
+	buf->b_ops = &xfs_sb_buf_ops;
+	memset(XFS_BUF_PTR(buf), 0, cfg->sectorsize);
+	libxfs_sb_to_disk((void *)XFS_BUF_PTR(buf), sbp);
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+
+	/*
+	 * AG header block: freespace
+	 */
+	buf = libxfs_getbuf(mp->m_ddev_targp,
+			XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
+			XFS_FSS_TO_BB(mp, 1));
+	buf->b_ops = &xfs_agf_buf_ops;
+	agf = XFS_BUF_TO_AGF(buf);
+	memset(agf, 0, cfg->sectorsize);
+	if (agno == cfg->agcount - 1)
+		agsize = cfg->dblocks - (xfs_rfsblock_t)(agno * agsize);
+	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
+	agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
+	agf->agf_seqno = cpu_to_be32(agno);
+	agf->agf_length = cpu_to_be32(agsize);
+	agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
+	agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
+	agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
+	agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
+	pag->pagf_levels[XFS_BTNUM_BNOi] = 1;
+	pag->pagf_levels[XFS_BTNUM_CNTi] = 1;
+
+	if (xfs_sb_version_hasrmapbt(sbp)) {
+		agf->agf_roots[XFS_BTNUM_RMAPi] = cpu_to_be32(XFS_RMAP_BLOCK(mp));
+		agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
+		agf->agf_rmap_blocks = cpu_to_be32(1);
+	}
+
+	if (xfs_sb_version_hasreflink(sbp)) {
+		agf->agf_refcount_root = cpu_to_be32(libxfs_refc_block(mp));
+		agf->agf_refcount_level = cpu_to_be32(1);
+		agf->agf_refcount_blocks = cpu_to_be32(1);
+	}
+
+	agf->agf_flfirst = 0;
+	agf->agf_fllast = cpu_to_be32(XFS_AGFL_SIZE(mp) - 1);
+	agf->agf_flcount = 0;
+	agblocks = (xfs_agblock_t)(agsize - libxfs_prealloc_blocks(mp));
+	agf->agf_freeblks = cpu_to_be32(agblocks);
+	agf->agf_longest = cpu_to_be32(agblocks);
+
+	if (xfs_sb_version_hascrc(sbp))
+		platform_uuid_copy(&agf->agf_uuid, &sbp->sb_uuid);
+
+	if (is_log_ag) {
+		be32_add_cpu(&agf->agf_freeblks, -(int64_t)cfg->logblocks);
+		agf->agf_longest = cpu_to_be32(agsize -
+			XFS_FSB_TO_AGBNO(mp, cfg->logstart) - cfg->logblocks);
+	}
+	if (libxfs_alloc_min_freelist(mp, pag) > *worst_freelist)
+		*worst_freelist = libxfs_alloc_min_freelist(mp, pag);
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+
+	/*
+	 * AG freelist header block
+	 */
+	buf = libxfs_getbuf(mp->m_ddev_targp,
+			XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
+			XFS_FSS_TO_BB(mp, 1));
+	buf->b_ops = &xfs_agfl_buf_ops;
+	agfl = XFS_BUF_TO_AGFL(buf);
+	/* setting to 0xff results in initialisation to NULLAGBLOCK */
+	memset(agfl, 0xff, cfg->sectorsize);
+	if (xfs_sb_version_hascrc(sbp)) {
+		agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
+		agfl->agfl_seqno = cpu_to_be32(agno);
+		platform_uuid_copy(&agfl->agfl_uuid, &sbp->sb_uuid);
+		for (bucket = 0; bucket < XFS_AGFL_SIZE(mp); bucket++)
+			agfl->agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
+	}
+
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+
+	/*
+	 * AG header block: inodes
+	 */
+	buf = libxfs_getbuf(mp->m_ddev_targp,
+			XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
+			XFS_FSS_TO_BB(mp, 1));
+	agi = XFS_BUF_TO_AGI(buf);
+	buf->b_ops = &xfs_agi_buf_ops;
+	memset(agi, 0, cfg->sectorsize);
+	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
+	agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
+	agi->agi_seqno = cpu_to_be32(agno);
+	agi->agi_length = cpu_to_be32(agsize);
+	agi->agi_count = 0;
+	agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
+	agi->agi_level = cpu_to_be32(1);
+	if (xfs_sb_version_hasfinobt(sbp)) {
+		agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp));
+		agi->agi_free_level = cpu_to_be32(1);
+	}
+	agi->agi_freecount = 0;
+	agi->agi_newino = cpu_to_be32(NULLAGINO);
+	agi->agi_dirino = cpu_to_be32(NULLAGINO);
+	if (xfs_sb_version_hascrc(sbp))
+		platform_uuid_copy(&agi->agi_uuid, &sbp->sb_uuid);
+	for (c = 0; c < XFS_AGI_UNLINKED_BUCKETS; c++)
+		agi->agi_unlinked[c] = cpu_to_be32(NULLAGINO);
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+
+	/*
+	 * BNO btree root block
+	 */
+	buf = libxfs_getbuf(mp->m_ddev_targp,
+			XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
+			BTOBB(cfg->blocksize));
+	buf->b_ops = &xfs_allocbt_buf_ops;
+	block = XFS_BUF_TO_BLOCK(buf);
+	memset(block, 0, cfg->blocksize);
+	libxfs_btree_init_block(mp, buf, XFS_BTNUM_BNO, 0, 1, agno, 0);
+
+	arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
+	arec->ar_startblock = cpu_to_be32(libxfs_prealloc_blocks(mp));
+	if (is_log_ag) {
+		xfs_agblock_t	start = XFS_FSB_TO_AGBNO(mp, cfg->logstart);
+
+		ASSERT(start >= libxfs_prealloc_blocks(mp));
+		if (start != libxfs_prealloc_blocks(mp)) {
+			/*
+			 * Modify first record to pad stripe align of log
+			 */
+			arec->ar_blockcount = cpu_to_be32(start -
+						libxfs_prealloc_blocks(mp));
+			nrec = arec + 1;
+			/*
+			 * Insert second record at start of internal log
+			 * which then gets trimmed.
+			 */
+			nrec->ar_startblock = cpu_to_be32(
+					be32_to_cpu(arec->ar_startblock) +
+					be32_to_cpu(arec->ar_blockcount));
+			arec = nrec;
+			be16_add_cpu(&block->bb_numrecs, 1);
+		}
+		/*
+		 * Change record start to after the internal log
+		 */
+		be32_add_cpu(&arec->ar_startblock, cfg->logblocks);
+	}
+	/*
+	 * Calculate the record block count and check for the case where
+	 * the log might have consumed all available space in the AG. If
+	 * so, reset the record count to 0 to avoid exposure of an invalid
+	 * record start block.
+	 */
+	arec->ar_blockcount = cpu_to_be32(agsize -
+					  be32_to_cpu(arec->ar_startblock));
+	if (!arec->ar_blockcount)
+		block->bb_numrecs = 0;
+
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+
+	/*
+	 * CNT btree root block
+	 */
+	buf = libxfs_getbuf(mp->m_ddev_targp,
+			XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
+			BTOBB(cfg->blocksize));
+	buf->b_ops = &xfs_allocbt_buf_ops;
+	block = XFS_BUF_TO_BLOCK(buf);
+	memset(block, 0, cfg->blocksize);
+	libxfs_btree_init_block(mp, buf, XFS_BTNUM_CNT, 0, 1, agno, 0);
+
+	arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
+	arec->ar_startblock = cpu_to_be32(libxfs_prealloc_blocks(mp));
+	if (is_log_ag) {
+		xfs_agblock_t	start = XFS_FSB_TO_AGBNO(mp, cfg->logstart);
+
+		ASSERT(start >= libxfs_prealloc_blocks(mp));
+		if (start != libxfs_prealloc_blocks(mp)) {
+			arec->ar_blockcount = cpu_to_be32(start -
+					libxfs_prealloc_blocks(mp));
+			nrec = arec + 1;
+			nrec->ar_startblock = cpu_to_be32(
+					be32_to_cpu(arec->ar_startblock) +
+					be32_to_cpu(arec->ar_blockcount));
+			arec = nrec;
+			be16_add_cpu(&block->bb_numrecs, 1);
+		}
+		be32_add_cpu(&arec->ar_startblock, cfg->logblocks);
+	}
+	/*
+	 * Calculate the record block count and check for the case where
+	 * the log might have consumed all available space in the AG. If
+	 * so, reset the record count to 0 to avoid exposure of an invalid
+	 * record start block.
+	 */
+	arec->ar_blockcount = cpu_to_be32(agsize -
+					  be32_to_cpu(arec->ar_startblock));
+	if (!arec->ar_blockcount)
+		block->bb_numrecs = 0;
+
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+
+	/*
+	 * refcount btree root block
+	 */
+	if (xfs_sb_version_hasreflink(sbp)) {
+		buf = libxfs_getbuf(mp->m_ddev_targp,
+			XFS_AGB_TO_DADDR(mp, agno, libxfs_refc_block(mp)),
+			BTOBB(cfg->blocksize));
+		buf->b_ops = &xfs_refcountbt_buf_ops;
+
+		block = XFS_BUF_TO_BLOCK(buf);
+		memset(block, 0, cfg->blocksize);
+		libxfs_btree_init_block(mp, buf, XFS_BTNUM_REFC, 0, 0, agno, 0);
+		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+	}
+
+	/*
+	 * INO btree root block
+	 */
+	buf = libxfs_getbuf(mp->m_ddev_targp,
+			XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
+			BTOBB(cfg->blocksize));
+	buf->b_ops = &xfs_inobt_buf_ops;
+	block = XFS_BUF_TO_BLOCK(buf);
+	memset(block, 0, cfg->blocksize);
+	libxfs_btree_init_block(mp, buf, XFS_BTNUM_INO, 0, 0, agno, 0);
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+
+	/*
+	 * Free INO btree root block
+	 */
+	if (xfs_sb_version_hasfinobt(sbp)) {
+		buf = libxfs_getbuf(mp->m_ddev_targp,
+				XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
+				BTOBB(cfg->blocksize));
+		buf->b_ops = &xfs_inobt_buf_ops;
+		block = XFS_BUF_TO_BLOCK(buf);
+		memset(block, 0, cfg->blocksize);
+		libxfs_btree_init_block(mp, buf, XFS_BTNUM_FINO, 0, 0, agno, 0);
+		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+	}
+
+	/* RMAP btree root block */
+	if (xfs_sb_version_hasrmapbt(sbp)) {
+		struct xfs_rmap_rec	*rrec;
+
+		buf = libxfs_getbuf(mp->m_ddev_targp,
+			XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
+			BTOBB(cfg->blocksize));
+		buf->b_ops = &xfs_rmapbt_buf_ops;
+		block = XFS_BUF_TO_BLOCK(buf);
+		memset(block, 0, cfg->blocksize);
+
+		libxfs_btree_init_block(mp, buf, XFS_BTNUM_RMAP, 0, 0, agno, 0);
+
+		/*
+		 * mark the AG header regions as static metadata
+		 * The BNO btree block is the first block after the
+		 * headers, so it's location defines the size of region
+		 * the static metadata consumes.
+		 */
+		rrec = XFS_RMAP_REC_ADDR(block, 1);
+		rrec->rm_startblock = 0;
+		rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
+
+		/* account freespace btree root blocks */
+		rrec = XFS_RMAP_REC_ADDR(block, 2);
+		rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
+		rrec->rm_blockcount = cpu_to_be32(2);
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
+
+		/* account inode btree root blocks */
+		rrec = XFS_RMAP_REC_ADDR(block, 3);
+		rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
+		rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
+						XFS_IBT_BLOCK(mp));
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
+
+		/* account for rmap btree root */
+		rrec = XFS_RMAP_REC_ADDR(block, 4);
+		rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
+		rrec->rm_blockcount = cpu_to_be32(1);
+		rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+		rrec->rm_offset = 0;
+		be16_add_cpu(&block->bb_numrecs, 1);
+
+		/* account for refcount btree root */
+		if (xfs_sb_version_hasreflink(sbp)) {
+			rrec = XFS_RMAP_REC_ADDR(block, 5);
+			rrec->rm_startblock = cpu_to_be32(libxfs_refc_block(mp));
+			rrec->rm_blockcount = cpu_to_be32(1);
+			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
+			rrec->rm_offset = 0;
+			be16_add_cpu(&block->bb_numrecs, 1);
+		}
+
+		/* account for the log space */
+		if (is_log_ag) {
+			rrec = XFS_RMAP_REC_ADDR(block,
+					be16_to_cpu(block->bb_numrecs) + 1);
+			rrec->rm_startblock = cpu_to_be32(
+					XFS_FSB_TO_AGBNO(mp, cfg->logstart));
+			rrec->rm_blockcount = cpu_to_be32(cfg->logblocks);
+			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_LOG);
+			rrec->rm_offset = 0;
+			be16_add_cpu(&block->bb_numrecs, 1);
+		}
+
+		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+	}
+
+	libxfs_perag_put(pag);
+}
+
+static void
+initialise_ag_freespace(
+	struct xfs_mount	*mp,
+	xfs_agnumber_t		agno,
+	int			worst_freelist)
+{
+	struct xfs_alloc_arg	args;
+	struct xfs_trans	*tp;
+	struct xfs_trans_res tres = {0};
+	int			c;
+
+	c = libxfs_trans_alloc(mp, &tres, worst_freelist, 0, 0, &tp);
+	if (c)
+		res_failed(c);
+
+	memset(&args, 0, sizeof(args));
+	args.tp = tp;
+	args.mp = mp;
+	args.agno = agno;
+	args.alignment = 1;
+	args.pag = libxfs_perag_get(mp, agno);
+
+	libxfs_alloc_fix_freelist(&args, 0);
+	libxfs_perag_put(args.pag);
+	libxfs_trans_commit(tp);
+}
+
 int
 main(
 	int			argc,
 	char			**argv)
 {
 	uint64_t		agcount;
-	xfs_agf_t		*agf;
-	xfs_agi_t		*agi;
 	xfs_agnumber_t		agno;
 	uint64_t		agsize;
-	xfs_alloc_rec_t		*arec;
-	struct xfs_btree_block	*block;
 	int			blflag;
 	int			blocklog;
 	int			bsflag;
-	int			bsize;
 	xfs_buf_t		*buf;
 	int			c;
 	int			daflag;

@@ -2152,7 +2531,6 @@ main(
 	int			nlflag;
 	int			nodsflag;
 	int			norsflag;
-	xfs_alloc_rec_t		*nrec;
 	int			nsflag;
 	int			nvflag;
 	int			Nflag;

@@ -3153,7 +3531,6 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 	validate_log_size(logblocks, blocklog, min_logblocks);
 
 	protostring = setup_proto(protofile);
-	bsize = 1 << (blocklog - BBSHIFT);
 	mp = &mbuf;
 	sbp = &mp->m_sb;
 	memset(mp, 0, sizeof(xfs_mount_t));

@@ -3284,363 +3661,16 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 	}
 
 	/*
-	 * XXX: this code is effectively shared with the kernel growfs code.
-	 * These initialisations should be pulled into libxfs to keep the
-	 * kernel/userspace header initialisation code the same.
+	 * Initialise all the static on disk metadata.
 	 */
-	for (agno = 0; agno < agcount; agno++) {
-		struct xfs_agfl	*agfl;
-		int		bucket;
-		struct xfs_perag *pag = libxfs_perag_get(mp, agno);
-
-		/*
-		 * Superblock.
-		 */
-		buf = libxfs_getbuf(mp->m_ddev_targp,
-				XFS_AG_DADDR(mp, agno, XFS_SB_DADDR),
-				XFS_FSS_TO_BB(mp, 1));
-		buf->b_ops = &xfs_sb_buf_ops;
-		memset(XFS_BUF_PTR(buf), 0, sectorsize);
-		libxfs_sb_to_disk((void *)XFS_BUF_PTR(buf), sbp);
-		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-
-		/*
-		 * AG header block: freespace
-		 */
-		buf = libxfs_getbuf(mp->m_ddev_targp,
-				XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
-				XFS_FSS_TO_BB(mp, 1));
-		buf->b_ops = &xfs_agf_buf_ops;
-		agf = XFS_BUF_TO_AGF(buf);
-		memset(agf, 0, sectorsize);
-		if (agno == agcount - 1)
-			agsize = dblocks - (xfs_rfsblock_t)(agno * agsize);
-		agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
-		agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
-		agf->agf_seqno = cpu_to_be32(agno);
-		agf->agf_length = cpu_to_be32(agsize);
-		agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
-		agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
-		agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
-		agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
-		pag->pagf_levels[XFS_BTNUM_BNOi] = 1;
-		pag->pagf_levels[XFS_BTNUM_CNTi] = 1;
-		if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
-			agf->agf_roots[XFS_BTNUM_RMAPi] =
-						cpu_to_be32(XFS_RMAP_BLOCK(mp));
-			agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
-			agf->agf_rmap_blocks = cpu_to_be32(1);
-		}
-		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-			agf->agf_refcount_root = cpu_to_be32(
-					libxfs_refc_block(mp));
-			agf->agf_refcount_level = cpu_to_be32(1);
-			agf->agf_refcount_blocks = cpu_to_be32(1);
-		}
-		agf->agf_flfirst = 0;
-		agf->agf_fllast = cpu_to_be32(XFS_AGFL_SIZE(mp) - 1);
-		agf->agf_flcount = 0;
-		nbmblocks = (xfs_extlen_t)(agsize - libxfs_prealloc_blocks(mp));
-		agf->agf_freeblks = cpu_to_be32(nbmblocks);
-		agf->agf_longest = cpu_to_be32(nbmblocks);
-		if (xfs_sb_version_hascrc(&mp->m_sb))
-			platform_uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_uuid);
-
-		if (loginternal && agno == logagno) {
-			be32_add_cpu(&agf->agf_freeblks, -logblocks);
-			agf->agf_longest = cpu_to_be32(agsize -
-				XFS_FSB_TO_AGBNO(mp, logstart) - logblocks);
-		}
-		if (libxfs_alloc_min_freelist(mp, pag) > worst_freelist)
-			worst_freelist = libxfs_alloc_min_freelist(mp, pag);
-		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-
-		/*
-		 * AG freelist header block
-		 */
-		buf = libxfs_getbuf(mp->m_ddev_targp,
-				XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
-				XFS_FSS_TO_BB(mp, 1));
-		buf->b_ops = &xfs_agfl_buf_ops;
-		agfl = XFS_BUF_TO_AGFL(buf);
-		/* setting to 0xff results in initialisation to NULLAGBLOCK */
-		memset(agfl, 0xff, sectorsize);
-		if (xfs_sb_version_hascrc(&mp->m_sb)) {
-			agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
-			agfl->agfl_seqno = cpu_to_be32(agno);
-			platform_uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_uuid);
-			for (bucket = 0; bucket < XFS_AGFL_SIZE(mp); bucket++)
-				agfl->agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
-		}
-
-		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-
-		/*
-		 * AG header block: inodes
-		 */
-		buf = libxfs_getbuf(mp->m_ddev_targp,
-				XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
-				XFS_FSS_TO_BB(mp, 1));
-		agi = XFS_BUF_TO_AGI(buf);
-		buf->b_ops = &xfs_agi_buf_ops;
-		memset(agi, 0, sectorsize);
-		agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
-		agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
-		agi->agi_seqno = cpu_to_be32(agno);
-		agi->agi_length = cpu_to_be32((xfs_agblock_t)agsize);
-		agi->agi_count = 0;
-		agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
-		agi->agi_level = cpu_to_be32(1);
-		if (sb_feat.finobt) {
-			agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp));
-			agi->agi_free_level = cpu_to_be32(1);
-		}
-		agi->agi_freecount = 0;
-		agi->agi_newino = cpu_to_be32(NULLAGINO);
-		agi->agi_dirino = cpu_to_be32(NULLAGINO);
-		if (xfs_sb_version_hascrc(&mp->m_sb))
-			platform_uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_uuid);
-		for (c = 0; c < XFS_AGI_UNLINKED_BUCKETS; c++)
-			agi->agi_unlinked[c] = cpu_to_be32(NULLAGINO);
-		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-
-		/*
-		 * BNO btree root block
-		 */
-		buf = libxfs_getbuf(mp->m_ddev_targp,
-				XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
-				bsize);
-		buf->b_ops = &xfs_allocbt_buf_ops;
-		block = XFS_BUF_TO_BLOCK(buf);
-		memset(block, 0, blocksize);
-		libxfs_btree_init_block(mp, buf, XFS_BTNUM_BNO, 0, 1, agno, 0);
-
-		arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
-		arec->ar_startblock = cpu_to_be32(libxfs_prealloc_blocks(mp));
-		if (loginternal && agno == logagno) {
-			if (lalign) {
-				/*
-				 * Have to insert two records
-				 * Insert pad record for stripe align of log
-				 */
-				arec->ar_blockcount = cpu_to_be32(
-					XFS_FSB_TO_AGBNO(mp, logstart) -
-					be32_to_cpu(arec->ar_startblock));
-				nrec = arec + 1;
-				/*
-				 * Insert record at start of internal log
-				 */
-				nrec->ar_startblock = cpu_to_be32(
-					be32_to_cpu(arec->ar_startblock) +
-					be32_to_cpu(arec->ar_blockcount));
-				arec = nrec;
-				be16_add_cpu(&block->bb_numrecs, 1);
-			}
-			/*
-			 * Change record start to after the internal log
-			 */
-			be32_add_cpu(&arec->ar_startblock, logblocks);
-		}
-		/*
-		 * Calculate the record block count and check for the case where
-		 * the log might have consumed all available space in the AG. If
-		 * so, reset the record count to 0 to avoid exposure of an invalid
-		 * record start block.
-		 */
-		arec->ar_blockcount = cpu_to_be32(agsize -
-					be32_to_cpu(arec->ar_startblock));
-		if (!arec->ar_blockcount)
-			block->bb_numrecs = 0;
-
-		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-
-		/*
-		 * CNT btree root block
-		 */
-		buf = libxfs_getbuf(mp->m_ddev_targp,
-				XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
-				bsize);
-		buf->b_ops = &xfs_allocbt_buf_ops;
-		block = XFS_BUF_TO_BLOCK(buf);
-		memset(block, 0, blocksize);
-		libxfs_btree_init_block(mp, buf, XFS_BTNUM_CNT, 0, 1, agno, 0);
-
-		arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
-		arec->ar_startblock = cpu_to_be32(libxfs_prealloc_blocks(mp));
-		if (loginternal && agno == logagno) {
-			if (lalign) {
-				arec->ar_blockcount = cpu_to_be32(
-					XFS_FSB_TO_AGBNO(mp, logstart) -
-					be32_to_cpu(arec->ar_startblock));
-				nrec = arec + 1;
-				nrec->ar_startblock = cpu_to_be32(
-					be32_to_cpu(arec->ar_startblock) +
-					be32_to_cpu(arec->ar_blockcount));
-				arec = nrec;
-				be16_add_cpu(&block->bb_numrecs, 1);
-			}
-			be32_add_cpu(&arec->ar_startblock, logblocks);
-		}
-		/*
-		 * Calculate the record block count and check for the case where
-		 * the log might have consumed all available space in the AG. If
-		 * so, reset the record count to 0 to avoid exposure of an invalid
-		 * record start block.
-		 */
-		arec->ar_blockcount = cpu_to_be32(agsize -
-					be32_to_cpu(arec->ar_startblock));
-		if (!arec->ar_blockcount)
-			block->bb_numrecs = 0;
-
-		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-
-		/*
-		 * refcount btree root block
-		 */
-		if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-			buf = libxfs_getbuf(mp->m_ddev_targp,
-					XFS_AGB_TO_DADDR(mp, agno,
-						libxfs_refc_block(mp)),
-					bsize);
-			buf->b_ops = &xfs_refcountbt_buf_ops;
-
-			block = XFS_BUF_TO_BLOCK(buf);
-			memset(block, 0, blocksize);
-			libxfs_btree_init_block(mp, buf, XFS_BTNUM_REFC, 0,
-						0, agno, 0);
-
-			libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-		}
-
-		/*
-		 * INO btree root block
-		 */
-		buf = libxfs_getbuf(mp->m_ddev_targp,
-				XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
-				bsize);
-		buf->b_ops = &xfs_inobt_buf_ops;
-		block = XFS_BUF_TO_BLOCK(buf);
-		memset(block, 0, blocksize);
-		libxfs_btree_init_block(mp, buf, XFS_BTNUM_INO, 0, 0, agno, 0);
-		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-
-		/*
-		 * Free INO btree root block
-		 */
-		if (sb_feat.finobt) {
-			buf = libxfs_getbuf(mp->m_ddev_targp,
-					XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
-					bsize);
-			buf->b_ops = &xfs_inobt_buf_ops;
-			block = XFS_BUF_TO_BLOCK(buf);
-			memset(block, 0, blocksize);
-			libxfs_btree_init_block(mp, buf, XFS_BTNUM_FINO, 0, 0, agno, 0);
-			libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-		}
-
-		/* RMAP btree root block */
-		if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
-			struct xfs_rmap_rec	*rrec;
-
-			buf = libxfs_getbuf(mp->m_ddev_targp,
-				XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
-				bsize);
-			buf->b_ops = &xfs_rmapbt_buf_ops;
-			block = XFS_BUF_TO_BLOCK(buf);
-			memset(block, 0, blocksize);
-
-			libxfs_btree_init_block(mp, buf, XFS_BTNUM_RMAP, 0, 0, agno, 0);
-
-			/*
-			 * mark the AG header regions as static metadata
-			 * The BNO btree block is the first block after the
-			 * headers, so it's location defines the size of region
-			 * the static metadata consumes.
-			 */
-			rrec = XFS_RMAP_REC_ADDR(block, 1);
-			rrec->rm_startblock = 0;
-			rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
-			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
-			rrec->rm_offset = 0;
-			be16_add_cpu(&block->bb_numrecs, 1);
-
-			/* account freespace btree root blocks */
-			rrec = XFS_RMAP_REC_ADDR(block, 2);
-			rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
-			rrec->rm_blockcount = cpu_to_be32(2);
-			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
-			rrec->rm_offset = 0;
-			be16_add_cpu(&block->bb_numrecs, 1);
-
-			/* account inode btree root blocks */
-			rrec = XFS_RMAP_REC_ADDR(block, 3);
-			rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
-			rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
-							XFS_IBT_BLOCK(mp));
-			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
-			rrec->rm_offset = 0;
-			be16_add_cpu(&block->bb_numrecs, 1);
-
-			/* account for rmap btree root */
-			rrec = XFS_RMAP_REC_ADDR(block, 4);
-			rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
-			rrec->rm_blockcount = cpu_to_be32(1);
-			rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
-			rrec->rm_offset = 0;
-			be16_add_cpu(&block->bb_numrecs, 1);
-
-			/* account for refcount btree root */
-			if (xfs_sb_version_hasreflink(&mp->m_sb)) {
-				rrec = XFS_RMAP_REC_ADDR(block, 5);
-				rrec->rm_startblock = cpu_to_be32(
-							libxfs_refc_block(mp));
-				rrec->rm_blockcount = cpu_to_be32(1);
-				rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
-				rrec->rm_offset = 0;
-				be16_add_cpu(&block->bb_numrecs, 1);
-			}
-
-			/* account for the log space */
-			if (loginternal && agno == logagno) {
-				rrec = XFS_RMAP_REC_ADDR(block,
-					be16_to_cpu(block->bb_numrecs) + 1);
-				rrec->rm_startblock = cpu_to_be32(
-						XFS_FSB_TO_AGBNO(mp, logstart));
-				rrec->rm_blockcount = cpu_to_be32(logblocks);
-				rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_LOG);
-				rrec->rm_offset = 0;
-				be16_add_cpu(&block->bb_numrecs, 1);
-			}
-
-			libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-		}
-
-		libxfs_perag_put(pag);
-	}
+	for (agno = 0; agno < cfg.agcount; agno++)
+		initialise_ag_headers(&cfg, mp, sbp, agno, &worst_freelist);
 
 	/*
-	 * BNO, CNT free block list
+	 * Initialise the freespace freelists (i.e. AGFLs) in each AG.
 	 */
-	for (agno = 0; agno < agcount; agno++) {
-		xfs_alloc_arg_t	args;
-		xfs_trans_t	*tp;
-		struct xfs_trans_res tres = {0};
-
-		c = libxfs_trans_alloc(mp, &tres, worst_freelist, 0, 0, &tp);
-		if (c)
-			res_failed(c);
-
-		memset(&args, 0, sizeof(args));
-		args.tp = tp;
-		args.mp = mp;
-		args.agno = agno;
-		args.alignment = 1;
-		args.pag = libxfs_perag_get(mp,agno);
-
-		libxfs_alloc_fix_freelist(&args, 0);
-		libxfs_perag_put(args.pag);
-		libxfs_trans_commit(tp);
-	}
+	for (agno = 0; agno < cfg.agcount; agno++)
+		initialise_ag_freespace(mp, agno, worst_freelist);
 
 	/*
 	 * Allocate the root inode and anything else in the proto file.

index 13af1ef1cd41..1fd5108be520 100644
@@ -2468,6 +2468,39 @@ initialise_ag_freespace(
 	libxfs_trans_commit(tp);
 }
 
+/*
+ * rewrite several secondary superblocks with the root inode number filled out.
+ * This can help repair recovery from a trashed primary superblock without
+ * losing the root inode.
+ */
+static void
+rewrite_secondary_superblocks(
+	struct xfs_mount	*mp)
+{
+	struct xfs_buf		*buf;
+
+	/* rewrite the last superblock */
+	buf = libxfs_readbuf(mp->m_dev,
+			XFS_AGB_TO_DADDR(mp, mp->m_sb.sb_agcount - 1,
+				XFS_SB_DADDR),
+			XFS_FSS_TO_BB(mp, 1),
+			LIBXFS_EXIT_ON_FAILURE, &xfs_sb_buf_ops);
+	XFS_BUF_TO_SBP(buf)->sb_rootino = cpu_to_be64(mp->m_sb.sb_rootino);
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+
+	/* and one in the middle for luck if there's enough AGs for that */
+	if (mp->m_sb.sb_agcount <= 2)
+		return;
+
+	buf = libxfs_readbuf(mp->m_dev,
+			XFS_AGB_TO_DADDR(mp, (mp->m_sb.sb_agcount - 1) / 2,
+				XFS_SB_DADDR),
+			XFS_FSS_TO_BB(mp, 1),
+			LIBXFS_EXIT_ON_FAILURE, &xfs_sb_buf_ops);
+	XFS_BUF_TO_SBP(buf)->sb_rootino = cpu_to_be64(mp->m_sb.sb_rootino);
+	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
+}
+
 int
 main(
 	int			argc,

@@ -3688,34 +3721,10 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 	}
 
 	/*
-	 * Write out multiple secondary superblocks with rootinode field set
+	 * Re-write multiple secondary superblocks with rootinode field set
 	 */
-	if (mp->m_sb.sb_agcount > 1) {
-		/*
-		 * the last superblock
-		 */
-		buf = libxfs_readbuf(mp->m_dev,
-				XFS_AGB_TO_DADDR(mp, mp->m_sb.sb_agcount-1,
-					XFS_SB_DADDR),
-				XFS_FSS_TO_BB(mp, 1),
-				LIBXFS_EXIT_ON_FAILURE, &xfs_sb_buf_ops);
-		XFS_BUF_TO_SBP(buf)->sb_rootino = cpu_to_be64(
-							mp->m_sb.sb_rootino);
-		libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-		/*
-		 * and one in the middle for luck
-		 */
-		if (mp->m_sb.sb_agcount > 2) {
-			buf = libxfs_readbuf(mp->m_dev,
-				XFS_AGB_TO_DADDR(mp, (mp->m_sb.sb_agcount-1)/2,
-					XFS_SB_DADDR),
-				XFS_FSS_TO_BB(mp, 1),
-				LIBXFS_EXIT_ON_FAILURE, &xfs_sb_buf_ops);
-			XFS_BUF_TO_SBP(buf)->sb_rootino = cpu_to_be64(
-							mp->m_sb.sb_rootino);
-			libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
-		}
-	}
+	if (mp->m_sb.sb_agcount > 1)
+		rewrite_secondary_superblocks(mp);
 
 	/*
 	 * Dump all inodes and buffers before marking us all done.

index 1fd5108be520..e53e56a1bd47 100644
@@ -851,6 +851,27 @@ struct mkfs_params {
 	struct sb_feat_args	sb_feat;
 };
 
+/*
+ * Default filesystem features and configuration values
+ *
+ * This structure contains the default mkfs values that are to be used when
+ * a user does not specify the option on the command line. We do not use these
+ * values directly - they are inputs to the mkfs geometry validation and
+ * calculations.
+ */
+struct mkfs_default_params {
+	char	*source;	/* where the defaults came from */
+
+	int	sectorsize;
+	int	blocksize;
+
+	/* feature flags that are set */
+	struct sb_feat_args	sb_feat;
+
+	/* root inode characteristics */
+	struct fsxattr		fsx;
+};
+
 #define TERABYTES(count, blog)	((uint64_t)(count) << (40 - (blog)))
 #define GIGABYTES(count, blog)	((uint64_t)(count) << (30 - (blog)))
 #define MEGABYTES(count, blog)	((uint64_t)(count) << (20 - (blog)))

@@ -2587,25 +2608,33 @@ main(
 	int			worst_freelist;
 	libxfs_init_t		xi;
 	struct fs_topology	ft;
-	struct sb_feat_args	sb_feat = {
-		.finobt = 1,
-		.spinodes = 0,
-		.log_version = 2,
-		.attr_version = 2,
-		.dir_version = XFS_DFL_DIR_VERSION,
-		.inode_align = XFS_IFLAG_ALIGN,
-		.nci = false,
-		.lazy_sb_counters = true,
-		.projid16bit = false,
-		.crcs_enabled = true,
-		.dirftype = true,
-		.parent_pointers = false,
-		.rmapbt = false,
-		.reflink = false,
+	struct sb_feat_args	sb_feat;
+	/* build time defaults */
+	struct mkfs_default_params	dft = {
+		.source = "package build definitions",
+		.sectorsize = XFS_MIN_SECTORSIZE,
+		.blocksize = 1 << XFS_DFL_BLOCKSIZE_LOG,
+		.sb_feat = {
+			.log_version = 2,
+			.attr_version = 2,
+			.dir_version = XFS_DFL_DIR_VERSION,
+			.inode_align = XFS_IFLAG_ALIGN,
+			.nci = false,
+			.lazy_sb_counters = true,
+			.projid16bit = false,
+			.crcs_enabled = true,
+			.dirftype = true,
+			.finobt = true,
+			.spinodes = false,
+			.rmapbt = false,
+			.reflink = false,
+			.parent_pointers = false,
+			.nodalign = false,
+			.nortalign = false,
+		},
 	};
 	struct cli_params	cli = {
 		.xi = &xi,
-		.sb_feat = sb_feat,
 	};
 	struct mkfs_params	cfg = {};
 

@@ -2615,6 +2644,22 @@ main(
 	bindtextdomain(PACKAGE, LOCALEDIR);
 	textdomain(PACKAGE);
 
+	/*
+	 * TODO: Sourcing defaults from a config file
+	 *
+	 * Before anything else, see if there's a config file with different
+	 * defaults. If a file exists in <package location>, read in the new
+	 * default values and overwrite them in the &dft structure. This way the
+	 * new defaults will apply before we parse the CLI, and the CLI will
+	 * still be able to override them. Emit a message to indicate where the
+	 * defaults being used came from.
+	 */
+	printf(_("Default configuration sourced from %s\n"), dft.source);
+
+	/* copy new defaults into CLI parsing structure */
+	memcpy(&cli.sb_feat, &dft.sb_feat, sizeof(cli.sb_feat));
+	memcpy(&cli.fsx, &dft.fsx, sizeof(cli.fsx));
+
 	blflag = bsflag = slflag = ssflag = lslflag = lssflag = 0;
 	blocklog = blocksize = 0;
 	sectorlog = lsectorlog = 0;

index e53e56a1bd47..7b71f59dc654 100644
@@ -2587,11 +2587,11 @@ main(
 	int			norsflag;
 	int			nsflag;
 	int			nvflag;
-	int			Nflag;
+	int			dry_run;
 	int			discard = 1;
 	char			*protofile;
 	char			*protostring;
-	int			qflag;
+	int			quiet;
 	xfs_rfsblock_t		rtblocks;
 	xfs_extlen_t		rtextblocks;
 	xfs_rtblock_t		rtextents;

@@ -2669,9 +2669,9 @@ main(
 	liflag = laflag = lsflag = lsuflag = lsunitflag = ldflag = lvflag = 0;
 	loginternal = 1;
 	logagno = logblocks = rtblocks = rtextblocks = 0;
-	Nflag = nlflag = nsflag = nvflag = 0;
+	dry_run = nlflag = nsflag = nvflag = 0;
 	dirblocklog = dirblocksize = 0;
-	qflag = 0;
+	quiet = 0;
 	imaxpct = inodelog = inopblock = isize = 0;
 	dfile = logfile = rtfile = NULL;
 	dsize = logsize = rtsize = rtextsize = protofile = NULL;

@@ -2800,7 +2800,7 @@ main(
 			/* end temp don't break code */
 			break;
 		case 'N':
-			Nflag = 1;
+			dry_run = 1;
 			break;
 		case 'K':
 			discard = 0;

@@ -2811,7 +2811,7 @@ main(
 			protofile = optarg;
 			break;
 		case 'q':
-			qflag = 1;
+			quiet = 1;
 			break;
 		case 'r':
 			parse_subopts(c, optarg, &cli);

@@ -2896,14 +2896,14 @@ _("Minimum block size for CRC enabled filesystems is %d bytes.\n"),
 	 * host filesystem.
 	 */
 	check_device_type(dfile, &xi.disfile, !dsize, !dfile,
-			  Nflag ? NULL : &xi.dcreat, force_overwrite, "d");
+			  dry_run ? NULL : &xi.dcreat, force_overwrite, "d");
 	if (!loginternal)
 		check_device_type(xi.logname, &xi.lisfile, !logsize, !xi.logname,
-				  Nflag ? NULL : &xi.lcreat,
+				  dry_run ? NULL : &xi.lcreat,
 				  force_overwrite, "l");
 	if (xi.rtname)
 		check_device_type(xi.rtname, &xi.risfile, !rtsize, !xi.rtname,
-				  Nflag ? NULL : &xi.rcreat,
+				  dry_run ? NULL : &xi.rcreat,
 				  force_overwrite, "r");
 	if (xi.disfile || xi.lisfile || xi.risfile)
 		xi.isdirect = 0;

@@ -3259,7 +3259,7 @@ _("rmapbt not supported with realtime devices\n"));
 
 
 	/* don't do discards on print-only runs or on files */
-	if (discard && !Nflag) {
+	if (discard && !dry_run) {
 		if (!xi.disfile)
 			discard_blocks(xi.ddev, xi.dsize);
 		if (xi.rtdev && !xi.risfile)

@@ -3709,9 +3709,9 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
 	memcpy(&cfg.sb_feat, &sb_feat, sizeof(sb_feat));
 	/* end temp support code */
 
-	if (!qflag || Nflag) {
+	if (!quiet || dry_run) {
 		print_mkfs_cfg(&cfg, dfile, logfile, rtfile);
-		if (Nflag)
+		if (dry_run)
 			exit(0);
 	}
 

index 7b71f59dc654..a6d2dd516319 100644
@@ -1903,6 +1903,107 @@ parse_subopts(
 }
 
 static void
+validate_sectorsize(
+	struct mkfs_params	*cfg,
+	struct cli_params	*cli,
+	struct mkfs_default_params *dft,
+	struct fs_topology	*ft,
+	char			*dfile,
+	int			dry_run,
+	int			force_overwrite)
+{
+	/* set configured sector sizes in preparation for checks */
+	if (!cli->sectorsize) {
+		cfg->sectorsize = dft->sectorsize;
+	} else {
+		cfg->sectorsize = cli->sectorsize;
+	}
+	cfg->sectorlog = libxfs_highbit32(cfg->sectorsize);
+
+	/*
+	 * Before anything else, verify that we are correctly operating on
+	 * files or block devices and set the control parameters correctly.
+	 */
+	check_device_type(dfile, &cli->xi->disfile, !cli->dsize, !dfile,
+			  dry_run ? NULL : &cli->xi->dcreat,
+			  force_overwrite, "d");
+	if (!cli->loginternal)
+		check_device_type(cli->xi->logname, &cli->xi->lisfile,
+				  !cli->logsize, !cli->xi->logname,
+				  dry_run ? NULL : &cli->xi->lcreat,
+				  force_overwrite, "l");
+	if (cli->xi->rtname)
+		check_device_type(cli->xi->rtname, &cli->xi->risfile,
+				  !cli->rtsize, !cli->xi->rtname,
+				  dry_run ? NULL : &cli->xi->rcreat,
+				  force_overwrite, "r");
+
+	/*
+	 * Explicitly disable direct IO for image files so we don't error out on
+	 * sector size mismatches between the new filesystem and the underlying
+	 * host filesystem.
+	 */
+	if (cli->xi->disfile || cli->xi->lisfile || cli->xi->risfile)
+		cli->xi->isdirect = 0;
+
+	memset(ft, 0, sizeof(*ft));
+	get_topology(cli->xi, ft, force_overwrite);
+
+	if (!cli->sectorsize) {
+		/*
+		 * Unless specified manually on the command line use the
+		 * advertised sector size of the device.  We use the physical
+		 * sector size unless the requested block size is smaller
+		 * than that, then we can use logical, but warn about the
+		 * inefficiency.
+		 *
+		 * Set the topology sectors if they were not probed to the
+		 * minimum supported sector size.
+		 */
+
+		if (!ft->lsectorsize)
+			ft->lsectorsize = XFS_MIN_SECTORSIZE;
+
+		/* Older kernels may not have physical/logical distinction */
+		if (!ft->psectorsize)
+			ft->psectorsize = ft->lsectorsize;
+
+		cfg->sectorsize = ft->psectorsize;
+		if (cfg->blocksize < cfg->sectorsize &&
+		    cfg->blocksize >= ft->lsectorsize) {
+			fprintf(stderr,
+_("specified blocksize %d is less than device physical sector size %d\n"
+  "switching to logical sector size %d\n"),
+				cfg->blocksize, ft->psectorsize,
+				ft->lsectorsize);
+			cfg->sectorsize = ft->lsectorsize;
+		}
+
+		cfg->sectorlog = libxfs_highbit32(cfg->sectorsize);
+	}
+
+	/* validate specified/probed sector size */
+	if (cfg->sectorsize < XFS_MIN_SECTORSIZE ||
+	    cfg->sectorsize > XFS_MAX_SECTORSIZE) {
+		fprintf(stderr, _("illegal sector size %d\n"), cfg->sectorsize);
+		usage();
+	}
+
+	if (cfg->blocksize < cfg->sectorsize) {
+		fprintf(stderr,
+_("block size %d cannot be smaller than sector size %d\n"),
+			cfg->blocksize, cfg->sectorsize);
+		usage();
+	}
+
+	if (cfg->sectorsize < ft->lsectorsize) {
+		fprintf(stderr, _("illegal sector size %d; hw sector is %d\n"),
+			cfg->sectorsize, ft->lsectorsize);
+		usage();
+	}
+}
+
+static void
 print_mkfs_cfg(
 	struct mkfs_params	*cfg,
 	char			*dfile,

@@ -2601,8 +2702,6 @@ main(
 	xfs_sb_t		*sbp;
 	int			sectorlog;
 	uint64_t		sector_mask;
-	int			slflag;
-	int			ssflag;
 	uint64_t		tmp_agsize;
 	uuid_t			uuid;
 	int			worst_freelist;

@@ -2660,10 +2759,10 @@ main(
 	memcpy(&cli.sb_feat, &dft.sb_feat, sizeof(cli.sb_feat));
 	memcpy(&cli.fsx, &dft.fsx, sizeof(cli.fsx));
 
-	blflag = bsflag = slflag = ssflag = lslflag = lssflag = 0;
+	blflag = bsflag = lslflag = lssflag = 0;
 	blocklog = blocksize = 0;
-	sectorlog = lsectorlog = 0;
-	sectorsize = lsectorsize = 0;
+	lsectorlog = 0;
+	lsectorsize = 0;
 	agsize = daflag = dasize = dblocks = 0;
 	ilflag = imflag = ipflag = isflag = 0;
 	liflag = laflag = lsflag = lsuflag = lsunitflag = ldflag = lvflag = 0;

@@ -2724,11 +2823,6 @@ main(
 				  cli_opt_set(&dopts, D_SWIDTH);
 			nodsflag = cli_opt_set(&dopts, D_NOALIGN);
 
-			sectorsize = cli.sectorsize;
-			sectorlog = libxfs_highbit32(sectorsize);
-			slflag = cli_opt_set(&dopts, D_SECTLOG);
-			ssflag = cli_opt_set(&dopts, D_SECTSIZE);
-
 			fsx.fsx_xflags |= cli.fsx.fsx_xflags;
 			fsx.fsx_projid = cli.fsx.fsx_projid;
 			fsx.fsx_extsize = cli.fsx.fsx_extsize;

@@ -2826,14 +2920,12 @@ main(
 			parse_subopts(c, optarg, &cli);
 
 			/* temp don't break code */
-			sectorsize = cli.sectorsize;
-			lsectorlog = libxfs_highbit32(sectorsize);
 			lsectorsize = cli.lsectorsize;
 			lsectorlog = libxfs_highbit32(lsectorsize);
-			lslflag = slflag = cli_opt_set(&sopts, S_LOG) ||
+			lslflag = cli_opt_set(&sopts, S_LOG) ||
 					   cli_opt_set(&sopts, S_SECTLOG);
 
-			lssflag = ssflag = cli_opt_set(&sopts, S_SIZE) ||
+			lssflag = cli_opt_set(&sopts, S_SIZE) ||
 					   cli_opt_set(&sopts, S_SECTSIZE);
 			break;
 		case 'V':

@@ -2879,89 +2971,18 @@ _("Minimum block size for CRC enabled filesystems is %d bytes.\n"),
 		usage();
 	}
 
-	if (!slflag && !ssflag) {
-		sectorlog = XFS_MIN_SECTORSIZE_LOG;
-		sectorsize = XFS_MIN_SECTORSIZE;
-	}
-	if (!lslflag && !lssflag) {
-		lsectorlog = sectorlog;
-		lsectorsize = sectorsize;
-	}
-
 	/*
-	 * Before anything else, verify that we are correctly operating on
-	 * files or block devices and set the control parameters correctly.
-	 * Explicitly disable direct IO for image files so we don't error out on
-	 * sector size mismatches between the new filesystem and the underlying
-	 * host filesystem.
+	 * Extract as much of the valid config as we can from the CLI input
+	 * before opening the libxfs devices.
 	 */
-	check_device_type(dfile, &xi.disfile, !dsize, !dfile,
-			  dry_run ? NULL : &xi.dcreat, force_overwrite, "d");
-	if (!loginternal)
-		check_device_type(xi.logname, &xi.lisfile, !logsize, !xi.logname,
-				  dry_run ? NULL : &xi.lcreat,
-				  force_overwrite, "l");
-	if (xi.rtname)
-		check_device_type(xi.rtname, &xi.risfile, !rtsize, !xi.rtname,
-				  dry_run ? NULL : &xi.rcreat,
-				  force_overwrite, "r");
-	if (xi.disfile || xi.lisfile || xi.risfile)
-		xi.isdirect = 0;
-
-	memset(&ft, 0, sizeof(ft));
-	get_topology(&xi, &ft, force_overwrite);
-
-	if (!ssflag) {
-		/*
-		 * Unless specified manually on the command line use the
-		 * advertised sector size of the device.  We use the physical
-		 * sector size unless the requested block size is smaller
-		 * than that, then we can use logical, but warn about the
-		 * inefficiency.
-		 */
-
-		/* Older kernels may not have physical/logical distinction */
-		if (!ft.psectorsize)
-			ft.psectorsize = ft.lsectorsize;
-
-		sectorsize = ft.psectorsize ? ft.psectorsize :
-					      XFS_MIN_SECTORSIZE;
-
-		if ((blocksize < sectorsize) && (blocksize >= ft.lsectorsize)) {
-			fprintf(stderr,
-_("specified blocksize %d is less than device physical sector size %d\n"),
-				blocksize, ft.psectorsize);
-			fprintf(stderr,
-_("switching to logical sector size %d\n"),
-				ft.lsectorsize);
-			sectorsize = ft.lsectorsize ? ft.lsectorsize :
-						      XFS_MIN_SECTORSIZE;
-		}
-	}
+	validate_sectorsize(&cfg, &cli, &dft, &ft, dfile, dry_run,
+			    force_overwrite);
 
-	if (!ssflag) {
-		sectorlog = libxfs_highbit32(sectorsize);
-		if (loginternal) {
-			lsectorsize = sectorsize;
-			lsectorlog = sectorlog;
-		}
-	}
+	/* temp don't break code */
+	sectorsize = cfg.sectorsize;
+	sectorlog = cfg.sectorlog;
+	/* end temp don't break code */
 
-	if (sectorsize < XFS_MIN_SECTORSIZE ||
-	    sectorsize > XFS_MAX_SECTORSIZE || sectorsize > blocksize) {
-		if (ssflag)
-			fprintf(stderr, _("illegal sector size %d\n"), sectorsize);
-		else
-			fprintf(stderr,
-_("block size %d cannot be smaller than logical sector size %d\n"),
-				blocksize, ft.lsectorsize);
-		usage();
-	}
-	if (sectorsize < ft.lsectorsize) {
-		fprintf(stderr, _("illegal sector size %d; hw sector is %d\n"),
-			sectorsize, ft.lsectorsize);
-		usage();
-	}
 	if (lsectorsize < XFS_MIN_SECTORSIZE ||
 	    lsectorsize > XFS_MAX_SECTORSIZE || lsectorsize > blocksize) {
 		fprintf(stderr, _("illegal log sector size %d\n"), lsectorsize);

index a6d2dd516319..4e256942173f 100644
@@ -2004,6 +2004,40 @@ _("block size %d cannot be smaller than sector size %d\n"),
 }
 
 static void
+validate_blocksize(
+	struct mkfs_params	*cfg,
+	struct cli_params	*cli,
+	struct mkfs_default_params *dft)
+{
+	/*
+	 * Blocksize and sectorsize first, other things depend on them
+	 * For RAID4/5/6 we want to align sector size and block size,
+	 * so we need to start with the device geometry extraction too.
+	 */
+	if (!cli->blocksize)
+		cfg->blocksize = dft->blocksize;
+	else
+		cfg->blocksize = cli->blocksize;
+	cfg->blocklog = libxfs_highbit32(cfg->blocksize);
+
+	/* validate block sizes are in range */
+	if (cfg->blocksize < XFS_MIN_BLOCKSIZE ||
+	    cfg->blocksize > XFS_MAX_BLOCKSIZE) {
+		fprintf(stderr, _("illegal block size %d\n"), cfg->blocksize);
+		usage();
+	}
+
+	if (cli->sb_feat.crcs_enabled &&
+	    cfg->blocksize < XFS_MIN_CRC_BLOCKSIZE) {
+		fprintf(stderr,
+_("Minimum block size for CRC enabled filesystems is %d bytes.\n"),
+			XFS_MIN_CRC_BLOCKSIZE);
+		usage();
+	}
+
+}
+
+static void
 print_mkfs_cfg(
 	struct mkfs_params	*cfg,
 	char			*dfile,

@@ -2631,9 +2665,7 @@ main(
 	uint64_t		agcount;
 	xfs_agnumber_t		agno;
 	uint64_t		agsize;
-	int			blflag;
 	int			blocklog;
-	int			bsflag;
 	xfs_buf_t		*buf;
 	int			c;
 	int			daflag;

@@ -2759,8 +2791,7 @@ main(
 	memcpy(&cli.sb_feat, &dft.sb_feat, sizeof(cli.sb_feat));
 	memcpy(&cli.fsx, &dft.fsx, sizeof(cli.fsx));
 
-	blflag = bsflag = lslflag = lssflag = 0;
-	blocklog = blocksize = 0;
+	lslflag = lssflag = 0;
 	lsectorlog = 0;
 	lsectorsize = 0;
 	agsize = daflag = dasize = dblocks = 0;

@@ -2792,13 +2823,6 @@ main(
 			break;
 		case 'b':
 			parse_subopts(c, optarg, &cli);
-
-			/* temp don't break code */
-			blocksize = cli.blocksize;
-			blocklog = libxfs_highbit32(blocksize);
-			blflag = cli_opt_set(&bopts, B_LOG);
-			bsflag = cli_opt_set(&bopts, B_SIZE);
-			/* end temp don't break code */
 			break;
 		case 'd':
 			parse_subopts(c, optarg, &cli);

@@ -2947,25 +2971,6 @@ main(
 	sb_feat = cli.sb_feat;
 	/* end temp don't break code */
 
-	/*
-	 * Blocksize and sectorsize first, other things depend on them
-	 * For RAID4/5/6 we want to align sector size and block size,
-	 * so we need to start with the device geometry extraction too.
-	 */
-	if (!blflag && !bsflag) {
-		blocklog = XFS_DFL_BLOCKSIZE_LOG;
-		blocksize = 1 << XFS_DFL_BLOCKSIZE_LOG;
-	}
-	if (blocksize < XFS_MIN_BLOCKSIZE || blocksize > XFS_MAX_BLOCKSIZE) {
-		fprintf(stderr, _("illegal block size %d\n"), blocksize);
-		usage();
-	}
-	if (sb_feat.crcs_enabled && blocksize < XFS_MIN_CRC_BLOCKSIZE) {
-		fprintf(stderr,
-_("Minimum block size for CRC enabled filesystems is %d bytes.\n"),
-			XFS_MIN_CRC_BLOCKSIZE);
-		usage();
-	}
 	if (sb_feat.crcs_enabled && !sb_feat.dirftype) {
 		fprintf(stderr, _("cannot disable ftype with crcs enabled\n"));
 		usage();

@@ -2975,12 +2980,15 @@ _("Minimum block size for CRC enabled filesystems is %d bytes.\n"),
 	 * Extract as much of the valid config as we can from the CLI input
 	 * before opening the libxfs devices.
 	 */
+	validate_blocksize(&cfg, &cli, &dft);
 	validate_sectorsize(&cfg, &cli, &dft, &ft, dfile, dry_run,
 			    force_overwrite);
 
 	/* temp don't break code */
 	sectorsize = cfg.sectorsize;
 	sectorlog = cfg.sectorlog;
+	blocksize = cfg.blocksize;
+	blocklog = cfg.blocklog;
 	/* end temp don't break code */
 
 	if (lsectorsize < XFS_MIN_SECTORSIZE ||

index 4e256942173f..64542442148c 100644
@@ -2037,6 +2037,59 @@ _("Minimum block size for CRC enabled filesystems is %d bytes.\n"),
 
 }
 
+/*
+ * Grab log sector size and validate.
+ *
+ * XXX: should we probe sector size on external log device rather than using
+ * the data device sector size?
+ */
+static void
+validate_log_sectorsize(
+	struct mkfs_params	*cfg,
+	struct cli_params	*cli,
+	struct mkfs_default_params *dft)
+{
+
+	if (cli->loginternal && cli->lsectorsize &&
+	    cli->lsectorsize != cfg->sectorsize) {
+		fprintf(stderr,
+_("Can't change sector size on internal log!\n"));
+		usage();
+	}
+
+	if (!cli->lsectorsize)
+		cfg->lsectorsize = dft->sectorsize;
+	else
+		cfg->lsectorsize = cli->lsectorsize;
+	cfg->lsectorlog = libxfs_highbit32(cfg->lsectorsize);
+
+	if (cfg->lsectorsize < XFS_MIN_SECTORSIZE ||
+	    cfg->lsectorsize > XFS_MAX_SECTORSIZE ||
+	    cfg->lsectorsize > cfg->blocksize) {
+		fprintf(stderr, _("illegal log sector size %d\n"),
+			cfg->lsectorsize);
+		usage();
+	}
+	if (cfg->lsectorsize > XFS_MIN_SECTORSIZE) {
+		if (cli->sb_feat.log_version < 2) {
+			/* user specified non-default log version */
+			fprintf(stderr,
+_("Version 1 logs do not support sector size %d\n"),
+				cfg->lsectorsize);
+			usage();
+		}
+	}
+
+	/* if lsu or lsunit was specified, automatically use v2 logs */
+	if ((cli_opt_set(&lopts, L_SU) || cli_opt_set(&lopts, L_SUNIT)) &&
+	    cli->sb_feat.log_version == 1) {
+		fprintf(stderr,
+_("log stripe unit specified, using v2 logs\n"));
+		cli->sb_feat.log_version = 2;
+	}
+
+}
+
 static void
 print_mkfs_cfg(
 	struct mkfs_params	*cfg,

@@ -2707,8 +2760,6 @@ main(
 	int			lsunitflag;
 	int			lsectorlog;
 	int			lsectorsize;
-	int			lslflag;
-	int			lssflag;
 	int			lsu;
 	int			lsunit;
 	int			min_logblocks;

@@ -2791,9 +2842,13 @@ main(
 	memcpy(&cli.sb_feat, &dft.sb_feat, sizeof(cli.sb_feat));
 	memcpy(&cli.fsx, &dft.fsx, sizeof(cli.fsx));
 
-	lslflag = lssflag = 0;
-	lsectorlog = 0;
-	lsectorsize = 0;
+	/*
+	 * Initialise cli parameters that can be set to zero to an appropriate
+	 * value so we can tell if they have been set or or changed from the
+	 * default value.
+	 */
+	cli.loginternal = 1;	/* internal by default */
+
 	agsize = daflag = dasize = dblocks = 0;
 	ilflag = imflag = ipflag = isflag = 0;
 	liflag = laflag = lsflag = lsuflag = lsunitflag = ldflag = lvflag = 0;

@@ -2822,6 +2877,7 @@ main(
 			force_overwrite = 1;
 			break;
 		case 'b':
+		case 's':
 			parse_subopts(c, optarg, &cli);
 			break;
 		case 'd':

@@ -2875,8 +2931,6 @@ main(
 			loginternal = cli.loginternal;
 			logfile = xi.logname;
 			logsize = cli.logsize;
-			lsectorsize = cli.lsectorsize;
-			lsectorlog = libxfs_highbit32(lsectorsize);
 
 			lsunit = cli.lsunit;
 			lsunitflag = cli_opt_set(&lopts, L_SUNIT);

@@ -2890,8 +2944,6 @@ main(
 			ldflag = cli_opt_set(&lopts, L_NAME) ||
 				 cli_opt_set(&lopts, L_DEV);
 			lvflag = cli_opt_set(&lopts, L_VERSION);
-			lslflag = cli_opt_set(&lopts, L_SECTLOG);
-			lssflag = cli_opt_set(&lopts, L_SECTSIZE);
 			/* end temp don't break code */
 			break;
 		case 'L':

@@ -2940,17 +2992,6 @@ main(
 			norsflag = cli.sb_feat.nortalign;
 			/* end temp don't break code */
 			break;
-		case 's':
-			parse_subopts(c, optarg, &cli);
-
-			/* temp don't break code */
-			lsectorsize = cli.lsectorsize;
-			lsectorlog = libxfs_highbit32(lsectorsize);
-			lslflag = cli_opt_set(&sopts, S_LOG) ||
-					   cli_opt_set(&sopts, S_SECTLOG);
-
-			lssflag = cli_opt_set(&sopts, S_SIZE) ||
-					   cli_opt_set(&sopts, S_SECTSIZE);
 			break;
 		case 'V':
 			printf(_("%s version %s\n"), progname, VERSION);

@@ -2983,23 +3024,18 @@ main(
 	validate_blocksize(&cfg, &cli, &dft);
 	validate_sectorsize(&cfg, &cli, &dft, &ft, dfile, dry_run,
 			    force_overwrite);
+	validate_log_sectorsize(&cfg, &cli, &dft);
 
 	/* temp don't break code */
 	sectorsize = cfg.sectorsize;
 	sectorlog = cfg.sectorlog;
 	blocksize = cfg.blocksize;
 	blocklog = cfg.blocklog;
+	lsectorsize = cfg.lsectorsize;
+	lsectorlog = cfg.lsectorlog;
+	sb_feat = cfg.sb_feat;
 	/* end temp don't break code */
 
-	if (lsectorsize < XFS_MIN_SECTORSIZE ||
-	    lsectorsize > XFS_MAX_SECTORSIZE || lsectorsize > blocksize) {
-		fprintf(stderr, _("illegal log sector size %d\n"), lsectorsize);
-		usage();
-	} else if (lsectorsize > XFS_MIN_SECTORSIZE && !lsu && !lsunit) {
-		lsu = blocksize;
-		sb_feat.log_version = 2;
-	}
-
 	/*
 	 * Now we have blocks and sector sizes set up, check parameters that are
 	 * no longer optional for CRC enabled filesystems.  Catch them up front

@@ -3244,13 +3280,6 @@ _("rmapbt not supported with realtime devices\n"));
 		exit(1);
 	}
 
-	/* if lsu or lsunit was specified, automatically use v2 logs */
-	if ((lsu || lsunit) && sb_feat.log_version == 1) {
-		fprintf(stderr,
-			_("log stripe unit specified, using v2 logs\n"));
-		sb_feat.log_version = 2;
-	}
-
 	calc_stripe_factors(dsu, dsw, sectorsize, lsu, lsectorsize,
 				&dsunit, &dswidth, &lsunit);
 

index 64542442148c..1c697dd5d4e1 100644
@@ -2090,6 +2090,130 @@ _("log stripe unit specified, using v2 logs\n"));
 
 }
 
+/*
+ * Check that the incoming features make sense. The CLI structure was
+ * initialised with the default values before parsing, so we can just
+ * check it and copy it straight across to the cfg structure if it
+ * checks out.
+ */
+static void
+validate_sb_features(
+	struct mkfs_params	*cfg,
+	struct cli_params	*cli)
+{
+	/*
+	 * Now we have blocks and sector sizes set up, check parameters that are
+	 * no longer optional for CRC enabled filesystems.  Catch them up front
+	 * here before doing anything else.
+	 */
+	if (cli->sb_feat.crcs_enabled) {
+		/* minimum inode size is 512 bytes, rest checked later */
+		if (cli->inodesize &&
+		    cli->inodesize < (1 << XFS_DINODE_DFL_CRC_LOG)) {
+			fprintf(stderr,
+_("Minimum inode size for CRCs is %d bytes\n"),
+				1 << XFS_DINODE_DFL_CRC_LOG);
+			usage();
+		}
+
+		/* inodes always aligned */
+		if (!cli->sb_feat.inode_align) {
+			fprintf(stderr,
+_("Inodes always aligned for CRC enabled filesytems\n"));
+			usage();
+		}
+
+		/* lazy sb counters always on */
+		if (!cli->sb_feat.lazy_sb_counters) {
+			fprintf(stderr,
+_("Lazy superblock counted always enabled for CRC enabled filesytems\n"));
+			usage();
+		}
+
+		/* version 2 logs always on */
+		if (cli->sb_feat.log_version != 2) {
+			fprintf(stderr,
+_("V2 logs always enabled for CRC enabled filesytems\n"));
+			usage();
+		}
+
+		/* attr2 always on */
+		if (cli->sb_feat.attr_version != 2) {
+			fprintf(stderr,
+_("V2 attribute format always enabled on CRC enabled filesytems\n"));
+			usage();
+		}
+
+		/* 32 bit project quota always on */
+		/* attr2 always on */
+		if (cli->sb_feat.projid16bit) {
+			fprintf(stderr,
+_("32 bit Project IDs always enabled on CRC enabled filesytems\n"));
+			usage();
+		}
+
+		/* ftype always on */
+		if (!cli->sb_feat.dirftype) {
+			fprintf(stderr,
+_("Directory ftype field always enabled on CRC enabled filesytems\n"));
+			usage();
+		}
+
+	} else {
+		/*
+		 * The kernel doesn't currently support crc=0,finobt=1
+		 * filesystems. If crcs are not enabled and the user has not
+		 * explicitly turned finobt on, then silently turn it off to
+		 * avoid an unnecessary warning.
+		 * If the user explicitly tried to use crc=0,finobt=1,
+		 * then issue an error.
+		 * The same is also for sparse inodes.
+		 */
+		if (cli->sb_feat.finobt && cli_opt_set(&mopts, M_FINOBT)) {
+			fprintf(stderr,
+_("finobt not supported without CRC support\n"));
+			usage();
+		}
+		cli->sb_feat.finobt = false;
+
+		if (cli->sb_feat.spinodes) {
+			fprintf(stderr,
+_("sparse inodes not supported without CRC support\n"));
+			usage();
+		}
+		cli->sb_feat.spinodes = false;
+
+		if (cli->sb_feat.rmapbt) {
+			fprintf(stderr,
+_("rmapbt not supported without CRC support\n"));
+			usage();
+		}
+		cli->sb_feat.rmapbt = false;
+
+		if (cli->sb_feat.reflink) {
+			fprintf(stderr,
+_("reflink not supported without CRC support\n"));
+			usage();
+		}
+		cli->sb_feat.reflink = false;
+	}
+
+
+	if (cli->sb_feat.rmapbt && cli->xi->rtname) {
+		fprintf(stderr,
+_("rmapbt not supported with realtime devices\n"));
+		usage();
+		cli->sb_feat.rmapbt = false;
+	}
+
+	/*
+	 * Copy features across to config structure now.
+	 */
+	cfg->sb_feat = cli->sb_feat;
+	if (!platform_uuid_is_null(&cli->uuid))
+		platform_uuid_copy(&cfg->uuid, &cli->uuid);
+}
+
 static void
 print_mkfs_cfg(
 	struct mkfs_params	*cfg,