mkfs: support arbitrary conflict specification

Currently the conflict table is a single dimension, allowing
conflicts to be specified in the same option table. however, we
have conflicts that span option tables (e.g. sector size) and
so we need to encode both the table and the option that conflicts.

Add support for a two dimensional conflict definition and convert
all the code over to use it.

Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Eric Sandeen <sandeen@sandeen.net>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

1 files changed, 130 insertions, 127 deletions

diff --git a/mkfs/xfs_mkfs.c b/mkfs/xfs_mkfs.c
index 438cdc3246..1825ba85a4 100644
--- a/mkfs/xfs_mkfs.c
+++ b/mkfs/xfs_mkfs.c
@@ -125,7 +125,10 @@ struct opt_params {
 		bool		str_seen;
 		bool		convert;
 		bool		is_power_2;
-		int		conflicts[MAX_CONFLICTS];
+		struct _conflict {
+			struct opt_params	*opts;
+			int			subopt;
+		}		conflicts[MAX_CONFLICTS];
 		long long	minval;
 		long long	maxval;
 		long long	defaultval;
@@ -143,8 +146,8 @@ struct opt_params bopts = {
 	},
 	.subopt_params = {
 		{ .index = B_LOG,
-		  .conflicts = { B_SIZE,
-				 LAST_CONFLICT },
+		  .conflicts = { { &bopts, B_SIZE },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = XFS_MIN_BLOCKSIZE_LOG,
 		  .maxval = XFS_MAX_BLOCKSIZE_LOG,
 		  .defaultval = SUBOPT_NEEDS_VAL,
@@ -152,8 +155,8 @@ struct opt_params bopts = {
 		{ .index = B_SIZE,
 		  .convert = true,
 		  .is_power_2 = true,
-		  .conflicts = { B_LOG,
-				 LAST_CONFLICT },
+		  .conflicts = { { &bopts, B_LOG },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = XFS_MIN_BLOCKSIZE,
 		  .maxval = XFS_MAX_BLOCKSIZE,
 		  .defaultval = SUBOPT_NEEDS_VAL,
@@ -200,84 +203,84 @@ struct opt_params dopts = {
 	},
 	.subopt_params = {
 		{ .index = D_AGCOUNT,
-		  .conflicts = { D_AGSIZE,
-				 LAST_CONFLICT },
+		  .conflicts = { { &dopts, D_AGSIZE },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = 1,
 		  .maxval = XFS_MAX_AGNUMBER,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_FILE,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
 		},
 		{ .index = D_NAME,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_SIZE,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .minval = XFS_AG_MIN_BYTES,
 		  .maxval = LLONG_MAX,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_SUNIT,
-		  .conflicts = { D_NOALIGN,
-				 D_SU,
-				 D_SW,
-				 LAST_CONFLICT },
+		  .conflicts = { { &dopts, D_NOALIGN },
+				 { &dopts, D_SU },
+				 { &dopts, D_SW },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = UINT_MAX,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_SWIDTH,
-		  .conflicts = { D_NOALIGN,
-				 D_SU,
-				 D_SW,
-				 LAST_CONFLICT },
+		  .conflicts = { { &dopts, D_NOALIGN },
+				 { &dopts, D_SU },
+				 { &dopts, D_SW },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = UINT_MAX,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_AGSIZE,
-		  .conflicts = { D_AGCOUNT,
-				 LAST_CONFLICT },
+		  .conflicts = { { &dopts, D_AGCOUNT },
+				 { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .minval = XFS_AG_MIN_BYTES,
 		  .maxval = XFS_AG_MAX_BYTES,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_SU,
-		  .conflicts = { D_NOALIGN,
-				 D_SUNIT,
-				 D_SWIDTH,
-				 LAST_CONFLICT },
+		  .conflicts = { { &dopts, D_NOALIGN },
+				 { &dopts, D_SUNIT },
+				 { &dopts, D_SWIDTH },
+				 { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .minval = 0,
 		  .maxval = UINT_MAX,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_SW,
-		  .conflicts = { D_NOALIGN,
-				 D_SUNIT,
-				 D_SWIDTH,
-				 LAST_CONFLICT },
+		  .conflicts = { { &dopts, D_NOALIGN },
+				 { &dopts, D_SUNIT },
+				 { &dopts, D_SWIDTH },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = UINT_MAX,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_SECTLOG,
-		  .conflicts = { D_SECTSIZE,
-				 LAST_CONFLICT },
+		  .conflicts = { { &dopts, D_SECTSIZE },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = XFS_MIN_SECTORSIZE_LOG,
 		  .maxval = XFS_MAX_SECTORSIZE_LOG,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_SECTSIZE,
-		  .conflicts = { D_SECTLOG,
-				 LAST_CONFLICT },
+		  .conflicts = { { &dopts, D_SECTLOG },
+				 { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .is_power_2 = true,
 		  .minval = XFS_MIN_SECTORSIZE,
@@ -285,35 +288,35 @@ struct opt_params dopts = {
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_NOALIGN,
-		  .conflicts = { D_SU,
-				 D_SW,
-				 D_SUNIT,
-				 D_SWIDTH,
-				 LAST_CONFLICT },
+		  .conflicts = { { &dopts, D_SU },
+				 { &dopts, D_SW },
+				 { &dopts, D_SUNIT },
+				 { &dopts, D_SWIDTH },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
 		},
 		{ .index = D_RTINHERIT,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 1,
 		  .maxval = 1,
 		  .defaultval = 1,
 		},
 		{ .index = D_PROJINHERIT,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = UINT_MAX,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_EXTSZINHERIT,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = UINT_MAX,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = D_COWEXTSIZE,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = UINT_MAX,
 		  .defaultval = SUBOPT_NEEDS_VAL,
@@ -345,57 +348,57 @@ struct opt_params iopts = {
 	},
 	.subopt_params = {
 		{ .index = I_ALIGN,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
 		},
 		{ .index = I_LOG,
-		  .conflicts = { I_PERBLOCK,
-				 I_SIZE,
-				 LAST_CONFLICT },
+		  .conflicts = { { &iopts, I_PERBLOCK },
+				 { &iopts, I_SIZE },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = XFS_DINODE_MIN_LOG,
 		  .maxval = XFS_DINODE_MAX_LOG,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = I_MAXPCT,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 100,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = I_PERBLOCK,
-		  .conflicts = { I_LOG,
-				 I_SIZE,
-				 LAST_CONFLICT },
+		  .conflicts = { { &iopts, I_LOG },
+				 { &iopts, I_SIZE },
+				 { NULL, LAST_CONFLICT } },
 		  .is_power_2 = true,
 		  .minval = XFS_MIN_INODE_PERBLOCK,
 		  .maxval = XFS_MAX_BLOCKSIZE / XFS_DINODE_MIN_SIZE,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = I_SIZE,
-		  .conflicts = { I_PERBLOCK,
-				 I_LOG,
-				 LAST_CONFLICT },
+		  .conflicts = { { &iopts, I_PERBLOCK },
+				 { &iopts, I_LOG },
+				 { NULL, LAST_CONFLICT } },
 		  .is_power_2 = true,
 		  .minval = XFS_DINODE_MIN_SIZE,
 		  .maxval = XFS_DINODE_MAX_SIZE,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = I_ATTR,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 2,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = I_PROJID32BIT,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
 		},
 		{ .index = I_SPINODES,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
@@ -434,68 +437,68 @@ struct opt_params lopts = {
 	},
 	.subopt_params = {
 		{ .index = L_AGNUM,
-		  .conflicts = { L_DEV,
-				 LAST_CONFLICT },
+		  .conflicts = { { &lopts, L_DEV },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = UINT_MAX,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = L_INTERNAL,
-		  .conflicts = { L_FILE,
-				 L_DEV,
-				 L_SECTLOG,
-				 L_SECTSIZE,
-				 LAST_CONFLICT },
+		  .conflicts = { { &lopts, L_FILE },
+				 { &lopts, L_DEV },
+				 { &lopts, L_SECTLOG },
+				 { &lopts, L_SECTSIZE },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
 		},
 		{ .index = L_SIZE,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .minval = 2 * 1024 * 1024LL,	/* XXX: XFS_MIN_LOG_BYTES */
 		  .maxval = XFS_MAX_LOG_BYTES,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = L_VERSION,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 1,
 		  .maxval = 2,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = L_SUNIT,
-		  .conflicts = { L_SU,
-				 LAST_CONFLICT },
+		  .conflicts = { { &lopts, L_SU },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = 1,
 		  .maxval = BTOBB(XLOG_MAX_RECORD_BSIZE),
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = L_SU,
-		  .conflicts = { L_SUNIT,
-				 LAST_CONFLICT },
+		  .conflicts = { { &lopts, L_SUNIT },
+				 { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .minval = BBTOB(1),
 		  .maxval = XLOG_MAX_RECORD_BSIZE,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = L_DEV,
-		  .conflicts = { L_AGNUM,
-				 L_INTERNAL,
-				 LAST_CONFLICT },
+		  .conflicts = { { &lopts, L_AGNUM },
+				 { &lopts, L_INTERNAL },
+				 { NULL, LAST_CONFLICT } },
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = L_SECTLOG,
-		  .conflicts = { L_SECTSIZE,
-				 L_INTERNAL,
-				 LAST_CONFLICT },
+		  .conflicts = { { &lopts, L_SECTSIZE },
+				 { &lopts, L_INTERNAL },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = XFS_MIN_SECTORSIZE_LOG,
 		  .maxval = XFS_MAX_SECTORSIZE_LOG,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = L_SECTSIZE,
-		  .conflicts = { L_SECTLOG,
-				 L_INTERNAL,
-				 LAST_CONFLICT },
+		  .conflicts = { { &lopts, L_SECTLOG },
+				 { &lopts, L_INTERNAL },
+				 { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .is_power_2 = true,
 		  .minval = XFS_MIN_SECTORSIZE,
@@ -503,20 +506,20 @@ struct opt_params lopts = {
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = L_FILE,
-		  .conflicts = { L_INTERNAL,
-				 LAST_CONFLICT },
+		  .conflicts = { { &lopts, L_INTERNAL },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
 		},
 		{ .index = L_NAME,
-		  .conflicts = { L_AGNUM,
-				 L_INTERNAL,
-				 LAST_CONFLICT },
+		  .conflicts = { { &lopts, L_AGNUM },
+				 { &lopts, L_INTERNAL },
+				 { NULL, LAST_CONFLICT } },
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = L_LAZYSBCNTR,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
@@ -539,15 +542,15 @@ struct opt_params nopts = {
 	},
 	.subopt_params = {
 		{ .index = N_LOG,
-		  .conflicts = { N_SIZE,
-				 LAST_CONFLICT },
+		  .conflicts = { { &nopts, N_SIZE },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = XFS_MIN_REC_DIRSIZE,
 		  .maxval = XFS_MAX_BLOCKSIZE_LOG,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = N_SIZE,
-		  .conflicts = { N_LOG,
-				 LAST_CONFLICT },
+		  .conflicts = { { &nopts, N_LOG },
+				 { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .is_power_2 = true,
 		  .minval = 1 << XFS_MIN_REC_DIRSIZE,
@@ -555,13 +558,13 @@ struct opt_params nopts = {
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = N_VERSION,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 2,
 		  .maxval = 2,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = N_FTYPE,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
@@ -588,38 +591,38 @@ struct opt_params ropts = {
 	},
 	.subopt_params = {
 		{ .index = R_EXTSIZE,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .minval = XFS_MIN_RTEXTSIZE,
 		  .maxval = XFS_MAX_RTEXTSIZE,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = R_SIZE,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .minval = 0,
 		  .maxval = LLONG_MAX,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = R_DEV,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = R_FILE,
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		},
 		{ .index = R_NAME,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = R_NOALIGN,
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		},
 	},
 };
@@ -639,25 +642,25 @@ struct opt_params sopts = {
 	},
 	.subopt_params = {
 		{ .index = S_LOG,
-		  .conflicts = { S_SIZE,
-				 S_SECTSIZE,
-				 LAST_CONFLICT },
+		  .conflicts = { { &sopts, S_SIZE },
+				 { &sopts, S_SECTSIZE },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = XFS_MIN_SECTORSIZE_LOG,
 		  .maxval = XFS_MAX_SECTORSIZE_LOG,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = S_SECTLOG,
-		  .conflicts = { S_SIZE,
-				 S_SECTSIZE,
-				 LAST_CONFLICT },
+		  .conflicts = { { &sopts, S_SIZE },
+				 { &sopts, S_SECTSIZE },
+				 { NULL, LAST_CONFLICT } },
 		  .minval = XFS_MIN_SECTORSIZE_LOG,
 		  .maxval = XFS_MAX_SECTORSIZE_LOG,
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = S_SIZE,
-		  .conflicts = { S_LOG,
-				 S_SECTLOG,
-				 LAST_CONFLICT },
+		  .conflicts = { { &sopts, S_LOG },
+				 { &sopts, S_SECTLOG },
+				 { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .is_power_2 = true,
 		  .minval = XFS_MIN_SECTORSIZE,
@@ -665,9 +668,9 @@ struct opt_params sopts = {
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = S_SECTSIZE,
-		  .conflicts = { S_LOG,
-				 S_SECTLOG,
-				 LAST_CONFLICT },
+		  .conflicts = { { &sopts, S_LOG },
+				 { &sopts, S_SECTLOG },
+				 { NULL, LAST_CONFLICT } },
 		  .convert = true,
 		  .is_power_2 = true,
 		  .minval = XFS_MIN_SECTORSIZE,
@@ -694,29 +697,29 @@ struct opt_params mopts = {
 	},
 	.subopt_params = {
 		{ .index = M_CRC,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
 		},
 		{ .index = M_FINOBT,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
 		},
 		{ .index = M_UUID,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .defaultval = SUBOPT_NEEDS_VAL,
 		},
 		{ .index = M_RMAPBT,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
 		},
 		{ .index = M_REFLINK,
-		  .conflicts = { LAST_CONFLICT },
+		  .conflicts = { { NULL, LAST_CONFLICT } },
 		  .minval = 0,
 		  .maxval = 1,
 		  .defaultval = 1,
@@ -924,13 +927,14 @@ usage( void )
 
 static void
 conflict(
-	char		opt,
-	const char	*tab[],
-	int		oldidx,
-	int		newidx)
+	struct opt_params       *opts,
+	int			option,
+	struct opt_params       *con_opts,
+	int			conflict)
 {
 	fprintf(stderr, _("Cannot specify both -%c %s and -%c %s\n"),
-		opt, tab[oldidx], opt, tab[newidx]);
+			opts->name, opts->subopts[option],
+			con_opts->name, con_opts->subopts[conflict]);
 	usage();
 }
 
@@ -1341,14 +1345,13 @@ check_opt(
 
 	/* check for conflicts with the option */
 	for (i = 0; i < MAX_CONFLICTS; i++) {
-		int conflict_opt = sp->conflicts[i];
+		struct _conflict *con = &sp->conflicts[i];
 
-		if (conflict_opt == LAST_CONFLICT)
+		if (con->subopt == LAST_CONFLICT)
 			break;
-		if (opts->subopt_params[conflict_opt].seen ||
-		    opts->subopt_params[conflict_opt].str_seen)
-			conflict(opts->name, opts->subopts,
-				 conflict_opt, index);
+		if (con->opts->subopt_params[con->subopt].seen ||
+		    con->opts->subopt_params[con->subopt].str_seen)
+			conflict(opts, index, con->opts, con->subopt);
 	}
 }
 
@@ -1490,13 +1493,13 @@ data_opts_parser(
 		break;
 	case D_SECTLOG:
 		if (cli->sectorsize)
-			conflict('d', opts->subopts, D_SECTSIZE, D_SECTLOG);
+			conflict(opts, D_SECTSIZE, opts, 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);
+			conflict(opts, D_SECTSIZE, opts, D_SECTLOG);
 		cli->sectorsize = getnum(value, opts, D_SECTSIZE);
 		break;
 	case D_RTINHERIT:
@@ -1723,7 +1726,7 @@ sector_opts_parser(
 	case S_LOG:
 	case S_SECTLOG:
 		if (cli->sectorsize)
-			conflict('s', opts->subopts, S_SECTSIZE, S_SECTLOG);
+			conflict(opts, S_SECTSIZE, opts, S_SECTLOG);
 		sectorlog = getnum(value, opts, S_SECTLOG);
 		cli->sectorsize = 1 << sectorlog;
 		cli->lsectorsize = cli->sectorsize;
@@ -1731,7 +1734,7 @@ sector_opts_parser(
 	case S_SIZE:
 	case S_SECTSIZE:
 		if (cli->sectorsize)
-			conflict('s', opts->subopts, S_SECTLOG, S_SECTSIZE);
+			conflict(opts, S_SECTSIZE, opts, S_SECTLOG);
 		cli->sectorsize = getnum(value, opts, S_SECTSIZE);
 		cli->lsectorsize = cli->sectorsize;
 		break;