diff --git a/mkfs/xfs_mkfs.c b/mkfs/xfs_mkfs.c
index 3698fc52..bd2d81a3 100644
--- a/mkfs/xfs_mkfs.c
+++ b/mkfs/xfs_mkfs.c
@@ -39,7 +39,7 @@ static int  ispow2(unsigned int i);
  * The configured block and sector sizes are defined as global variables so
  * that they don't need to be passed to functions that require them.
  */
-unsigned int		blocksize;
+unsigned int		*blocksize;
 unsigned int		sectorsize;
 
 #define MAX_OPTS	16
@@ -557,7 +557,7 @@ struct opt_params {
 					 },
 					 {LAST_CONFLICT} },
 			  .minval.i = 0,
-			  .maxval.i = UINT_MAX,
+			  .maxval.i = INT_MAX,
 			  .needs_val = true,
 			  .type = INT,
 			},
@@ -573,7 +573,7 @@ struct opt_params {
 					 },
 					 {LAST_CONFLICT} },
 			  .minval.i = 0,
-			  .maxval.i = UINT_MAX,
+			  .maxval.i = INT_MAX,
 			  .needs_val = true,
 			  .type = INT,
 			},
@@ -601,7 +601,7 @@ struct opt_params {
 					 {LAST_CONFLICT} },
 			  .convert = true,
 			  .minval.i = 0,
-			  .maxval.i = UINT_MAX,
+			  .maxval.i = INT_MAX,
 			  .needs_val = true,
 			  .type = INT,
 			},
@@ -617,7 +617,7 @@ struct opt_params {
 					 },
 					 {LAST_CONFLICT} },
 			  .minval.i = 0,
-			  .maxval.i = UINT_MAX,
+			  .maxval.i = INT_MAX,
 			  .needs_val = true,
 			  .type = INT,
 			},
@@ -852,6 +852,7 @@ struct opt_params {
 			  .maxval.i = 1,
 			  .flagval.i = 1,
 			  .type = INT,
+			  .value.i = 1,
 			},
 			{ .index = L_SIZE,
 			  .conflicts = { {LAST_CONFLICT} },
@@ -1344,7 +1345,7 @@ static void conflict_struct(struct opt_params 	*opt, struct subopt_param *subopt
 /*
  * Use this macro before we have superblock and mount structure
  */
-#define	DTOBT(d)	((xfs_rfsblock_t)((d) >> (blocklog - BBSHIFT)))
+#define	DTOBT(d)	((xfs_rfsblock_t)((d) >> ((*blocklog) - BBSHIFT)))
 
 /*
  * Use this for block reservations needed for mkfs's conditions
@@ -1415,16 +1416,16 @@ calc_stripe_factors(
 		*lsunit = (int)BTOBBT(lsu);
 
 	/* verify if lsu/lsunit is a multiple block size */
-	if (lsu % blocksize != 0) {
+	if (lsu % *blocksize != 0) {
 		fprintf(stderr,
 _("log stripe unit (%d) must be a multiple of the block size (%d)\n"),
-		lsu, blocksize);
+		lsu, *blocksize);
 		exit(1);
 	}
-	if ((BBTOB(*lsunit) % blocksize != 0)) {
+	if ((BBTOB(*lsunit) % *blocksize != 0)) {
 		fprintf(stderr,
 _("log stripe unit (%d) must be a multiple of the block size (%d)\n"),
-		BBTOB(*lsunit), blocksize);
+		BBTOB(*lsunit), *blocksize);
 		exit(1);
 	}
 }
@@ -2002,6 +2003,14 @@ check_all_opts(struct opt_params *opts)
 	}
 }
 
+/* TODO we might loose some numbers here, if they are unsigned and bigger than
+ * long long max value.
+ *
+ * However, I can't find any good solution for this and at this moment, it
+ * is a rather theoretical issue (real-world limits will kicks in long before
+ * it gets there). So, I'm going to keep this comment here for now, until
+ * someone gets an idea what to do with it.
+ */
 static long long
 getnum(
 	const char		*str,
@@ -2060,7 +2069,7 @@ getnum(
 	 * number.
 	 */
 	if (sp->convert)
-		c = cvtnum(blocksize, sectorsize, str);
+		c = cvtnum(*blocksize, sectorsize, str);
 	else {
 		char		*str_end;
 
@@ -2105,15 +2114,15 @@ main(
 	int			argc,
 	char			**argv)
 {
-	__uint64_t		agcount;
+	__uint64_t		*agcount;
 	xfs_agf_t		*agf;
 	xfs_agi_t		*agi;
 	xfs_agnumber_t		agno;
-	__uint64_t		agsize;
+	__uint64_t		*agsize;
 	xfs_alloc_rec_t		*arec;
 	struct xfs_btree_block	*block;
 	int			blflag;
-	int			blocklog;
+	int			*blocklog;
 	int			bsflag;
 	int			bsize;
 	xfs_buf_t		*buf;
@@ -2122,51 +2131,51 @@ main(
 	int			dasize;
 	xfs_rfsblock_t		dblocks;
 	char			*dfile;
-	int			dirblocklog;
-	int			dirblocksize;
-	__uint64_t 		dbytes;
-	int			dsu;
-	int			dsw;
-	int			dsunit;
-	int			dswidth;
+	int			*dirblocklog;
+	int			*dirblocksize;
+	__uint64_t 		*dbytes;
+	int			*dsu;
+	int			*dsw;
+	int			*dsunit;
+	int			*dswidth;
 	int			force_overwrite;
 	struct fsxattr		fsx;
 	int			ilflag;
-	int			imaxpct;
+	int			*imaxpct;
 	int			imflag;
-	int			inodelog;
-	int			inopblock;
+	int			*inodelog;
+	int			*inopblock;
 	int			ipflag;
 	int			isflag;
-	int			isize;
+	int			*isize;
 	char			*label = NULL;
 	int			laflag;
 	int			lalign;
 	int			ldflag;
 	int			liflag;
-	xfs_agnumber_t		logagno;
+	xfs_agnumber_t		*logagno;
 	xfs_rfsblock_t		logblocks;
 	char			*logfile;
-	int			loginternal;
-	__uint64_t 		logbytes;
+	int			*loginternal;
+	__uint64_t 		*logbytes;
 	xfs_fsblock_t		logstart;
 	int			lvflag;
 	int			lsflag;
 	int			lsuflag;
 	int			lsunitflag;
-	int			lsectorlog;
-	int			lsectorsize;
+	int			*lsectorlog;
+	int			*lsectorsize;
 	int			lslflag;
 	int			lssflag;
-	int			lsu;
-	int			lsunit;
+	int			*lsu;
+	int			*lsunit;
 	int			min_logblocks;
 	xfs_mount_t		*mp;
 	xfs_mount_t		mbuf;
 	xfs_extlen_t		nbmblocks;
 	int			nlflag;
-	int			nodsflag;
-	int			norsflag;
+	int			*nodsflag;
+	int			*norsflag;
 	xfs_alloc_rec_t		*nrec;
 	int			nsflag;
 	int			nvflag;
@@ -2177,10 +2186,10 @@ main(
 	char			*protostring;
 	int			qflag;
 	xfs_rfsblock_t		rtblocks;
-	__uint64_t 		rtbytes;
+	__uint64_t 		*rtbytes;
 	xfs_extlen_t		rtextblocks;
 	xfs_rtblock_t		rtextents;
-	__uint64_t 		rtextbytes;
+	__uint64_t 		*rtextbytes;
 	char			*rtfile;
 	xfs_sb_t		*sbp;
 	int			sectorlog;
@@ -2215,24 +2224,51 @@ main(
 	bindtextdomain(PACKAGE, LOCALEDIR);
 	textdomain(PACKAGE);
 
+
+	/*
+	 * Set up pointers, so we can use shorter names and to let gcc
+	 * check the correct type. We don't want to inadvertently use an int as
+	 * unsigned int and so on...
+	 */
+	agcount = &opts[OPT_D].subopt_params[D_AGCOUNT].value.uint64;
+	agsize = &opts[OPT_D].subopt_params[D_AGSIZE].value.uint64;
+	dbytes = &opts[OPT_D].subopt_params[D_SIZE].value.uint64;
+	dsunit = &opts[OPT_D].subopt_params[D_SUNIT].value.i;
+	dswidth = &opts[OPT_D].subopt_params[D_SWIDTH].value.i;
+	dsu = &opts[OPT_D].subopt_params[D_SU].value.i;
+	dsw = &opts[OPT_D].subopt_params[D_SW].value.i;
+	nodsflag = &opts[OPT_D].subopt_params[D_NOALIGN].value.i;
+	norsflag = &opts[OPT_R].subopt_params[R_NOALIGN].value.i;
+	logagno = &opts[OPT_L].subopt_params[L_AGNUM].value.u;
+	lsu = &opts[OPT_L].subopt_params[L_SU].value.i;
+	lsunit = &opts[OPT_L].subopt_params[L_SUNIT].value.i;
+	logbytes = &opts[OPT_L].subopt_params[L_SIZE].value.uint64;
+	imaxpct = &opts[OPT_I].subopt_params[I_MAXPCT].value.i;
+	inopblock = &opts[OPT_I].subopt_params[I_PERBLOCK].value.i;
+	dirblocksize = &opts[OPT_N].subopt_params[N_SIZE].value.i;
+	dirblocklog = &opts[OPT_N].subopt_params[N_LOG].value.i;
+	rtextbytes = &opts[OPT_R].subopt_params[R_EXTSIZE].value.uint64;
+	rtbytes = &opts[OPT_R].subopt_params[R_SIZE].value.uint64;
+	blocklog = &opts[OPT_B].subopt_params[B_LOG].value.i;
+	blocksize = &opts[OPT_B].subopt_params[B_SIZE].value.u;
+	isize = &opts[OPT_I].subopt_params[I_SIZE].value.i;
+	inodelog = &opts[OPT_I].subopt_params[I_LOG].value.i;
+	loginternal = &opts[OPT_L].subopt_params[L_INTERNAL].value.i;
+	lsectorsize = &opts[OPT_L].subopt_params[L_SECTSIZE].value.i;
+	lsectorlog = &opts[OPT_L].subopt_params[L_SECTLOG].value.i;
+
 	blflag = bsflag = slflag = ssflag = lslflag = lssflag = 0;
-	blocklog = blocksize = 0;
-	sectorlog = lsectorlog = 0;
-	sectorsize = lsectorsize = 0;
-	agsize = daflag = dasize = dblocks = 0;
+	sectorlog = 0;
+	sectorsize = 0;
+	daflag = dasize = dblocks = 0;
 	ilflag = imflag = ipflag = isflag = 0;
 	liflag = laflag = lsflag = lsuflag = lsunitflag = ldflag = lvflag = 0;
-	loginternal = 1;
-	logagno = logblocks = rtblocks = rtextblocks = 0;
+	logblocks = rtblocks = rtextblocks = 0;
 	Nflag = nlflag = nsflag = nvflag = 0;
-	dirblocklog = dirblocksize = 0;
 	qflag = 0;
-	imaxpct = inodelog = inopblock = isize = 0;
 	dfile = logfile = rtfile = NULL;
 	protofile = NULL;
-	rtbytes = rtextbytes = logbytes = dbytes = 0;
-	dsu = dsw = dsunit = dswidth = lalign = lsu = lsunit = 0;
-	nodsflag = norsflag = 0;
+	lalign = 0;
 	force_overwrite = 0;
 	worst_freelist = 0;
 	memset(&fsx, 0, sizeof(fsx));
@@ -2255,15 +2291,15 @@ main(
 
 				switch (getsubopt(&p, subopts, &value)) {
 				case B_LOG:
-					blocklog = getnum(value, &opts[OPT_B],
+					*blocklog = getnum(value, &opts[OPT_B],
 								B_LOG);
-					blocksize = 1 << blocklog;
+					*blocksize = 1 << *blocklog;
 					blflag = 1;
 					break;
 				case B_SIZE:
-					blocksize = getnum(value, &opts[OPT_B],
+					*blocksize = getnum(value, &opts[OPT_B],
 							   B_SIZE);
-					blocklog = libxfs_highbit32(blocksize);
+					*blocklog = libxfs_highbit32(*blocksize);
 					bsflag = 1;
 					break;
 				default:
@@ -2279,12 +2315,12 @@ main(
 
 				switch (getsubopt(&p, subopts, &value)) {
 				case D_AGCOUNT:
-					agcount = getnum(value, &opts[OPT_D],
+					*agcount = getnum(value, &opts[OPT_D],
 							 D_AGCOUNT);
 					daflag = 1;
 					break;
 				case D_AGSIZE:
-					agsize = getnum(value, &opts[OPT_D],
+					*agsize = getnum(value, &opts[OPT_D],
 								D_AGSIZE);
 					dasize = 1;
 					break;
@@ -2297,25 +2333,25 @@ main(
 								D_NAME);
 					break;
 				case D_SIZE:
-					dbytes = getnum(value, &opts[OPT_D],
+					*dbytes = getnum(value, &opts[OPT_D],
 								D_SIZE);
 					break;
 				case D_SUNIT:
-					dsunit = getnum(value, &opts[OPT_D],
+					*dsunit = getnum(value, &opts[OPT_D],
 								D_SUNIT);
 					break;
 				case D_SWIDTH:
-					dswidth = getnum(value, &opts[OPT_D],
+					*dswidth = getnum(value, &opts[OPT_D],
 							 D_SWIDTH);
 					break;
 				case D_SU:
-					dsu = getnum(value, &opts[OPT_D], D_SU);
+					*dsu = getnum(value, &opts[OPT_D], D_SU);
 					break;
 				case D_SW:
-					dsw = getnum(value, &opts[OPT_D], D_SW);
+					*dsw = getnum(value, &opts[OPT_D], D_SW);
 					break;
 				case D_NOALIGN:
-					nodsflag = getnum(value, &opts[OPT_D],
+					*nodsflag = getnum(value, &opts[OPT_D],
 								D_NOALIGN);
 					break;
 				case D_SECTLOG:
@@ -2337,6 +2373,7 @@ main(
 					if (c)
 						fsx.fsx_xflags |=
 							XFS_DIFLAG_RTINHERIT;
+					opts[OPT_D].subopt_params[D_RTINHERIT].value.u = c;
 					break;
 				case D_PROJINHERIT:
 					fsx.fsx_projid = getnum(value, &opts[OPT_D],
@@ -2368,25 +2405,25 @@ main(
 								I_ALIGN);
 					break;
 				case I_LOG:
-					inodelog = getnum(value, &opts[OPT_I],
+					*inodelog = getnum(value, &opts[OPT_I],
 								I_LOG);
-					isize = 1 << inodelog;
+					*isize = 1 << *inodelog;
 					ilflag = 1;
 					break;
 				case I_MAXPCT:
-					imaxpct = getnum(value, &opts[OPT_I],
+					*imaxpct = getnum(value, &opts[OPT_I],
 							 I_MAXPCT);
 					imflag = 1;
 					break;
 				case I_PERBLOCK:
-					inopblock = getnum(value, &opts[OPT_I],
+					*inopblock = getnum(value, &opts[OPT_I],
 							   I_PERBLOCK);
 					ipflag = 1;
 					break;
 				case I_SIZE:
-					isize = getnum(value, &opts[OPT_I],
+					*isize = getnum(value, &opts[OPT_I],
 								I_SIZE);
-					inodelog = libxfs_highbit32(isize);
+					*inodelog = libxfs_highbit32(*isize);
 					isflag = 1;
 					break;
 				case I_ATTR:
@@ -2418,7 +2455,7 @@ main(
 
 				switch (getsubopt(&p, subopts, &value)) {
 				case L_AGNUM:
-					logagno = getnum(value, &opts[OPT_L],
+					*logagno = getnum(value, &opts[OPT_L],
 								L_AGNUM);
 					laflag = 1;
 					break;
@@ -2427,16 +2464,16 @@ main(
 							    L_FILE);
 					break;
 				case L_INTERNAL:
-					loginternal = getnum(value, &opts[OPT_L],
+					*loginternal = getnum(value, &opts[OPT_L],
 							     L_INTERNAL);
 					liflag = 1;
 					break;
 				case L_SU:
-					lsu = getnum(value, &opts[OPT_L], L_SU);
+					*lsu = getnum(value, &opts[OPT_L], L_SU);
 					lsuflag = 1;
 					break;
 				case L_SUNIT:
-					lsunit = getnum(value, &opts[OPT_L],
+					*lsunit = getnum(value, &opts[OPT_L],
 								L_SUNIT);
 					lsunitflag = 1;
 					break;
@@ -2446,7 +2483,7 @@ main(
 								L_NAME);
 					xi.logname = logfile;
 					ldflag = 1;
-					loginternal = 0;
+					*loginternal = 0;
 					break;
 				case L_VERSION:
 					sb_feat.log_version =
@@ -2455,20 +2492,20 @@ main(
 					lvflag = 1;
 					break;
 				case L_SIZE:
-					logbytes = getnum(value, &opts[OPT_L],
+					*logbytes = getnum(value, &opts[OPT_L],
 								L_SIZE);
 					break;
 				case L_SECTLOG:
-					lsectorlog = getnum(value, &opts[OPT_L],
+					*lsectorlog = getnum(value, &opts[OPT_L],
 							    L_SECTLOG);
-					lsectorsize = 1 << lsectorlog;
+					*lsectorsize = 1 << *lsectorlog;
 					lslflag = 1;
 					break;
 				case L_SECTSIZE:
-					lsectorsize = getnum(value, &opts[OPT_L],
+					*lsectorsize = getnum(value, &opts[OPT_L],
 							     L_SECTSIZE);
-					lsectorlog =
-						libxfs_highbit32(lsectorsize);
+					*lsectorlog =
+						libxfs_highbit32(*lsectorsize);
 					lssflag = 1;
 					break;
 				case L_LAZYSBCNTR:
@@ -2509,6 +2546,7 @@ main(
 						reqval('m', subopts, M_UUID);
 					if (platform_uuid_parse(value, &uuid))
 						illegal(optarg, "m uuid");
+					opts[OPT_M].subopt_params[M_UUID].value.s = value;
 					break;
 				case M_RMAPBT:
 					sb_feat.rmapbt = getnum(
@@ -2531,16 +2569,16 @@ main(
 
 				switch (getsubopt(&p, subopts, &value)) {
 				case N_LOG:
-					dirblocklog = getnum(value, &opts[OPT_N],
+					*dirblocklog = getnum(value, &opts[OPT_N],
 							     N_LOG);
-					dirblocksize = 1 << dirblocklog;
+					*dirblocksize = 1 << *dirblocklog;
 					nlflag = 1;
 					break;
 				case N_SIZE:
-					dirblocksize = getnum(value, &opts[OPT_N],
+					*dirblocksize = getnum(value, &opts[OPT_N],
 							      N_SIZE);
-					dirblocklog =
-						libxfs_highbit32(dirblocksize);
+					*dirblocklog =
+						libxfs_highbit32(*dirblocksize);
 					nsflag = 1;
 					break;
 				case N_VERSION:
@@ -2587,7 +2625,7 @@ main(
 
 				switch (getsubopt(&p, subopts, &value)) {
 				case R_EXTSIZE:
-					rtextbytes = getnum(value, &opts[OPT_R],
+					*rtextbytes = getnum(value, &opts[OPT_R],
 								R_EXTSIZE);
 					break;
 				case R_FILE:
@@ -2600,11 +2638,11 @@ main(
 							   R_NAME);
 					break;
 				case R_SIZE:
-					rtbytes = getnum(value, &opts[OPT_R],
+					*rtbytes = getnum(value, &opts[OPT_R],
 								R_SIZE);
 					break;
 				case R_NOALIGN:
-					norsflag = getnum(value, &opts[OPT_R],
+					*norsflag = getnum(value, &opts[OPT_R],
 								R_NOALIGN);
 					break;
 				default:
@@ -2626,9 +2664,9 @@ main(
 							 S_SECTSIZE, S_SECTLOG);
 					sectorlog = getnum(value, &opts[OPT_S],
 							   S_SECTLOG);
-					lsectorlog = sectorlog;
+					*lsectorlog = sectorlog;
 					sectorsize = 1 << sectorlog;
-					lsectorsize = sectorsize;
+					*lsectorsize = sectorsize;
 					lslflag = slflag = 1;
 					break;
 				case S_SIZE:
@@ -2638,10 +2676,10 @@ main(
 							 S_SECTSIZE);
 					sectorsize = getnum(value, &opts[OPT_S],
 							    S_SECTSIZE);
-					lsectorsize = sectorsize;
+					*lsectorsize = sectorsize;
 					sectorlog =
 						libxfs_highbit32(sectorsize);
-					lsectorlog = sectorlog;
+					*lsectorlog = sectorlog;
 					lssflag = ssflag = 1;
 					break;
 				default:
@@ -2664,6 +2702,36 @@ main(
 	} else
 		dfile = xi.dname;
 
+	/*
+	 * Not every field could be connected with a pointer, so just copy
+	 * the values for a options check.
+	 */
+	opts[OPT_D].subopt_params[D_FILE].value.i  = xi.disfile;
+	opts[OPT_D].subopt_params[D_PROJINHERIT].value.u = fsx.fsx_projid;
+	opts[OPT_D].subopt_params[D_EXTSZINHERIT].value.u = fsx.fsx_extsize;
+	opts[OPT_L].subopt_params[L_FILE].value.i = xi.lisfile;
+	opts[OPT_L].subopt_params[L_VERSION].value.i = sb_feat.log_version;
+	opts[OPT_L].subopt_params[L_LAZYSBCNTR].value.b = sb_feat.lazy_sb_counters;
+	opts[OPT_I].subopt_params[I_ATTR].value.i = sb_feat.attr_version ;
+	opts[OPT_I].subopt_params[I_PROJID32BIT].value.b = !sb_feat.projid16bit ;
+	opts[OPT_I].subopt_params[I_SPINODES].value.i = sb_feat.spinodes ;
+	opts[OPT_M].subopt_params[M_FINOBT].value.i = sb_feat.finobt ;
+	opts[OPT_M].subopt_params[M_RMAPBT].value.b = sb_feat.rmapbt ;
+	opts[OPT_R].subopt_params[R_FILE].value.i = xi.risfile ;
+	opts[OPT_R].subopt_params[R_NAME].value.s = xi.rtname;
+	opts[OPT_R].subopt_params[R_DEV].value.s = xi.rtname;
+	opts[OPT_S].subopt_params[S_LOG].value.u = sectorsize;
+	opts[OPT_S].subopt_params[S_SECTLOG].value.u = sectorsize;
+	opts[OPT_D].subopt_params[D_NAME].value.s = xi.dname;
+	opts[OPT_D].subopt_params[D_SECTSIZE].value.u = sectorsize;
+	opts[OPT_D].subopt_params[D_SECTLOG].value.i = sectorlog;
+	opts[OPT_I].subopt_params[I_ALIGN].value.b = sb_feat.inode_align;
+	opts[OPT_L].subopt_params[L_NAME].value.s = xi.logname;
+	opts[OPT_L].subopt_params[L_DEV].value.s = xi.logname;
+	opts[OPT_M].subopt_params[M_CRC].value.b = sb_feat.crcs_enabled;
+	opts[OPT_N].subopt_params[N_VERSION].value.i = sb_feat.dir_version;
+	opts[OPT_N].subopt_params[N_FTYPE].value.b = sb_feat.dirftype;
+
 	check_all_opts(opts);
 
 	/*
@@ -2672,14 +2740,14 @@ main(
 	 * 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;
+		*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);
+	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) {
+	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);
@@ -2700,8 +2768,8 @@ _("Minimum block size for CRC enabled filesystems is %d bytes.\n"),
 		sectorsize = XFS_MIN_SECTORSIZE;
 	}
 	if (!lslflag && !lssflag) {
-		lsectorlog = sectorlog;
-		lsectorsize = sectorsize;
+		*lsectorlog = sectorlog;
+		*lsectorsize = sectorsize;
 	}
 
 	/*
@@ -2711,14 +2779,14 @@ _("Minimum block size for CRC enabled filesystems is %d bytes.\n"),
 	 * sector size mismatches between the new filesystem and the underlying
 	 * host filesystem.
 	 */
-	check_device_type(dfile, &xi.disfile, !dbytes, !dfile,
+	check_device_type(dfile, &xi.disfile, !*dbytes, !dfile,
 			  Nflag ? NULL : &xi.dcreat, force_overwrite, "d");
-	if (!loginternal)
-		check_device_type(xi.logname, &xi.lisfile, !logbytes, !xi.logname,
+	if (!*loginternal)
+		check_device_type(xi.logname, &xi.lisfile, !*logbytes, !xi.logname,
 				  Nflag ? NULL : &xi.lcreat,
 				  force_overwrite, "l");
 	if (xi.rtname)
-		check_device_type(xi.rtname, &xi.risfile, !rtbytes, !xi.rtname,
+		check_device_type(xi.rtname, &xi.risfile, !*rtbytes, !xi.rtname,
 				  Nflag ? NULL : &xi.rcreat,
 				  force_overwrite, "r");
 	if (xi.disfile || xi.lisfile || xi.risfile)
@@ -2743,10 +2811,10 @@ _("Minimum block size for CRC enabled filesystems is %d bytes.\n"),
 		sectorsize = ft.psectorsize ? ft.psectorsize :
 					      XFS_MIN_SECTORSIZE;
 
-		if ((blocksize < sectorsize) && (blocksize >= ft.lsectorsize)) {
+		if ((*blocksize < sectorsize) && (*blocksize >= ft.lsectorsize)) {
 			fprintf(stderr,
 _("specified blocksize %d is less than device physical sector size %d\n"),
-				blocksize, ft.psectorsize);
+				*blocksize, ft.psectorsize);
 			fprintf(stderr,
 _("switching to logical sector size %d\n"),
 				ft.lsectorsize);
@@ -2757,20 +2825,20 @@ _("switching to logical sector size %d\n"),
 
 	if (!ssflag) {
 		sectorlog = libxfs_highbit32(sectorsize);
-		if (loginternal) {
-			lsectorsize = sectorsize;
-			lsectorlog = sectorlog;
+		if (*loginternal) {
+			*lsectorsize = sectorsize;
+			*lsectorlog = sectorlog;
 		}
 	}
 
 	if (sectorsize < XFS_MIN_SECTORSIZE ||
-	    sectorsize > XFS_MAX_SECTORSIZE || sectorsize > blocksize) {
+	    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);
+				*blocksize, ft.lsectorsize);
 		usage();
 	}
 	if (sectorsize < ft.lsectorsize) {
@@ -2778,12 +2846,12 @@ _("block size %d cannot be smaller than logical sector size %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);
+	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;
+	} else if (*lsectorsize > XFS_MIN_SECTORSIZE && !*lsu && !*lsunit) {
+		*lsu = *blocksize;
 		sb_feat.log_version = 2;
 	}
 
@@ -2794,7 +2862,7 @@ _("block size %d cannot be smaller than logical sector size %d\n"),
 	 */
 	if (sb_feat.crcs_enabled) {
 		/* minimum inode size is 512 bytes, ipflag checked later */
-		if ((isflag || ilflag) && inodelog < XFS_DINODE_DFL_CRC_LOG) {
+		if ((isflag || ilflag) && *inodelog < XFS_DINODE_DFL_CRC_LOG) {
 			fprintf(stderr,
 _("Minimum inode size for CRCs is %d bytes\n"),
 				1 << XFS_DINODE_DFL_CRC_LOG);
@@ -2818,89 +2886,89 @@ _("Minimum inode size for CRCs is %d bytes\n"),
 	}
 
 	if (nsflag || nlflag) {
-		if (dirblocksize < blocksize ||
-					dirblocksize > XFS_MAX_BLOCKSIZE) {
+		if (*dirblocksize < *blocksize ||
+					*dirblocksize > XFS_MAX_BLOCKSIZE) {
 			fprintf(stderr, _("illegal directory block size %d\n"),
-				dirblocksize);
+				*dirblocksize);
 			usage();
 		}
 	} else {
-		if (blocksize < (1 << XFS_MIN_REC_DIRSIZE))
-			dirblocklog = XFS_MIN_REC_DIRSIZE;
+		if (*blocksize < (1 << XFS_MIN_REC_DIRSIZE))
+			*dirblocklog = XFS_MIN_REC_DIRSIZE;
 		else
-			dirblocklog = blocklog;
-		dirblocksize = 1 << dirblocklog;
+			*dirblocklog = *blocklog;
+		*dirblocksize = 1 << *dirblocklog;
 	}
 
 
-	if (dbytes) {
-		if (dbytes % XFS_MIN_BLOCKSIZE) {
+	if (*dbytes) {
+		if (*dbytes % XFS_MIN_BLOCKSIZE) {
 			fprintf(stderr,
 			_("illegal data length %lld, not a multiple of %d\n"),
-				(long long)dbytes, XFS_MIN_BLOCKSIZE);
+				(long long)*dbytes, XFS_MIN_BLOCKSIZE);
 			usage();
 		}
-		dblocks = (xfs_rfsblock_t)(dbytes >> blocklog);
-		if (dbytes % blocksize)
+		dblocks = (xfs_rfsblock_t)(*dbytes >> *blocklog);
+		if (*dbytes % *blocksize)
 			fprintf(stderr, _("warning: "
 	"data length %lld not a multiple of %d, truncated to %lld\n"),
-				(long long)dbytes, blocksize,
-				(long long)(dblocks << blocklog));
+				(long long)*dbytes, *blocksize,
+				(long long)(dblocks << *blocklog));
 	}
 	if (ipflag) {
-		inodelog = blocklog - libxfs_highbit32(inopblock);
-		isize = 1 << inodelog;
+		*inodelog = *blocklog - libxfs_highbit32(*inopblock);
+		*isize = 1 << *inodelog;
 	} else if (!ilflag && !isflag) {
-		inodelog = sb_feat.crcs_enabled ? XFS_DINODE_DFL_CRC_LOG
+		*inodelog = sb_feat.crcs_enabled ? XFS_DINODE_DFL_CRC_LOG
 						: XFS_DINODE_DFL_LOG;
-		isize = 1 << inodelog;
+		*isize = 1 << *inodelog;
 	}
-	if (sb_feat.crcs_enabled && inodelog < XFS_DINODE_DFL_CRC_LOG) {
+	if (sb_feat.crcs_enabled && *inodelog < XFS_DINODE_DFL_CRC_LOG) {
 		fprintf(stderr,
 		_("Minimum inode size for CRCs is %d bytes\n"),
 			1 << XFS_DINODE_DFL_CRC_LOG);
 		usage();
 	}
 
-	if (logbytes) {
-		if (logbytes % XFS_MIN_BLOCKSIZE) {
+	if (*logbytes) {
+		if (*logbytes % XFS_MIN_BLOCKSIZE) {
 			fprintf(stderr,
 			_("illegal log length %lld, not a multiple of %d\n"),
-				(long long)logbytes, XFS_MIN_BLOCKSIZE);
+				(long long)*logbytes, XFS_MIN_BLOCKSIZE);
 			usage();
 		}
-		logblocks = (xfs_rfsblock_t)(logbytes >> blocklog);
-		if (logbytes % blocksize)
+		logblocks = (xfs_rfsblock_t)(*logbytes >> *blocklog);
+		if (*logbytes % *blocksize)
 			fprintf(stderr,
 	_("warning: log length %lld not a multiple of %d, truncated to %lld\n"),
-				(long long)logbytes, blocksize,
-				(long long)(logblocks << blocklog));
+				(long long)*logbytes, *blocksize,
+				(long long)(logblocks << *blocklog));
 	}
-	if (rtbytes) {
-		if (rtbytes % XFS_MIN_BLOCKSIZE) {
+	if (*rtbytes) {
+		if (*rtbytes % XFS_MIN_BLOCKSIZE) {
 			fprintf(stderr,
 			_("illegal rt length %lld, not a multiple of %d\n"),
-				(long long)rtbytes, XFS_MIN_BLOCKSIZE);
+				(long long)*rtbytes, XFS_MIN_BLOCKSIZE);
 			usage();
 		}
-		rtblocks = (xfs_rfsblock_t)(rtbytes >> blocklog);
-		if (rtbytes % blocksize)
+		rtblocks = (xfs_rfsblock_t)(*rtbytes >> *blocklog);
+		if (*rtbytes % *blocksize)
 			fprintf(stderr,
 	_("warning: rt length %lld not a multiple of %d, truncated to %lld\n"),
-				(long long)rtbytes, blocksize,
-				(long long)(rtblocks << blocklog));
+				(long long)*rtbytes, *blocksize,
+				(long long)(rtblocks << *blocklog));
 	}
 	/*
 	 * If specified, check rt extent size against its constraints.
 	 */
-	if (rtextbytes) {
-		if (rtextbytes % blocksize) {
+	if (*rtextbytes) {
+		if (*rtextbytes % *blocksize) {
 			fprintf(stderr,
 		_("illegal rt extent size %lld, not a multiple of %d\n"),
-				(long long)rtextbytes, blocksize);
+				(long long)*rtextbytes, *blocksize);
 			usage();
 		}
-		rtextblocks = (xfs_extlen_t)(rtextbytes >> blocklog);
+		rtextblocks = (xfs_extlen_t)(*rtextbytes >> *blocklog);
 	} else {
 		/*
 		 * If realtime extsize has not been specified by the user,
@@ -2910,23 +2978,23 @@ _("Minimum inode size for CRCs is %d bytes\n"),
 		__uint64_t	rswidth;
 		__uint64_t	rtextbytes;
 
-		if (!norsflag && !xi.risfile && !(!rtbytes && xi.disfile))
+		if (!*norsflag && !xi.risfile && !(!*rtbytes && xi.disfile))
 			rswidth = ft.rtswidth;
 		else
 			rswidth = 0;
 
-		/* check that rswidth is a multiple of fs blocksize */
-		if (!norsflag && rswidth && !(BBTOB(rswidth) % blocksize)) {
+		/* check that rswidth is a multiple of fs *blocksize */
+		if (!*norsflag && rswidth && !(BBTOB(rswidth) % *blocksize)) {
 			rswidth = DTOBT(rswidth);
-			rtextbytes = rswidth << blocklog;
+			rtextbytes = rswidth << *blocklog;
 			if (XFS_MIN_RTEXTSIZE <= rtextbytes &&
 			    (rtextbytes <= XFS_MAX_RTEXTSIZE)) {
 				rtextblocks = rswidth;
 			}
 		}
 		if (!rtextblocks) {
-			rtextblocks = (blocksize < XFS_MIN_RTEXTSIZE) ?
-					XFS_MIN_RTEXTSIZE >> blocklog : 1;
+			rtextblocks = (*blocksize < XFS_MIN_RTEXTSIZE) ?
+					XFS_MIN_RTEXTSIZE >> *blocklog : 1;
 		}
 	}
 	ASSERT(rtextblocks);
@@ -2934,34 +3002,34 @@ _("Minimum inode size for CRCs is %d bytes\n"),
 	/*
 	 * Check some argument sizes against mins, maxes.
 	 */
-	if (isize > blocksize / XFS_MIN_INODE_PERBLOCK ||
-	    isize < XFS_DINODE_MIN_SIZE ||
-	    isize > XFS_DINODE_MAX_SIZE) {
+	if (*isize > *blocksize / XFS_MIN_INODE_PERBLOCK ||
+	    *isize < XFS_DINODE_MIN_SIZE ||
+	    *isize > XFS_DINODE_MAX_SIZE) {
 		int	maxsz;
 
-		fprintf(stderr, _("illegal inode size %d\n"), isize);
-		maxsz = MIN(blocksize / XFS_MIN_INODE_PERBLOCK,
+		fprintf(stderr, _("illegal inode size %d\n"), *isize);
+		maxsz = MIN(*blocksize / XFS_MIN_INODE_PERBLOCK,
 			    XFS_DINODE_MAX_SIZE);
 		if (XFS_DINODE_MIN_SIZE == maxsz)
 			fprintf(stderr,
 			_("allowable inode size with %d byte blocks is %d\n"),
-				blocksize, XFS_DINODE_MIN_SIZE);
+				*blocksize, XFS_DINODE_MIN_SIZE);
 		else
 			fprintf(stderr,
 	_("allowable inode size with %d byte blocks is between %d and %d\n"),
-				blocksize, XFS_DINODE_MIN_SIZE, maxsz);
+				*blocksize, XFS_DINODE_MIN_SIZE, maxsz);
 		exit(1);
 	}
 
-	/* if lsu or lsunit was specified, automatically use v2 logs */
-	if ((lsu || lsunit) && sb_feat.log_version == 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);
+	calc_stripe_factors(*dsu, *dsw, sectorsize, *lsu, *lsectorsize,
+				dsunit, dswidth, lsunit);
 
 	xi.setblksize = sectorsize;
 
@@ -2989,7 +3057,7 @@ _("Minimum inode size for CRCs is %d bytes\n"),
 	sector_mask = (__uint64_t)-1 << (MAX(sectorlog, 10) - BBSHIFT);
 	xi.dsize &= sector_mask;
 	xi.rtsize &= sector_mask;
-	xi.logBBsize &= (__uint64_t)-1 << (MAX(lsectorlog, 10) - BBSHIFT);
+	xi.logBBsize &= (__uint64_t)-1 << (MAX(*lsectorlog, 10) - BBSHIFT);
 
 
 	/* don't do discards on print-only runs or on files */
@@ -3003,10 +3071,10 @@ _("Minimum inode size for CRCs is %d bytes\n"),
 	}
 
 	if (!liflag && !ldflag)
-		loginternal = xi.logdev == 0;
+		*loginternal = xi.logdev == 0;
 	if (xi.logname)
 		logfile = xi.logname;
-	else if (loginternal)
+	else if (*loginternal)
 		logfile = _("internal log");
 	else if (xi.volname && xi.logdev)
 		logfile = _("volume log");
@@ -3021,15 +3089,15 @@ _("Minimum inode size for CRCs is %d bytes\n"),
 		rtfile = _("volume rt");
 	else if (!xi.rtdev)
 		rtfile = _("none");
-	if (dbytes && xi.dsize > 0 && dblocks > DTOBT(xi.dsize)) {
+	if (*dbytes && xi.dsize > 0 && dblocks > DTOBT(xi.dsize)) {
 		fprintf(stderr,
 			_("size %lld specified for data subvolume is too large, "
 			"maximum is %lld blocks\n"),
-			(long long)dbytes, (long long)DTOBT(xi.dsize));
+			(long long)*dbytes, (long long)DTOBT(xi.dsize));
 		usage();
-	} else if (!dbytes && xi.dsize > 0)
+	} else if (!*dbytes && xi.dsize > 0)
 		dblocks = DTOBT(xi.dsize);
-	else if (!dbytes) {
+	else if (!*dbytes) {
 		fprintf(stderr, _("can't get size of data subvolume\n"));
 		usage();
 	}
@@ -3040,11 +3108,11 @@ _("Minimum inode size for CRCs is %d bytes\n"),
 		usage();
 	}
 
-	if (loginternal && xi.logdev) {
+	if (*loginternal && xi.logdev) {
 		fprintf(stderr,
 			_("can't have both external and internal logs\n"));
 		usage();
-	} else if (loginternal && sectorsize != lsectorsize) {
+	} else if (*loginternal && sectorsize != *lsectorsize) {
 		fprintf(stderr,
 	_("data and log sector sizes must be equal for internal logs\n"));
 		usage();
@@ -3056,147 +3124,147 @@ _("Minimum inode size for CRCs is %d bytes\n"),
 reported by the device (%u).\n"),
 			sectorsize, xi.dbsize);
 	}
-	if (!loginternal && xi.lbsize > lsectorsize) {
+	if (!*loginternal && xi.lbsize > *lsectorsize) {
 		fprintf(stderr, _(
 "Warning: the log subvolume sector size %u is less than the sector size\n\
 reported by the device (%u).\n"),
-			lsectorsize, xi.lbsize);
+			*lsectorsize, xi.lbsize);
 	}
-	if (rtbytes && xi.rtsize > 0 && xi.rtbsize > sectorsize) {
+	if (*rtbytes && xi.rtsize > 0 && xi.rtbsize > sectorsize) {
 		fprintf(stderr, _(
 "Warning: the realtime subvolume sector size %u is less than the sector size\n\
 reported by the device (%u).\n"),
 			sectorsize, xi.rtbsize);
 	}
 
-	if (rtbytes && xi.rtsize > 0 && rtblocks > DTOBT(xi.rtsize)) {
+	if (*rtbytes && xi.rtsize > 0 && rtblocks > DTOBT(xi.rtsize)) {
 		fprintf(stderr,
 			_("size %lld specified for rt subvolume is too large, "
 			"maximum is %lld blocks\n"),
-			(long long)rtbytes, (long long)DTOBT(xi.rtsize));
+			(long long)*rtbytes, (long long)DTOBT(xi.rtsize));
 		usage();
-	} else if (!rtbytes && xi.rtsize > 0)
+	} else if (!*rtbytes && xi.rtsize > 0)
 		rtblocks = DTOBT(xi.rtsize);
-	else if (rtbytes && !xi.rtdev) {
+	else if (*rtbytes && !xi.rtdev) {
 		fprintf(stderr,
 			_("size specified for non-existent rt subvolume\n"));
 		usage();
 	}
 	if (xi.rtdev) {
 		rtextents = rtblocks / rtextblocks;
-		nbmblocks = (xfs_extlen_t)howmany(rtextents, NBBY * blocksize);
+		nbmblocks = (xfs_extlen_t)howmany(rtextents, NBBY * *blocksize);
 	} else {
 		rtextents = rtblocks = 0;
 		nbmblocks = 0;
 	}
 
-	if (!nodsflag) {
-		if (dsunit) {
-			if (ft.dsunit && ft.dsunit != dsunit) {
+	if (!*nodsflag) {
+		if (*dsunit) {
+			if (ft.dsunit && ft.dsunit != *dsunit) {
 				fprintf(stderr,
 					_("%s: Specified data stripe unit %d "
 					"is not the same as the volume stripe "
 					"unit %d\n"),
-					progname, dsunit, ft.dsunit);
+					progname, *dsunit, ft.dsunit);
 			}
-			if (ft.dswidth && ft.dswidth != dswidth) {
+			if (ft.dswidth && ft.dswidth != *dswidth) {
 				fprintf(stderr,
 					_("%s: Specified data stripe width %d "
 					"is not the same as the volume stripe "
 					"width %d\n"),
-					progname, dswidth, ft.dswidth);
+					progname, *dswidth, ft.dswidth);
 			}
 		} else {
-			dsunit = ft.dsunit;
-			dswidth = ft.dswidth;
-			nodsflag = 1;
+			*dsunit = ft.dsunit;
+			*dswidth = ft.dswidth;
+			*nodsflag = 1;
 		}
-	} /* else dsunit & dswidth can't be set if nodsflag is set */
+	} /* else *dsunit & *dswidth can't be set if *nodsflag is set */
 
 	if (dasize) {		/* User-specified AG size */
 		/*
-		 * Check specified agsize is a multiple of blocksize.
+		 * Check specified agsize is a multiple of *blocksize.
 		 */
-		if (agsize % blocksize) {
+		if (*agsize % *blocksize) {
 			fprintf(stderr,
 		_("agsize (%lld) not a multiple of fs blk size (%d)\n"),
-				(long long)agsize, blocksize);
+				(long long)*agsize, *blocksize);
 			usage();
 		}
-		agsize /= blocksize;
-		agcount = dblocks / agsize + (dblocks % agsize != 0);
+		*agsize /= *blocksize;
+		*agcount = dblocks / *agsize + (dblocks % *agsize != 0);
 
 	} else if (daflag) {	/* User-specified AG count */
-		agsize = dblocks / agcount + (dblocks % agcount != 0);
+		*agsize = dblocks / *agcount + (dblocks % *agcount != 0);
 	} else {
-		calc_default_ag_geometry(blocklog, dblocks,
-				dsunit | dswidth, &agsize, &agcount);
+		calc_default_ag_geometry(*blocklog, dblocks,
+				*dsunit | *dswidth, agsize, agcount);
 	}
 
 	/*
-	 * If dsunit is a multiple of fs blocksize, then check that is a
+	 * If *dsunit is a multiple of fs *blocksize, then check that is a
 	 * multiple of the agsize too
 	 */
-	if (dsunit && !(BBTOB(dsunit) % blocksize) &&
-	    dswidth && !(BBTOB(dswidth) % blocksize)) {
+	if (*dsunit && !(BBTOB(*dsunit) % *blocksize) &&
+	    *dswidth && !(BBTOB(*dswidth) % *blocksize)) {
 
-		/* convert from 512 byte blocks to fs blocksize */
-		dsunit = DTOBT(dsunit);
-		dswidth = DTOBT(dswidth);
+		/* convert from 512 byte blocks to fs *blocksize */
+		*dsunit = DTOBT(*dsunit);
+		*dswidth = DTOBT(*dswidth);
 
 		/*
-		 * agsize is not a multiple of dsunit
+		 * agsize is not a multiple of *dsunit
 		 */
-		if ((agsize % dsunit) != 0) {
+		if ((*agsize % *dsunit) != 0) {
 			/*
 			 * Round up to stripe unit boundary. Also make sure
 			 * that agsize is still larger than
-			 * XFS_AG_MIN_BLOCKS(blocklog)
+			 * XFS_AG_MIN_BLOCKS(*blocklog)
 		 	 */
-			tmp_agsize = ((agsize + (dsunit - 1))/ dsunit) * dsunit;
+			tmp_agsize = ((*agsize + (*dsunit - 1))/ *dsunit) * *dsunit;
 			/*
 			 * Round down to stripe unit boundary if rounding up
 			 * created an AG size that is larger than the AG max.
 			 */
-			if (tmp_agsize > XFS_AG_MAX_BLOCKS(blocklog))
-				tmp_agsize = ((agsize) / dsunit) * dsunit;
+			if (tmp_agsize > XFS_AG_MAX_BLOCKS(*blocklog))
+				tmp_agsize = ((*agsize) / *dsunit) * *dsunit;
 
-			if ((tmp_agsize >= XFS_AG_MIN_BLOCKS(blocklog)) &&
-			    (tmp_agsize <= XFS_AG_MAX_BLOCKS(blocklog))) {
-				agsize = tmp_agsize;
+			if ((tmp_agsize >= XFS_AG_MIN_BLOCKS(*blocklog)) &&
+			    (tmp_agsize <= XFS_AG_MAX_BLOCKS(*blocklog))) {
+				*agsize = tmp_agsize;
 				if (!daflag)
-					agcount = dblocks/agsize +
-						(dblocks % agsize != 0);
+					*agcount = dblocks/ *agsize +
+						(dblocks % *agsize != 0);
 				if (dasize)
 					fprintf(stderr,
 				_("agsize rounded to %lld, swidth = %d\n"),
-						(long long)agsize, dswidth);
+						(long long)*agsize, *dswidth);
 			} else {
-				if (nodsflag) {
-					dsunit = dswidth = 0;
+				if (*nodsflag) {
+					*dsunit = *dswidth = 0;
 				} else {
 					/*
 					 * agsize is out of bounds, this will
 					 * print nice details & exit.
 					 */
-					validate_ag_geometry(blocklog, dblocks,
-							    agsize, agcount);
+					validate_ag_geometry(*blocklog, dblocks,
+							    *agsize, *agcount);
 					exit(1);
 				}
 			}
 		}
-		if (dswidth && ((agsize % dswidth) == 0) && (agcount > 1)) {
+		if (*dswidth && ((*agsize % *dswidth) == 0) && (*agcount > 1)) {
 			/* This is a non-optimal configuration because all AGs
 			 * start on the same disk in the stripe.  Changing
 			 * the AG size by one sunit will guarantee that this
 			 * does not happen.
 			 */
-			tmp_agsize = agsize - dsunit;
-			if (tmp_agsize < XFS_AG_MIN_BLOCKS(blocklog)) {
-				tmp_agsize = agsize + dsunit;
-				if (dblocks < agsize) {
+			tmp_agsize = *agsize - *dsunit;
+			if (tmp_agsize < XFS_AG_MIN_BLOCKS(*blocklog)) {
+				tmp_agsize = *agsize + *dsunit;
+				if (dblocks < *agsize) {
 					/* oh well, nothing to do */
-					tmp_agsize = agsize;
+					tmp_agsize = *agsize;
 				}
 			}
 			if (daflag || dasize) {
@@ -3206,30 +3274,30 @@ problems by aligning all AGs on the same disk.  To avoid this, run mkfs with\n\
 an AG size that is one stripe unit smaller, for example %llu.\n"),
 					(unsigned long long)tmp_agsize);
 			} else {
-				agsize = tmp_agsize;
-				agcount = dblocks/agsize + (dblocks % agsize != 0);
+				*agsize = tmp_agsize;
+				*agcount = dblocks/ *agsize + (dblocks % *agsize != 0);
 				/*
 				 * If the last AG is too small, reduce the
 				 * filesystem size and drop the blocks.
 				 */
-				if ( dblocks % agsize != 0 &&
-				    (dblocks % agsize <
-				    XFS_AG_MIN_BLOCKS(blocklog))) {
-					dblocks = (xfs_rfsblock_t)((agcount - 1) * agsize);
-					agcount--;
-					ASSERT(agcount != 0);
+				if ( dblocks % *agsize != 0 &&
+				    (dblocks % *agsize <
+				    XFS_AG_MIN_BLOCKS(*blocklog))) {
+					dblocks = (xfs_rfsblock_t)((*agcount - 1) * *agsize);
+					(*agcount)--;
+					ASSERT(*agcount != 0);
 				}
 			}
 		}
 	} else {
-		if (nodsflag)
-			dsunit = dswidth = 0;
+		if (*nodsflag)
+			*dsunit = *dswidth = 0;
 		else {
 			fprintf(stderr,
 				_("%s: Stripe unit(%d) or stripe width(%d) is "
 				"not a multiple of the block size(%d)\n"),
-				progname, BBTOB(dsunit), BBTOB(dswidth),
-				blocksize);
+				progname, BBTOB(*dsunit), BBTOB(*dswidth),
+				*blocksize);
 			exit(1);
 		}
 	}
@@ -3238,82 +3306,83 @@ an AG size that is one stripe unit smaller, for example %llu.\n"),
 	 * If the last AG is too small, reduce the filesystem size
 	 * and drop the blocks.
 	 */
-	if ( dblocks % agsize != 0 &&
-	     (dblocks % agsize < XFS_AG_MIN_BLOCKS(blocklog))) {
+	if ( dblocks % *agsize != 0 &&
+	     (dblocks % *agsize < XFS_AG_MIN_BLOCKS(*blocklog))) {
 		ASSERT(!daflag);
-		dblocks = (xfs_rfsblock_t)((agcount - 1) * agsize);
-		agcount--;
-		ASSERT(agcount != 0);
+		dblocks = (xfs_rfsblock_t)((*agcount - 1) * *agsize);
+		(*agcount)--;
+		ASSERT(*agcount != 0);
 	}
 
-	validate_ag_geometry(blocklog, dblocks, agsize, agcount);
+	validate_ag_geometry(*blocklog, dblocks, *agsize, *agcount);
 
 	if (!imflag)
-		imaxpct = calc_default_imaxpct(blocklog, dblocks);
+		*imaxpct = calc_default_imaxpct(*blocklog, dblocks);
 
 	/*
-	 * check that log sunit is modulo fsblksize or default it to dsunit.
+	 * check that log sunit is modulo fsblksize or default it to *dsunit.
 	 */
 
-	if (lsunit) {
+	if (*lsunit) {
 		/* convert from 512 byte blocks to fs blocks */
-		lsunit = DTOBT(lsunit);
-	} else if (sb_feat.log_version == 2 && loginternal && dsunit) {
-		/* lsunit and dsunit now in fs blocks */
-		lsunit = dsunit;
+		*lsunit = DTOBT(*lsunit);
+	} else if (sb_feat.log_version == 2 && *loginternal && *dsunit) {
+		/* *lsunit and *dsunit now in fs blocks */
+		*lsunit = *dsunit;
 	}
 
-	if (sb_feat.log_version == 2 && (lsunit * blocksize) > 256 * 1024) {
+	if (sb_feat.log_version == 2 && (*lsunit * *blocksize) > 256 * 1024) {
 		/* Warn only if specified on commandline */
 		if (lsuflag || lsunitflag) {
 			fprintf(stderr,
 	_("log stripe unit (%d bytes) is too large (maximum is 256KiB)\n"),
-				(lsunit * blocksize));
+				(*lsunit * *blocksize));
 			fprintf(stderr,
 	_("log stripe unit adjusted to 32KiB\n"));
 		}
-		lsunit = (32 * 1024) >> blocklog;
+		*lsunit = (32 * 1024) >> *blocklog;
 	}
 
-	min_logblocks = max_trans_res(agsize,
+	min_logblocks = max_trans_res(*agsize,
 				   sb_feat.crcs_enabled, sb_feat.dir_version,
-				   sectorlog, blocklog, inodelog, dirblocklog,
-				   sb_feat.log_version, lsunit, sb_feat.finobt,
+				   sectorlog, *blocklog, *inodelog, *dirblocklog,
+				   sb_feat.log_version, *lsunit, sb_feat.finobt,
 				   sb_feat.rmapbt, sb_feat.reflink);
+
 	ASSERT(min_logblocks);
 	min_logblocks = MAX(XFS_MIN_LOG_BLOCKS, min_logblocks);
-	if (!logbytes && dblocks >= (1024*1024*1024) >> blocklog)
-		min_logblocks = MAX(min_logblocks, XFS_MIN_LOG_BYTES>>blocklog);
-	if (logbytes && xi.logBBsize > 0 && logblocks > DTOBT(xi.logBBsize)) {
+	if (!*logbytes && dblocks >= (1024*1024*1024) >> *blocklog)
+		min_logblocks = MAX(min_logblocks, XFS_MIN_LOG_BYTES>>*blocklog);
+	if (*logbytes && xi.logBBsize > 0 && logblocks > DTOBT(xi.logBBsize)) {
 		fprintf(stderr,
 _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"),
-			(long long)logbytes, (long long)DTOBT(xi.logBBsize));
+			(long long)*logbytes, (long long)DTOBT(xi.logBBsize));
 		usage();
-	} else if (!logbytes && xi.logBBsize > 0) {
+	} else if (!*logbytes && xi.logBBsize > 0) {
 		logblocks = DTOBT(xi.logBBsize);
-	} else if (logbytes && !xi.logdev && !loginternal) {
+	} else if (*logbytes && !xi.logdev && !*loginternal) {
 		fprintf(stderr,
 			_("size specified for non-existent log subvolume\n"));
 		usage();
-	} else if (loginternal && logbytes && logblocks >= dblocks) {
+	} else if (*loginternal && *logbytes && logblocks >= dblocks) {
 		fprintf(stderr, _("size %lld too large for internal log\n"),
 			(long long)logblocks);
 		usage();
-	} else if (!loginternal && !xi.logdev) {
+	} else if (!*loginternal && !xi.logdev) {
 		logblocks = 0;
-	} else if (loginternal && !logbytes) {
+	} else if (*loginternal && !*logbytes) {
 
-		if (dblocks < GIGABYTES(1, blocklog)) {
+		if (dblocks < GIGABYTES(1, *blocklog)) {
 			/* tiny filesystems get minimum sized logs. */
 			logblocks = min_logblocks;
-		} else if (dblocks < GIGABYTES(16, blocklog)) {
+		} else if (dblocks < GIGABYTES(16, *blocklog)) {
 
 			/*
 			 * For small filesystems, we want to use the
 			 * XFS_MIN_LOG_BYTES for filesystems smaller than 16G if
 			 * at all possible, ramping up to 128MB at 256GB.
 			 */
-			logblocks = MIN(XFS_MIN_LOG_BYTES >> blocklog,
+			logblocks = MIN(XFS_MIN_LOG_BYTES >> *blocklog,
 					min_logblocks * XFS_DFL_LOG_FACTOR);
 		} else {
 			/*
@@ -3322,34 +3391,34 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 			 * max log size of 128M at 256GB fs size. IOWs,
 			 * the ratio of fs size to log size is 2048:1.
 			 */
-			logblocks = (dblocks << blocklog) / 2048;
-			logblocks = logblocks >> blocklog;
+			logblocks = (dblocks << *blocklog) / 2048;
+			logblocks = logblocks >> *blocklog;
 		}
 
 		/* Ensure the chosen size meets minimum log size requirements */
 		logblocks = MAX(min_logblocks, logblocks);
 
 		/* make sure the log fits wholly within an AG */
-		if (logblocks >= agsize)
+		if (logblocks >= *agsize)
 			logblocks = min_logblocks;
 
 		/* and now clamp the size to the maximum supported size */
 		logblocks = MIN(logblocks, XFS_MAX_LOG_BLOCKS);
-		if ((logblocks << blocklog) > XFS_MAX_LOG_BYTES)
-			logblocks = XFS_MAX_LOG_BYTES >> blocklog;
+		if ((logblocks << *blocklog) > XFS_MAX_LOG_BYTES)
+			logblocks = XFS_MAX_LOG_BYTES >> *blocklog;
 
 	}
-	validate_log_size(logblocks, blocklog, min_logblocks);
+	validate_log_size(logblocks, *blocklog, min_logblocks);
 
 	protostring = setup_proto(protofile);
-	bsize = 1 << (blocklog - BBSHIFT);
+	bsize = 1 << (*blocklog - BBSHIFT);
 	mp = &mbuf;
 	sbp = &mp->m_sb;
 	memset(mp, 0, sizeof(xfs_mount_t));
-	sbp->sb_blocklog = (__uint8_t)blocklog;
+	sbp->sb_blocklog = (__uint8_t)*blocklog;
 	sbp->sb_sectlog = (__uint8_t)sectorlog;
-	sbp->sb_agblklog = (__uint8_t)libxfs_log2_roundup((unsigned int)agsize);
-	sbp->sb_agblocks = (xfs_agblock_t)agsize;
+	sbp->sb_agblklog = (__uint8_t)libxfs_log2_roundup((unsigned int)*agsize);
+	sbp->sb_agblocks = (xfs_agblock_t)*agsize;
 	mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT;
 	mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT;
 
@@ -3357,22 +3426,22 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 	 * sb_versionnum, finobt and rmapbt flags must be set before we use
 	 * libxfs_prealloc_blocks().
 	 */
-	sb_set_features(&mp->m_sb, &sb_feat, sectorsize, lsectorsize, dsunit);
+	sb_set_features(&mp->m_sb, &sb_feat, sectorsize, *lsectorsize, *dsunit);
 
 
-	if (loginternal) {
+	if (*loginternal) {
 		/*
 		 * Readjust the log size to fit within an AG if it was sized
 		 * automatically.
 		 */
-		if (!logbytes) {
+		if (!*logbytes) {
 			logblocks = MIN(logblocks,
 					libxfs_alloc_ag_max_usable(mp));
 
 			/* revalidate the log size is valid if we changed it */
-			validate_log_size(logblocks, blocklog, min_logblocks);
+			validate_log_size(logblocks, *blocklog, min_logblocks);
 		}
-		if (logblocks > agsize - libxfs_prealloc_blocks(mp)) {
+		if (logblocks > *agsize - libxfs_prealloc_blocks(mp)) {
 			fprintf(stderr,
 	_("internal log size %lld too large, must fit in allocation group\n"),
 				(long long)logblocks);
@@ -3380,35 +3449,35 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 		}
 
 		if (laflag) {
-			if (logagno >= agcount) {
+			if (*logagno >= *agcount) {
 				fprintf(stderr,
 		_("log ag number %d too large, must be less than %lld\n"),
-					logagno, (long long)agcount);
+					*logagno, (long long)*agcount);
 				usage();
 			}
 		} else
-			logagno = (xfs_agnumber_t)(agcount / 2);
+			*logagno = (xfs_agnumber_t)(*agcount / 2);
 
-		logstart = XFS_AGB_TO_FSB(mp, logagno, libxfs_prealloc_blocks(mp));
+		logstart = XFS_AGB_TO_FSB(mp, *logagno, libxfs_prealloc_blocks(mp));
 		/*
 		 * Align the logstart at stripe unit boundary.
 		 */
-		if (lsunit) {
+		if (*lsunit) {
 			logstart = fixup_internal_log_stripe(mp,
-					lsflag, logstart, agsize, lsunit,
-					&logblocks, blocklog, &lalign);
-		} else if (dsunit) {
+					lsflag, logstart, *agsize, *lsunit,
+					&logblocks, *blocklog, &lalign);
+		} else if (*dsunit) {
 			logstart = fixup_internal_log_stripe(mp,
-					lsflag, logstart, agsize, dsunit,
-					&logblocks, blocklog, &lalign);
+					lsflag, logstart, *agsize, *dsunit,
+					&logblocks, *blocklog, &lalign);
 		}
 	} else {
 		logstart = 0;
-		if (lsunit)
-			fixup_log_stripe_unit(lsflag, lsunit,
-					&logblocks, blocklog);
+		if (*lsunit)
+			fixup_log_stripe_unit(lsflag, *lsunit,
+					&logblocks, *blocklog);
 	}
-	validate_log_size(logblocks, blocklog, min_logblocks);
+	validate_log_size(logblocks, *blocklog, min_logblocks);
 
 	if (!qflag || Nflag) {
 		printf(_(
@@ -3421,19 +3490,19 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\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,
+			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,
+			"", *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,
+			logfile, 1 << *blocklog, (long long)logblocks,
+			sb_feat.log_version, "", *lsectorsize, *lsunit,
 				sb_feat.lazy_sb_counters,
-			rtfile, rtextblocks << blocklog,
+			rtfile, rtextblocks << *blocklog,
 			(long long)rtblocks, (long long)rtextents);
 		if (Nflag)
 			exit(0);
@@ -3442,7 +3511,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 	if (label)
 		strncpy(sbp->sb_fname, label, sizeof(sbp->sb_fname));
 	sbp->sb_magicnum = XFS_SB_MAGIC;
-	sbp->sb_blocksize = blocksize;
+	sbp->sb_blocksize = *blocksize;
 	sbp->sb_dblocks = dblocks;
 	sbp->sb_rblocks = rtblocks;
 	sbp->sb_rextents = rtextents;
@@ -3452,52 +3521,52 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 	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_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_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_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_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_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;
+	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;
+		*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;
+			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;
+	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);
+	sb_set_features(&mp->m_sb, &sb_feat, sectorsize, *lsectorsize, *dsunit);
 
 	if (force_overwrite)
 		zero_old_xfs_structures(&xi, sbp);
@@ -3527,8 +3596,8 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 	 * 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) {
+	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);
@@ -3556,7 +3625,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 	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);
+		&sbp->sb_uuid, sb_feat.log_version, *lsunit, XLOG_FMT, XLOG_INIT_CYCLE, false);
 
 	mp = libxfs_mount(mp, sbp, xi.ddev, xi.logdev, xi.rtdev, 0);
 	if (mp == NULL) {
@@ -3570,7 +3639,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 	 * These initialisations should be pulled into libxfs to keep the
 	 * kernel/userspace header initialisation code the same.
 	 */
-	for (agno = 0; agno < agcount; agno++) {
+	for (agno = 0; agno < *agcount; agno++) {
 		struct xfs_agfl	*agfl;
 		int		bucket;
 		struct xfs_perag *pag = libxfs_perag_get(mp, agno);
@@ -3595,12 +3664,12 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 		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);
+		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_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);
@@ -3622,15 +3691,15 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 		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));
+		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) {
+		if (*loginternal && agno == *logagno) {
 			be32_add_cpu(&agf->agf_freeblks, -logblocks);
-			agf->agf_longest = cpu_to_be32(agsize -
+			agf->agf_longest = cpu_to_be32(*agsize -
 				XFS_FSB_TO_AGBNO(mp, logstart) - logblocks);
 		}
 		if (libxfs_alloc_min_freelist(mp, pag) > worst_freelist)
@@ -3669,7 +3738,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 		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_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);
@@ -3694,7 +3763,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 				bsize);
 		buf->b_ops = &xfs_allocbt_buf_ops;
 		block = XFS_BUF_TO_BLOCK(buf);
-		memset(block, 0, blocksize);
+		memset(block, 0, *blocksize);
 		if (xfs_sb_version_hascrc(&mp->m_sb))
 			libxfs_btree_init_block(mp, buf, XFS_ABTB_CRC_MAGIC, 0, 1,
 						agno, XFS_BTREE_CRC_BLOCKS);
@@ -3704,7 +3773,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 
 		arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
 		arec->ar_startblock = cpu_to_be32(libxfs_prealloc_blocks(mp));
-		if (loginternal && agno == logagno) {
+		if (*loginternal && agno == *logagno) {
 			if (lalign) {
 				/*
 				 * Have to insert two records
@@ -3734,7 +3803,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 		 * so, reset the record count to 0 to avoid exposure of an invalid
 		 * record start block.
 		 */
-		arec->ar_blockcount = cpu_to_be32(agsize -
+		arec->ar_blockcount = cpu_to_be32(*agsize -
 					be32_to_cpu(arec->ar_startblock));
 		if (!arec->ar_blockcount)
 			block->bb_numrecs = 0;
@@ -3749,7 +3818,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 				bsize);
 		buf->b_ops = &xfs_allocbt_buf_ops;
 		block = XFS_BUF_TO_BLOCK(buf);
-		memset(block, 0, blocksize);
+		memset(block, 0, *blocksize);
 		if (xfs_sb_version_hascrc(&mp->m_sb))
 			libxfs_btree_init_block(mp, buf, XFS_ABTC_CRC_MAGIC, 0, 1,
 						agno, XFS_BTREE_CRC_BLOCKS);
@@ -3759,7 +3828,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 
 		arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
 		arec->ar_startblock = cpu_to_be32(libxfs_prealloc_blocks(mp));
-		if (loginternal && agno == logagno) {
+		if (*loginternal && agno == *logagno) {
 			if (lalign) {
 				arec->ar_blockcount = cpu_to_be32(
 					XFS_FSB_TO_AGBNO(mp, logstart) -
@@ -3779,7 +3848,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 		 * so, reset the record count to 0 to avoid exposure of an invalid
 		 * record start block.
 		 */
-		arec->ar_blockcount = cpu_to_be32(agsize -
+		arec->ar_blockcount = cpu_to_be32(*agsize -
 					be32_to_cpu(arec->ar_startblock));
 		if (!arec->ar_blockcount)
 			block->bb_numrecs = 0;
@@ -3797,7 +3866,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 			buf->b_ops = &xfs_refcountbt_buf_ops;
 
 			block = XFS_BUF_TO_BLOCK(buf);
-			memset(block, 0, blocksize);
+			memset(block, 0, *blocksize);
 			libxfs_btree_init_block(mp, buf, XFS_REFC_CRC_MAGIC, 0,
 						0, agno, XFS_BTREE_CRC_BLOCKS);
 
@@ -3812,7 +3881,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 				bsize);
 		buf->b_ops = &xfs_inobt_buf_ops;
 		block = XFS_BUF_TO_BLOCK(buf);
-		memset(block, 0, blocksize);
+		memset(block, 0, *blocksize);
 		if (xfs_sb_version_hascrc(&mp->m_sb))
 			libxfs_btree_init_block(mp, buf, XFS_IBT_CRC_MAGIC, 0, 0,
 						agno, XFS_BTREE_CRC_BLOCKS);
@@ -3830,7 +3899,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 					bsize);
 			buf->b_ops = &xfs_inobt_buf_ops;
 			block = XFS_BUF_TO_BLOCK(buf);
-			memset(block, 0, blocksize);
+			memset(block, 0, *blocksize);
 			if (xfs_sb_version_hascrc(&mp->m_sb))
 				libxfs_btree_init_block(mp, buf, XFS_FIBT_CRC_MAGIC, 0, 0,
 							agno, XFS_BTREE_CRC_BLOCKS);
@@ -3849,7 +3918,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 				bsize);
 			buf->b_ops = &xfs_rmapbt_buf_ops;
 			block = XFS_BUF_TO_BLOCK(buf);
-			memset(block, 0, blocksize);
+			memset(block, 0, *blocksize);
 
 			libxfs_btree_init_block(mp, buf, XFS_RMAP_CRC_MAGIC, 0, 0,
 						agno, XFS_BTREE_CRC_BLOCKS);
@@ -3904,7 +3973,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 			}
 
 			/* account for the log space */
-			if (loginternal && agno == logagno) {
+			if (*loginternal && agno == *logagno) {
 				rrec = XFS_RMAP_REC_ADDR(block,
 					be16_to_cpu(block->bb_numrecs) + 1);
 				rrec->rm_startblock = cpu_to_be32(
@@ -3926,7 +3995,7 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 	 */
 	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);
+	memset(XFS_BUF_PTR(buf), 0, *blocksize);
 	libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
 
 	/*
@@ -3935,14 +4004,14 @@ _("size %lld specified for log subvolume is too large, maximum is %lld blocks\n"
 	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);
+		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++) {
+	for (agno = 0; agno < *agcount; agno++) {
 		xfs_alloc_arg_t	args;
 		xfs_trans_t	*tp;
 		struct xfs_trans_res tres = {0};
