Commit 91fd8438 authored by Jacek Kalwas's avatar Jacek Kalwas Committed by Jim Harris
Browse files

nvme: add spdk_nvme_trid_entry_parse util function 



While making utils
- fix error handling on "all PCIe" default trid parse in abort and perf
  app
- remove spdk_nvme_transport_id_populate_trstring from parse in abort
  and connect_stress app
- unify key:value separator support (:, =)

Change-Id: I9e3799537323cf8a16ca22b5768c6b1b1a800688
Signed-off-by: default avatarJacek Kalwas <jacek.kalwas@nutanix.com>
Reviewed-on: https://review.spdk.io/c/spdk/spdk/+/25851


Reviewed-by: default avatarAnkit Kumar <ankit.kumar@samsung.com>
Tested-by: default avatarSPDK Automated Test System <spdkbot@gmail.com>
Community-CI: Mellanox Build Bot
Reviewed-by: default avatarJim Harris <jim.harris@nvidia.com>
Reviewed-by: default avatarAleksey Marchuk <alexeymar@nvidia.com>
parent e87a3247

app/spdk_nvme_identify/identify.c

+13 −28
Original line number Diff line number Diff line
@@ -94,7 +94,7 @@ static int g_main_core = 0; 


static char g_core_mask[20] = "0x1";



static struct spdk_nvme_transport_id g_trid;

static struct spdk_nvme_trid_entry g_trid;

static char g_hostnqn[SPDK_NVMF_NQN_MAX_LEN + 1];



static int g_controllers_found = 0;
@@ -2749,10 +2749,11 @@ static int 
parse_args(int argc, char **argv)

{

	int op, rc;

	char *hostnqn;



	spdk_nvme_trid_populate_transport(&g_trid, SPDK_NVME_TRANSPORT_PCIE);

	snprintf(g_trid.subnqn, sizeof(g_trid.subnqn), "%s", SPDK_NVMF_DISCOVERY_NQN);

	rc = spdk_nvme_trid_entry_parse(&g_trid, "trtype:PCIe");

	if (rc < 0) {

		return 1;

	}



	while ((op = getopt(argc, argv, "d:gi:op:r:v:xz::HL:S:V")) != -1) {

		switch (op) {
@@ -2785,27 +2786,11 @@ parse_args(int argc, char **argv) 
			snprintf(g_core_mask, sizeof(g_core_mask), "0x%llx", 1ULL << g_main_core);

			break;

		case 'r':

			if (spdk_nvme_transport_id_parse(&g_trid, optarg) != 0) {

				fprintf(stderr, "Error parsing transport address\n");

				return 1;

			}



			assert(optarg != NULL);

			hostnqn = strcasestr(optarg, "hostnqn:");

			if (hostnqn) {

				size_t len;



				hostnqn += strlen("hostnqn:");



				len = strcspn(hostnqn, " \t\n");

				if (len > (sizeof(g_hostnqn) - 1)) {

					fprintf(stderr, "Host NQN is too long\n");

			rc = spdk_nvme_trid_entry_parse(&g_trid, optarg);

			if (rc < 0) {

				usage(argv[0]);

				return 1;

			}



				memcpy(g_hostnqn, hostnqn, len);

				g_hostnqn[len] = '\0';

			}

			break;

		case 'v':

			g_iova_mode = optarg;
@@ -2899,7 +2884,7 @@ main(int argc, char **argv) 
	opts.core_mask = g_core_mask;

	opts.hugepage_single_segments = g_dpdk_mem_single_seg;

	opts.iova_mode = g_iova_mode;

	if (g_trid.trtype != SPDK_NVME_TRANSPORT_PCIE) {

	if (g_trid.trid.trtype != SPDK_NVME_TRANSPORT_PCIE) {

		opts.no_pci = true;

	}

	if (spdk_env_init(&opts) < 0) {
@@ -2913,14 +2898,14 @@ main(int argc, char **argv) 
	}



	/* A specific trid is required. */

	if (strlen(g_trid.traddr) != 0) {

	if (strlen(g_trid.trid.traddr) != 0) {

		struct spdk_nvme_ctrlr_opts opts;



		spdk_nvme_ctrlr_get_default_ctrlr_opts(&opts, sizeof(opts));

		if (g_hostnqn[0] != '\0') {

			memcpy(opts.hostnqn, g_hostnqn, sizeof(opts.hostnqn));

		}

		ctrlr = spdk_nvme_connect(&g_trid, &opts, sizeof(opts));

		ctrlr = spdk_nvme_connect(&g_trid.trid, &opts, sizeof(opts));

		if (!ctrlr) {

			fprintf(stderr, "spdk_nvme_connect() failed\n");

			rc = 1;
@@ -2928,9 +2913,9 @@ main(int argc, char **argv) 
		}



		g_controllers_found++;

		print_controller(ctrlr, &g_trid, spdk_nvme_ctrlr_get_opts(ctrlr));

		print_controller(ctrlr, &g_trid.trid, spdk_nvme_ctrlr_get_opts(ctrlr));

		spdk_nvme_detach_async(ctrlr, &g_detach_ctx);

	} else if (spdk_nvme_probe(&g_trid, NULL, probe_cb, attach_cb, NULL) != 0) {

	} else if (spdk_nvme_probe(&g_trid.trid, NULL, probe_cb, attach_cb, NULL) != 0) {

		fprintf(stderr, "spdk_nvme_probe() failed\n");

		rc = 1;

		goto exit;

app/spdk_nvme_perf/perf.c

+32 −103
Original line number Diff line number Diff line
@@ -301,14 +301,14 @@ static pthread_mutex_t g_stats_mutex; 
#define MAX_ALLOWED_PCI_DEVICE_NUM 128

static struct spdk_pci_addr g_allowed_pci_addr[MAX_ALLOWED_PCI_DEVICE_NUM];



struct trid_entry {

	struct spdk_nvme_transport_id	trid;

	uint16_t			nsid;

	char				hostnqn[SPDK_NVMF_NQN_MAX_LEN + 1];

	TAILQ_ENTRY(trid_entry)		tailq;

struct _trid_entry {

	struct spdk_nvme_trid_entry entry;

	TAILQ_ENTRY(_trid_entry) tailq;

};



static TAILQ_HEAD(, trid_entry) g_trid_list = TAILQ_HEAD_INITIALIZER(g_trid_list);

#define MAX_TRID_ENTRY 256

static struct _trid_entry g_trids[MAX_TRID_ENTRY];

static TAILQ_HEAD(, _trid_entry) g_trid_list = TAILQ_HEAD_INITIALIZER(g_trid_list);



static int g_file_optind; /* Index of first filename in argv */
@@ -1425,7 +1425,7 @@ set_latency_tracking_feature(struct spdk_nvme_ctrlr *ctrlr, bool enable) 
}



static void

register_ctrlr(struct spdk_nvme_ctrlr *ctrlr, struct trid_entry *trid_entry)

register_ctrlr(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_trid_entry *trid_entry)

{

	struct spdk_nvme_ns *ns;

	struct ctrlr_entry *entry = malloc(sizeof(struct ctrlr_entry));
@@ -2194,89 +2194,6 @@ print_stats(void) 
	}

}



static void

unregister_trids(void)

{

	struct trid_entry *trid_entry, *tmp;



	TAILQ_FOREACH_SAFE(trid_entry, &g_trid_list, tailq, tmp) {

		TAILQ_REMOVE(&g_trid_list, trid_entry, tailq);

		free(trid_entry);

	}

}



static int

add_trid(const char *trid_str)

{

	struct trid_entry *trid_entry;

	struct spdk_nvme_transport_id *trid;

	char *ns;

	char *hostnqn;



	trid_entry = calloc(1, sizeof(*trid_entry));

	if (trid_entry == NULL) {

		return -1;

	}



	trid = &trid_entry->trid;

	trid->trtype = SPDK_NVME_TRANSPORT_PCIE;

	snprintf(trid->subnqn, sizeof(trid->subnqn), "%s", SPDK_NVMF_DISCOVERY_NQN);



	if (spdk_nvme_transport_id_parse(trid, trid_str) != 0) {

		fprintf(stderr, "Invalid transport ID format '%s'\n", trid_str);

		free(trid_entry);

		return 1;

	}



	if ((ns = strcasestr(trid_str, "ns:")) ||

	    (ns = strcasestr(trid_str, "ns="))) {

		char nsid_str[6]; /* 5 digits maximum in an nsid */

		int len;

		int nsid;



		ns += 3;



		len = strcspn(ns, " \t\n");

		if (len > 5) {

			fprintf(stderr, "NVMe namespace IDs must be 5 digits or less\n");

			free(trid_entry);

			return 1;

		}



		memcpy(nsid_str, ns, len);

		nsid_str[len] = '\0';



		nsid = spdk_strtol(nsid_str, 10);

		if (nsid <= 0 || nsid > 65535) {

			fprintf(stderr, "NVMe namespace IDs must be less than 65536 and greater than 0\n");

			free(trid_entry);

			return 1;

		}



		trid_entry->nsid = (uint16_t)nsid;

	}



	if ((hostnqn = strcasestr(trid_str, "hostnqn:")) ||

	    (hostnqn = strcasestr(trid_str, "hostnqn="))) {

		size_t len;



		hostnqn += strlen("hostnqn:");



		len = strcspn(hostnqn, " \t\n");

		if (len > (sizeof(trid_entry->hostnqn) - 1)) {

			fprintf(stderr, "Host NQN is too long\n");

			free(trid_entry);

			return 1;

		}



		memcpy(trid_entry->hostnqn, hostnqn, len);

		trid_entry->hostnqn[len] = '\0';

	}



	TAILQ_INSERT_TAIL(&g_trid_list, trid_entry, tailq);

	return 0;

}



static int

add_allowed_pci_device(const char *bdf_str, struct spdk_env_opts *env_opts)

{
@@ -2540,6 +2457,7 @@ parse_args(int argc, char **argv, struct spdk_env_opts *env_opts) 
	char *endptr;

	bool ssl_used = false;

	char *sock_impl = "posix";

	uint32_t trid_count = 0;



	while ((op = getopt_long(argc, argv, PERF_GETOPT_SHORT, g_perf_cmdline_opts, &long_idx)) != -1) {

		switch (op) {
@@ -2673,10 +2591,19 @@ parse_args(int argc, char **argv, struct spdk_env_opts *env_opts) 
			g_monitor_perf_cores = true;

			break;

		case PERF_TRANSPORT:

			if (add_trid(optarg)) {

			if (trid_count == MAX_TRID_ENTRY) {

				fprintf(stderr, "Number of Transport ID specified with -r is limited to %u\n", MAX_TRID_ENTRY);

				return 1;

			}



			rc = spdk_nvme_trid_entry_parse(&g_trids[trid_count].entry, optarg);

			if (rc < 0) {

				usage(argv[0]);

				return 1;

			}



			TAILQ_INSERT_TAIL(&g_trid_list, &g_trids[trid_count], tailq);

			++trid_count;

			break;

		case PERF_IO_PATTERN:

			g_workload_type = optarg;
@@ -2911,14 +2838,19 @@ parse_args(int argc, char **argv, struct spdk_env_opts *env_opts) 


	if (TAILQ_EMPTY(&g_trid_list)) {

		/* If no transport IDs specified, default to enumerating all local PCIe devices */

		add_trid("trtype:PCIe");

		rc = spdk_nvme_trid_entry_parse(&g_trids[trid_count].entry, "trtype:PCIe");

		if (rc < 0) {

			return 1;

		}



		TAILQ_INSERT_TAIL(&g_trid_list, &g_trids[trid_count], tailq);

	} else {

		struct trid_entry *trid_entry, *trid_entry_tmp;

		struct _trid_entry *trid_entry;



		env_opts->no_pci = true;

		/* check whether there is local PCIe type */

		TAILQ_FOREACH_SAFE(trid_entry, &g_trid_list, tailq, trid_entry_tmp) {

			if (trid_entry->trid.trtype == SPDK_NVME_TRANSPORT_PCIE) {

		TAILQ_FOREACH(trid_entry, &g_trid_list, tailq) {

			if (trid_entry->entry.trid.trtype == SPDK_NVME_TRANSPORT_PCIE) {

				env_opts->no_pci = false;

				break;

			}
@@ -2976,7 +2908,7 @@ static bool 
probe_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,

	 struct spdk_nvme_ctrlr_opts *opts)

{

	struct trid_entry *trid_entry = cb_ctx;

	struct spdk_nvme_trid_entry *trid_entry = cb_ctx;



	if (trid->trtype == SPDK_NVME_TRANSPORT_PCIE) {

		if (g_disable_sq_cmb) {
@@ -3016,7 +2948,7 @@ static void 
attach_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,

	  struct spdk_nvme_ctrlr *ctrlr, const struct spdk_nvme_ctrlr_opts *opts)

{

	struct trid_entry	*trid_entry = cb_ctx;

	struct spdk_nvme_trid_entry	*trid_entry = cb_ctx;

	struct spdk_pci_addr	pci_addr;

	struct spdk_pci_device	*pci_dev;

	struct spdk_pci_id	pci_id;
@@ -3055,7 +2987,7 @@ attach_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid, 
static int

register_controllers(void)

{

	struct trid_entry *trid_entry;

	struct _trid_entry *trid_entry;



	printf("Initializing NVMe Controllers\n");
@@ -3065,9 +2997,9 @@ register_controllers(void) 
	}



	TAILQ_FOREACH(trid_entry, &g_trid_list, tailq) {

		if (spdk_nvme_probe(&trid_entry->trid, trid_entry, probe_cb, attach_cb, NULL) != 0) {

		if (spdk_nvme_probe(&trid_entry->entry.trid, &trid_entry->entry, probe_cb, attach_cb, NULL) != 0) {

			fprintf(stderr, "spdk_nvme_probe() failed for transport address '%s'\n",

				trid_entry->trid.traddr);

				trid_entry->entry.trid.traddr);

			return -1;

		}

	}
@@ -3277,7 +3209,6 @@ main(int argc, char **argv) 
	}

	if (spdk_env_init(&opts) < 0) {

		fprintf(stderr, "Unable to initialize SPDK env\n");

		unregister_trids();

		pthread_mutex_destroy(&g_stats_mutex);

		free_key(&g_psk);

		return -1;
@@ -3286,7 +3217,6 @@ main(int argc, char **argv) 
	rc = spdk_keyring_init();

	if (rc != 0) {

		fprintf(stderr, "Unable to initialize keyring: %s\n", spdk_strerror(-rc));

		unregister_trids();

		pthread_mutex_destroy(&g_stats_mutex);

		free_key(&g_psk);

		spdk_env_fini();
@@ -3393,7 +3323,6 @@ cleanup: 
		}

	}



	unregister_trids();

	unregister_namespaces();

	unregister_controllers();

	unregister_workers();

examples/nvme/abort/abort.c

+31 −85
Original line number Diff line number Diff line
@@ -108,13 +108,14 @@ static const struct option g_abort_cmdline_opts[] = { 
	{0, 0, 0, 0}

};



struct trid_entry {

	struct spdk_nvme_transport_id	trid;

	uint16_t			nsid;

	TAILQ_ENTRY(trid_entry)		tailq;

struct _trid_entry {

	struct spdk_nvme_trid_entry entry;

	TAILQ_ENTRY(_trid_entry) tailq;

};



static TAILQ_HEAD(, trid_entry) g_trid_list = TAILQ_HEAD_INITIALIZER(g_trid_list);

#define MAX_TRID_ENTRY 256

static struct _trid_entry g_trids[MAX_TRID_ENTRY];

static TAILQ_HEAD(, _trid_entry) g_trid_list = TAILQ_HEAD_INITIALIZER(g_trid_list);



static void io_complete(void *ctx, const struct spdk_nvme_cpl *cpl);
@@ -245,7 +246,7 @@ unregister_namespaces(void) 
}



static void

register_ctrlr(struct spdk_nvme_ctrlr *ctrlr, struct trid_entry *trid_entry)

register_ctrlr(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_trid_entry *trid_entry)

{

	struct spdk_nvme_ns *ns;

	struct ctrlr_entry *entry = malloc(sizeof(struct ctrlr_entry));
@@ -570,80 +571,13 @@ usage(char *program_name) 
	printf("\t  disabled, error, warning, notice, info, debug\n");

}



static void

unregister_trids(void)

{

	struct trid_entry *trid_entry, *tmp;



	TAILQ_FOREACH_SAFE(trid_entry, &g_trid_list, tailq, tmp) {

		TAILQ_REMOVE(&g_trid_list, trid_entry, tailq);

		free(trid_entry);

	}

}



static int

add_trid(const char *trid_str)

{

	struct trid_entry *trid_entry;

	struct spdk_nvme_transport_id *trid;

	char *ns;



	trid_entry = calloc(1, sizeof(*trid_entry));

	if (trid_entry == NULL) {

		return -1;

	}



	trid = &trid_entry->trid;

	trid->trtype = SPDK_NVME_TRANSPORT_PCIE;

	snprintf(trid->subnqn, sizeof(trid->subnqn), "%s", SPDK_NVMF_DISCOVERY_NQN);



	if (spdk_nvme_transport_id_parse(trid, trid_str) != 0) {

		fprintf(stderr, "Invalid transport ID format '%s'\n", trid_str);

		free(trid_entry);

		return 1;

	}



	spdk_nvme_transport_id_populate_trstring(trid,

			spdk_nvme_transport_id_trtype_str(trid->trtype));



	ns = strcasestr(trid_str, "ns:");

	if (ns) {

		char nsid_str[6]; /* 5 digits maximum in an nsid */

		int len;

		int nsid;



		ns += 3;



		len = strcspn(ns, " \t\n");

		if (len > 5) {

			fprintf(stderr, "NVMe namespace IDs must be 5 digits or less\n");

			free(trid_entry);

			return 1;

		}



		memcpy(nsid_str, ns, len);

		nsid_str[len] = '\0';



		nsid = spdk_strtol(nsid_str, 10);

		if (nsid <= 0 || nsid > 65535) {

			fprintf(stderr, "NVMe namespace IDs must be less than 65536 and greater than 0\n");

			free(trid_entry);

			return 1;

		}



		trid_entry->nsid = (uint16_t)nsid;

	}



	TAILQ_INSERT_TAIL(&g_trid_list, trid_entry, tailq);

	return 0;

}



static int

parse_args(int argc, char **argv)

{

	int op, opt_index;

	long int val;

	int rc;

	uint32_t trid_count = 0;



	while ((op = getopt_long(argc, argv, ABORT_GETOPT_STRING, g_abort_cmdline_opts,

				 &opt_index)) != -1) {
@@ -689,10 +623,19 @@ parse_args(int argc, char **argv) 
			g_core_mask = optarg;

			break;

		case 'r':

			if (add_trid(optarg)) {

			if (trid_count == MAX_TRID_ENTRY) {

				fprintf(stderr, "Number of Transport ID specified with -r is limited to %u\n", MAX_TRID_ENTRY);

				return 1;

			}



			rc = spdk_nvme_trid_entry_parse(&g_trids[trid_count].entry, optarg);

			if (rc < 0) {

				usage(argv[0]);

				return 1;

			}



			TAILQ_INSERT_TAIL(&g_trid_list, &g_trids[trid_count], tailq);

			++trid_count;

			break;

		case 'w':

			g_workload_type = optarg;
@@ -794,14 +737,19 @@ parse_args(int argc, char **argv) 


	if (TAILQ_EMPTY(&g_trid_list)) {

		/* If no transport IDs specified, default to enumerating all local PCIe devices */

		add_trid("trtype:PCIe");

		rc = spdk_nvme_trid_entry_parse(&g_trids[trid_count].entry, "trtype:PCIe");

		if (rc < 0) {

			return 1;

		}



		TAILQ_INSERT_TAIL(&g_trid_list, &g_trids[trid_count], tailq);

	} else {

		struct trid_entry *trid_entry, *trid_entry_tmp;

		struct _trid_entry *trid_entry;



		g_no_pci = true;

		/* check whether there is local PCIe type */

		TAILQ_FOREACH_SAFE(trid_entry, &g_trid_list, tailq, trid_entry_tmp) {

			if (trid_entry->trid.trtype == SPDK_NVME_TRANSPORT_PCIE) {

		TAILQ_FOREACH(trid_entry, &g_trid_list, tailq) {

			if (trid_entry->entry.trid.trtype == SPDK_NVME_TRANSPORT_PCIE) {

				g_no_pci = false;

				break;

			}
@@ -889,7 +837,7 @@ static void 
attach_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,

	  struct spdk_nvme_ctrlr *ctrlr, const struct spdk_nvme_ctrlr_opts *opts)

{

	struct trid_entry       *trid_entry = cb_ctx;

	struct spdk_nvme_trid_entry       *trid_entry = cb_ctx;

	struct spdk_pci_addr    pci_addr;

	struct spdk_pci_device  *pci_dev;

	struct spdk_pci_id      pci_id;
@@ -921,14 +869,14 @@ attach_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid, 
static int

register_controllers(void)

{

	struct trid_entry *trid_entry;

	struct _trid_entry *trid_entry;



	printf("Initializing NVMe Controllers\n");



	TAILQ_FOREACH(trid_entry, &g_trid_list, tailq) {

		if (spdk_nvme_probe(&trid_entry->trid, trid_entry, probe_cb, attach_cb, NULL) != 0) {

		if (spdk_nvme_probe(&trid_entry->entry.trid, &trid_entry->entry, probe_cb, attach_cb, NULL) != 0) {

			fprintf(stderr, "spdk_nvme_probe() failed for transport address '%s'\n",

				trid_entry->trid.traddr);

				trid_entry->entry.trid.traddr);

			return -1;

		}

	}
@@ -1086,7 +1034,6 @@ main(int argc, char **argv) 
	}

	if (spdk_env_init(&opts) < 0) {

		fprintf(stderr, "Unable to initialize SPDK env\n");

		unregister_trids();

		return -1;

	}
@@ -1149,7 +1096,6 @@ main(int argc, char **argv) 
	}



cleanup:

	unregister_trids();

	unregister_workers();

	unregister_namespaces();

	unregister_controllers();

examples/nvme/reconnect/reconnect.c

+25 −67
Original line number Diff line number Diff line
@@ -92,13 +92,14 @@ static bool g_dpdk_mem_single_seg = false; 


static const char *g_core_mask;



struct trid_entry {

	struct spdk_nvme_transport_id	trid;

	struct spdk_nvme_transport_id	failover_trid;

	TAILQ_ENTRY(trid_entry)		tailq;

struct _trid_entry {

	struct spdk_nvme_trid_entry entry;

	TAILQ_ENTRY(_trid_entry) tailq;

};



static TAILQ_HEAD(, trid_entry) g_trid_list = TAILQ_HEAD_INITIALIZER(g_trid_list);

#define MAX_TRID_ENTRY 256

static struct _trid_entry g_trids[MAX_TRID_ENTRY];

static TAILQ_HEAD(, _trid_entry) g_trid_list = TAILQ_HEAD_INITIALIZER(g_trid_list);



static inline void task_complete(struct perf_task *task);

static void submit_io(struct ns_worker_ctx *ns_ctx, int queue_depth);
@@ -338,7 +339,7 @@ unregister_namespaces(void) 
}



static void

register_ctrlr(struct spdk_nvme_ctrlr *ctrlr, struct trid_entry *trid_entry)

register_ctrlr(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_trid_entry *trid_entry)

{

	struct spdk_nvme_ns *ns;

	struct ctrlr_entry *entry = calloc(1, sizeof(struct ctrlr_entry));
@@ -584,66 +585,16 @@ usage(char *program_name) 
#endif

}



static void

unregister_trids(void)

{

	struct trid_entry *trid_entry, *tmp;



	TAILQ_FOREACH_SAFE(trid_entry, &g_trid_list, tailq, tmp) {

		TAILQ_REMOVE(&g_trid_list, trid_entry, tailq);

		free(trid_entry);

	}

}



static int

add_trid(const char *trid_str)

{

	struct trid_entry *trid_entry;

	struct spdk_nvme_transport_id *trid;

	char *alt_traddr;

	int len;



	trid_entry = calloc(1, sizeof(*trid_entry));

	if (trid_entry == NULL) {

		return -1;

	}



	trid = &trid_entry->trid;

	snprintf(trid->subnqn, sizeof(trid->subnqn), "%s", SPDK_NVMF_DISCOVERY_NQN);



	if (spdk_nvme_transport_id_parse(trid, trid_str) != 0) {

		fprintf(stderr, "Invalid transport ID format '%s'\n", trid_str);

		free(trid_entry);

		return 1;

	}



	trid_entry->failover_trid = trid_entry->trid;



	alt_traddr = strcasestr(trid_str, "alt_traddr:");

	if (alt_traddr) {

		alt_traddr += strlen("alt_traddr:");

		len = strcspn(alt_traddr, " \t\n");

		if (len > SPDK_NVMF_TRADDR_MAX_LEN) {

			fprintf(stderr, "The failover traddr %s is too long.\n", alt_traddr);

			free(trid_entry);

			return -1;

		}

		snprintf(trid_entry->failover_trid.traddr, SPDK_NVMF_TRADDR_MAX_LEN + 1, "%s", alt_traddr);

	}



	TAILQ_INSERT_TAIL(&g_trid_list, trid_entry, tailq);

	return 0;

}



static int

parse_args(int argc, char **argv)

{

	struct trid_entry *trid_entry, *trid_entry_tmp;

	struct _trid_entry *trid_entry;

	const char *workload_type;

	int op;

	bool mix_specified = false;

	long int val;

	int rc;

	uint32_t trid_count = 0;



	/* default value */

	g_queue_depth = 0;
@@ -708,10 +659,19 @@ parse_args(int argc, char **argv) 
			g_dpdk_mem_single_seg = true;

			break;

		case 'r':

			if (add_trid(optarg)) {

			if (trid_count == MAX_TRID_ENTRY) {

				fprintf(stderr, "Number of Transport ID specified with -r is limited to %u\n", MAX_TRID_ENTRY);

				return 1;

			}



			rc = spdk_nvme_trid_entry_parse(&g_trids[trid_count].entry, optarg);

			if (rc < 0) {

				usage(argv[0]);

				return 1;

			}



			TAILQ_INSERT_TAIL(&g_trid_list, &g_trids[trid_count], tailq);

			++trid_count;

			break;

		case 'w':

			workload_type = optarg;
@@ -817,8 +777,8 @@ parse_args(int argc, char **argv) 
	}



	/* check whether there is local PCIe type and fail. */

	TAILQ_FOREACH_SAFE(trid_entry, &g_trid_list, tailq, trid_entry_tmp) {

		if (trid_entry->trid.trtype == SPDK_NVME_TRANSPORT_PCIE) {

	TAILQ_FOREACH(trid_entry, &g_trid_list, tailq) {

		if (trid_entry->entry.trid.trtype == SPDK_NVME_TRANSPORT_PCIE) {

			fprintf(stderr, "This application was not intended to be run on PCIe controllers.\n");

			return 1;

		}
@@ -897,7 +857,7 @@ static void 
attach_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,

	  struct spdk_nvme_ctrlr *ctrlr, const struct spdk_nvme_ctrlr_opts *opts)

{

	struct trid_entry	*trid_entry = cb_ctx;

	struct spdk_nvme_trid_entry	*trid_entry = cb_ctx;



	printf("Attached to NVMe over Fabrics controller at %s:%s: %s\n",

	       trid->traddr, trid->trsvcid,
@@ -909,14 +869,14 @@ attach_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid, 
static int

register_controllers(void)

{

	struct trid_entry *trid_entry;

	struct _trid_entry *trid_entry;



	printf("Initializing NVMe Controllers\n");



	TAILQ_FOREACH(trid_entry, &g_trid_list, tailq) {

		if (spdk_nvme_probe(&trid_entry->trid, trid_entry, probe_cb, attach_cb, NULL) != 0) {

		if (spdk_nvme_probe(&trid_entry->entry.trid, &trid_entry->entry, probe_cb, attach_cb, NULL) != 0) {

			fprintf(stderr, "spdk_nvme_probe() failed for transport address '%s'\n",

				trid_entry->trid.traddr);

				trid_entry->entry.trid.traddr);

			return -1;

		}

	}
@@ -1063,7 +1023,6 @@ main(int argc, char **argv) 
	opts.hugepage_single_segments = g_dpdk_mem_single_seg;

	if (spdk_env_init(&opts) < 0) {

		fprintf(stderr, "Unable to initialize SPDK env\n");

		unregister_trids();

		return 1;

	}
@@ -1122,7 +1081,6 @@ cleanup: 
	if (thread_id && pthread_cancel(thread_id) == 0) {

		pthread_join(thread_id, NULL);

	}

	unregister_trids();

	unregister_namespaces();

	unregister_controllers();

	unregister_workers();

include/spdk_internal/nvme_util.h

+26 −0
Original line number Diff line number Diff line
@@ -18,6 +18,13 @@ enum spdk_nvme_trid_usage_opt { 
	SPDK_NVME_TRID_USAGE_OPT_ALT_TRADDR = 1 << 8,

};



struct spdk_nvme_trid_entry {

	struct spdk_nvme_transport_id trid;

	uint16_t nsid;

	char hostnqn[SPDK_NVMF_NQN_MAX_LEN + 1];

	struct spdk_nvme_transport_id	failover_trid;

};



/**

 * Prints Transport ID format and its description.

 *
@@ -26,4 +33,23 @@ enum spdk_nvme_trid_usage_opt { 
 */

void spdk_nvme_transport_id_usage(FILE *f, uint32_t opts);



/**

 * Parses the string representation of a transport ID with extra key:value pairs.

 *

 * See \ref spdk_nvme_transport_id_parse for more details and base key:value pairs.

 *

 * Key          | Value

 * ------------ | -----

 * ns           | NVMe namespace ID (all active namespaces are used by default)

 * hostnqn      | Host NQN

 * alt_traddr   | Alternative Transport address for failover

 *

 * \param str Input string representation of a transport ID to parse.

 * \param trid_entry Output transport ID structure (must be allocated and initialized by caller).

 *

 * \return 0 if parsing was successful and trid is filled out, or negated errno

 * values on failure.

 */

int spdk_nvme_trid_entry_parse(struct spdk_nvme_trid_entry *trid_entry, const char *str);



#endif /* SPDK_INTERNAL_NVME_UTIL_H */