bdev modules: remove legacy config support

This patch removes legacy config support in:
 crypto bdev module
- nvme bdev module
- ocf bdev module
- rbd bdev module
- pmem bdev module
- iscsi bdev module
- raid bdev module
All options through the legacy config are already reflected in JSON.

Signed-off-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Change-Id: I00213365f52d3de1012493c14d4ea5fc537e595e
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/4673
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Community-CI: Broadcom CI
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
This commit is contained in:
Tomasz Zawadzki 2020-10-14 10:51:18 -04:00 committed by Jim Harris
parent b1f76f512f
commit 269efef886
11 changed files with 11 additions and 1045 deletions

View File

@ -130,22 +130,22 @@ DEPDIRS-bdev_split := $(BDEV_DEPS)
DEPDIRS-bdev_aio := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_compress := $(BDEV_DEPS_THREAD) reduce
DEPDIRS-bdev_crypto := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_delay := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_iscsi := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_null := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_nvme = $(BDEV_DEPS_THREAD) nvme
DEPDIRS-bdev_ocf := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_passthru := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_pmem := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_raid := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_rbd := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_uring := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_zone_block := $(BDEV_DEPS_THREAD)
ifeq ($(OS),Linux)
DEPDIRS-bdev_ftl := $(BDEV_DEPS_THREAD) ftl
endif
DEPDIRS-bdev_crypto := $(BDEV_DEPS_CONF_THREAD)
DEPDIRS-bdev_iscsi := $(BDEV_DEPS_CONF_THREAD)
DEPDIRS-bdev_nvme = $(BDEV_DEPS_CONF_THREAD) nvme
DEPDIRS-bdev_ocf := $(BDEV_DEPS_CONF_THREAD)
DEPDIRS-bdev_pmem := $(BDEV_DEPS_CONF_THREAD)
DEPDIRS-bdev_raid := $(BDEV_DEPS_CONF_THREAD)
DEPDIRS-bdev_rbd := $(BDEV_DEPS_CONF_THREAD)
DEPDIRS-bdev_virtio := $(BDEV_DEPS_CONF_THREAD) virtio
# module/event

View File

@ -34,7 +34,6 @@
#include "vbdev_crypto.h"
#include "spdk/env.h"
#include "spdk/conf.h"
#include "spdk/endian.h"
#include "spdk/thread.h"
#include "spdk/bdev_module.h"
@ -1550,72 +1549,12 @@ create_crypto_disk(const char *bdev_name, const char *vbdev_name,
static int
vbdev_crypto_init(void)
{
struct spdk_conf_section *sp = NULL;
const char *conf_bdev_name = NULL;
const char *conf_vbdev_name = NULL;
const char *crypto_pmd = NULL;
int i;
int rc = 0;
const char *key = NULL;
const char *cipher = NULL;
const char *key2 = NULL;
/* Fully configure both SW and HW drivers. */
rc = vbdev_crypto_init_crypto_drivers();
if (rc) {
SPDK_ERRLOG("Error setting up crypto devices\n");
return rc;
}
sp = spdk_conf_find_section(NULL, "crypto");
if (sp == NULL) {
return 0;
}
for (i = 0; ; i++) {
if (!spdk_conf_section_get_nval(sp, "CRY", i)) {
break;
}
conf_bdev_name = spdk_conf_section_get_nmval(sp, "CRY", i, 0);
if (!conf_bdev_name) {
SPDK_ERRLOG("crypto configuration missing bdev name\n");
return -EINVAL;
}
conf_vbdev_name = spdk_conf_section_get_nmval(sp, "CRY", i, 1);
if (!conf_vbdev_name) {
SPDK_ERRLOG("crypto configuration missing crypto_bdev name\n");
return -EINVAL;
}
key = spdk_conf_section_get_nmval(sp, "CRY", i, 2);
if (!key) {
SPDK_ERRLOG("crypto configuration missing crypto_bdev key\n");
return -EINVAL;
}
SPDK_NOTICELOG("WARNING: You are storing your key in a plain text file!!\n");
crypto_pmd = spdk_conf_section_get_nmval(sp, "CRY", i, 3);
if (!crypto_pmd) {
SPDK_ERRLOG("crypto configuration missing driver type\n");
return -EINVAL;
}
/* These are optional. */
cipher = spdk_conf_section_get_nmval(sp, "CRY", i, 4);
if (cipher == NULL) {
cipher = AES_CBC;
}
key2 = spdk_conf_section_get_nmval(sp, "CRY", i, 5);
/* Note: config file options do not support QAT AES_XTS, use RPC */
rc = vbdev_crypto_insert_name(conf_bdev_name, conf_vbdev_name,
crypto_pmd, key, cipher, key2);
if (rc != 0) {
return rc;
}
}
return rc;
@ -1690,22 +1629,6 @@ vbdev_crypto_get_ctx_size(void)
return sizeof(struct crypto_bdev_io);
}
/* Called when SPDK wants to save the current config of this vbdev module to
* a file.
*/
static void
vbdev_crypto_get_spdk_running_config(FILE *fp)
{
struct bdev_names *names = NULL;
fprintf(fp, "\n[crypto]\n");
TAILQ_FOREACH(names, &g_bdev_names, link) {
fprintf(fp, " crypto %s %s ", names->bdev_name, names->vbdev_name);
fprintf(fp, "\n");
}
fprintf(fp, "\n");
}
static void
vbdev_crypto_base_bdev_hotremove_cb(struct spdk_bdev *bdev_find)
{
@ -1752,7 +1675,6 @@ static const struct spdk_bdev_fn_table vbdev_crypto_fn_table = {
static struct spdk_bdev_module crypto_if = {
.name = "crypto",
.module_init = vbdev_crypto_init,
.config_text = vbdev_crypto_get_spdk_running_config,
.get_ctx_size = vbdev_crypto_get_ctx_size,
.examine_config = vbdev_crypto_examine,
.module_fini = vbdev_crypto_finish,

View File

@ -34,7 +34,6 @@
#include "spdk/stdinc.h"
#include "spdk/bdev.h"
#include "spdk/conf.h"
#include "spdk/env.h"
#include "spdk/fd.h"
#include "spdk/thread.h"
@ -175,7 +174,6 @@ static struct spdk_bdev_module g_iscsi_bdev_module = {
.module_init = bdev_iscsi_initialize,
.module_fini = bdev_iscsi_finish,
.get_ctx_size = bdev_iscsi_get_ctx_size,
.async_init = true,
};
SPDK_BDEV_MODULE_REGISTER(iscsi, &g_iscsi_bdev_module);
@ -884,53 +882,10 @@ delete_iscsi_disk(struct spdk_bdev *bdev, spdk_delete_iscsi_complete cb_fn, void
spdk_bdev_unregister(bdev, cb_fn, cb_arg);
}
static void
bdev_iscsi_initialize_cb(void *cb_arg, struct spdk_bdev *bdev, int status)
{
if (TAILQ_EMPTY(&g_iscsi_conn_req)) {
spdk_bdev_module_init_done(&g_iscsi_bdev_module);
}
}
static int
bdev_iscsi_initialize(void)
{
struct spdk_conf_section *sp;
const char *url, *bdev_name, *initiator_iqn;
int i, rc;
sp = spdk_conf_find_section(NULL, "iSCSI_Initiator");
if (sp == NULL) {
spdk_bdev_module_init_done(&g_iscsi_bdev_module);
return 0;
}
initiator_iqn = spdk_conf_section_get_val(sp, "initiator_name");
if (!initiator_iqn) {
initiator_iqn = DEFAULT_INITIATOR_NAME;
}
rc = 0;
for (i = 0; (url = spdk_conf_section_get_nmval(sp, "URL", i, 0)) != NULL; i++) {
bdev_name = spdk_conf_section_get_nmval(sp, "URL", i, 1);
if (bdev_name == NULL) {
SPDK_ERRLOG("no bdev name specified for URL %s\n", url);
rc = -EINVAL;
break;
}
rc = create_iscsi_disk(bdev_name, url, initiator_iqn, bdev_iscsi_initialize_cb, NULL);
if (rc) {
break;
}
}
if (i == 0) {
spdk_bdev_module_init_done(&g_iscsi_bdev_module);
}
return rc;
return 0;
}
SPDK_LOG_REGISTER_COMPONENT(iscsi_init)

View File

@ -37,7 +37,6 @@
#include "bdev_ocssd.h"
#include "spdk/config.h"
#include "spdk/conf.h"
#include "spdk/endian.h"
#include "spdk/bdev.h"
#include "spdk/json.h"
@ -53,7 +52,6 @@
#define SPDK_BDEV_NVME_DEFAULT_DELAY_CMD_SUBMIT true
static void bdev_nvme_get_spdk_running_config(FILE *fp);
static int bdev_nvme_config_json(struct spdk_json_write_ctx *w);
struct nvme_bdev_io {
@ -131,7 +129,6 @@ static bool g_nvme_hotplug_enabled = false;
static struct spdk_thread *g_bdev_nvme_init_thread;
static struct spdk_poller *g_hotplug_poller;
static struct spdk_nvme_probe_ctx *g_hotplug_probe_ctx;
static char *g_nvme_hostnqn = NULL;
static void nvme_ctrlr_populate_namespaces(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr,
struct nvme_async_probe_ctx *ctx);
@ -223,7 +220,6 @@ static struct spdk_bdev_module nvme_if = {
.async_fini = true,
.module_init = bdev_nvme_library_init,
.module_fini = bdev_nvme_library_fini,
.config_text = bdev_nvme_get_spdk_running_config,
.config_json = bdev_nvme_config_json,
.get_ctx_size = bdev_nvme_get_ctx_size,
@ -1128,49 +1124,6 @@ hotplug_probe_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,
return true;
}
static bool
probe_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,
struct spdk_nvme_ctrlr_opts *opts)
{
struct nvme_probe_ctx *ctx = cb_ctx;
SPDK_DEBUGLOG(bdev_nvme, "Probing device %s\n", trid->traddr);
if (nvme_bdev_ctrlr_get(trid)) {
SPDK_ERRLOG("A controller with the provided trid (traddr: %s) already exists.\n",
trid->traddr);
return false;
}
if (trid->trtype == SPDK_NVME_TRANSPORT_PCIE) {
bool claim_device = false;
size_t i;
for (i = 0; i < ctx->count; i++) {
if (spdk_nvme_transport_id_compare(trid, &ctx->trids[i]) == 0) {
claim_device = true;
break;
}
}
if (!claim_device) {
SPDK_DEBUGLOG(bdev_nvme, "Not claiming device at %s\n", trid->traddr);
return false;
}
}
if (ctx->hostnqn) {
snprintf(opts->hostnqn, sizeof(opts->hostnqn), "%s", ctx->hostnqn);
}
opts->arbitration_burst = (uint8_t)g_opts.arbitration_burst;
opts->low_priority_weight = (uint8_t)g_opts.low_priority_weight;
opts->medium_priority_weight = (uint8_t)g_opts.medium_priority_weight;
opts->high_priority_weight = (uint8_t)g_opts.high_priority_weight;
return true;
}
static void
nvme_abort_cpl(void *ctx, const struct spdk_nvme_cpl *cpl)
{
@ -2020,215 +1973,13 @@ bdev_nvme_delete(const char *name)
static int
bdev_nvme_library_init(void)
{
struct nvme_bdev_ctrlr *nvme_bdev_ctrlr;
struct spdk_conf_section *sp;
const char *val;
int rc = 0;
int64_t intval = 0;
size_t i;
struct nvme_probe_ctx *probe_ctx = NULL;
int retry_count;
uint32_t local_nvme_num = 0;
int64_t hotplug_period;
bool hotplug_enabled = g_nvme_hotplug_enabled;
g_bdev_nvme_init_thread = spdk_get_thread();
spdk_io_device_register(&g_nvme_bdev_ctrlrs, bdev_nvme_poll_group_create_cb,
bdev_nvme_poll_group_destroy_cb,
sizeof(struct nvme_bdev_poll_group), "bdev_nvme_poll_groups");
sp = spdk_conf_find_section(NULL, "Nvme");
if (sp == NULL) {
goto end;
}
probe_ctx = calloc(1, sizeof(*probe_ctx));
if (probe_ctx == NULL) {
SPDK_ERRLOG("Failed to allocate probe_ctx\n");
rc = -1;
goto end;
}
retry_count = spdk_conf_section_get_intval(sp, "RetryCount");
if (retry_count >= 0) {
g_opts.retry_count = retry_count;
}
val = spdk_conf_section_get_val(sp, "TimeoutUsec");
if (val != NULL) {
intval = spdk_strtoll(val, 10);
if (intval < 0) {
SPDK_ERRLOG("Invalid TimeoutUsec value\n");
rc = -1;
goto end;
}
}
g_opts.timeout_us = intval;
if (g_opts.timeout_us > 0) {
val = spdk_conf_section_get_val(sp, "ActionOnTimeout");
if (val != NULL) {
if (!strcasecmp(val, "Reset")) {
g_opts.action_on_timeout = SPDK_BDEV_NVME_TIMEOUT_ACTION_RESET;
} else if (!strcasecmp(val, "Abort")) {
g_opts.action_on_timeout = SPDK_BDEV_NVME_TIMEOUT_ACTION_ABORT;
}
}
}
intval = spdk_conf_section_get_intval(sp, "AdminPollRate");
if (intval > 0) {
g_opts.nvme_adminq_poll_period_us = intval;
}
intval = spdk_conf_section_get_intval(sp, "IOPollRate");
if (intval > 0) {
g_opts.nvme_ioq_poll_period_us = intval;
}
if (spdk_process_is_primary()) {
hotplug_enabled = spdk_conf_section_get_boolval(sp, "HotplugEnable", false);
}
hotplug_period = spdk_conf_section_get_intval(sp, "HotplugPollRate");
if (hotplug_period < 0) {
hotplug_period = 0;
}
g_nvme_hostnqn = spdk_conf_section_get_val(sp, "HostNQN");
probe_ctx->hostnqn = g_nvme_hostnqn;
g_opts.delay_cmd_submit = spdk_conf_section_get_boolval(sp, "DelayCmdSubmit",
SPDK_BDEV_NVME_DEFAULT_DELAY_CMD_SUBMIT);
for (i = 0; i < NVME_MAX_CONTROLLERS; i++) {
val = spdk_conf_section_get_nmval(sp, "TransportID", i, 0);
if (val == NULL) {
break;
}
rc = spdk_nvme_transport_id_parse(&probe_ctx->trids[i], val);
if (rc < 0) {
SPDK_ERRLOG("Unable to parse TransportID: %s\n", val);
rc = -1;
goto end;
}
rc = spdk_nvme_host_id_parse(&probe_ctx->hostids[i], val);
if (rc < 0) {
SPDK_ERRLOG("Unable to parse HostID: %s\n", val);
rc = -1;
goto end;
}
val = spdk_conf_section_get_nmval(sp, "TransportID", i, 1);
if (val == NULL) {
SPDK_ERRLOG("No name provided for TransportID\n");
rc = -1;
goto end;
}
probe_ctx->names[i] = val;
val = spdk_conf_section_get_nmval(sp, "TransportID", i, 2);
if (val != NULL) {
rc = spdk_nvme_prchk_flags_parse(&probe_ctx->prchk_flags[i], val);
if (rc < 0) {
SPDK_ERRLOG("Unable to parse prchk: %s\n", val);
rc = -1;
goto end;
}
}
probe_ctx->count++;
if (probe_ctx->trids[i].trtype != SPDK_NVME_TRANSPORT_PCIE) {
struct spdk_nvme_ctrlr *ctrlr;
struct spdk_nvme_ctrlr_opts opts;
if (nvme_bdev_ctrlr_get(&probe_ctx->trids[i])) {
SPDK_ERRLOG("A controller with the provided trid (traddr: %s) already exists.\n",
probe_ctx->trids[i].traddr);
rc = -1;
goto end;
}
if (probe_ctx->trids[i].subnqn[0] == '\0') {
SPDK_ERRLOG("Need to provide subsystem nqn\n");
rc = -1;
goto end;
}
spdk_nvme_ctrlr_get_default_ctrlr_opts(&opts, sizeof(opts));
opts.transport_retry_count = g_opts.retry_count;
if (probe_ctx->hostnqn != NULL) {
snprintf(opts.hostnqn, sizeof(opts.hostnqn), "%s", probe_ctx->hostnqn);
}
if (probe_ctx->hostids[i].hostaddr[0] != '\0') {
snprintf(opts.src_addr, sizeof(opts.src_addr), "%s", probe_ctx->hostids[i].hostaddr);
}
if (probe_ctx->hostids[i].hostsvcid[0] != '\0') {
snprintf(opts.src_svcid, sizeof(opts.src_svcid), "%s", probe_ctx->hostids[i].hostsvcid);
}
ctrlr = spdk_nvme_connect(&probe_ctx->trids[i], &opts, sizeof(opts));
if (ctrlr == NULL) {
SPDK_ERRLOG("Unable to connect to provided trid (traddr: %s)\n",
probe_ctx->trids[i].traddr);
rc = -1;
goto end;
}
rc = nvme_bdev_ctrlr_create(ctrlr, probe_ctx->names[i], &probe_ctx->trids[i], 0);
if (rc) {
goto end;
}
nvme_bdev_ctrlr = nvme_bdev_ctrlr_get(&probe_ctx->trids[i]);
if (!nvme_bdev_ctrlr) {
SPDK_ERRLOG("Failed to find new NVMe controller\n");
rc = -ENODEV;
goto end;
}
nvme_ctrlr_populate_namespaces(nvme_bdev_ctrlr, NULL);
} else {
local_nvme_num++;
}
}
if (local_nvme_num > 0) {
/* used to probe local NVMe device */
if (spdk_nvme_probe(NULL, probe_ctx, probe_cb, attach_cb, remove_cb)) {
rc = -1;
goto end;
}
for (i = 0; i < probe_ctx->count; i++) {
if (probe_ctx->trids[i].trtype != SPDK_NVME_TRANSPORT_PCIE) {
continue;
}
if (!nvme_bdev_ctrlr_get(&probe_ctx->trids[i])) {
SPDK_ERRLOG("NVMe SSD \"%s\" could not be found.\n", probe_ctx->trids[i].traddr);
SPDK_ERRLOG("Check PCIe BDF and that it is attached to UIO/VFIO driver.\n");
}
}
}
rc = bdev_nvme_set_hotplug(hotplug_enabled, hotplug_period, NULL, NULL);
if (rc) {
SPDK_ERRLOG("Failed to setup hotplug (%d): %s", rc, spdk_strerror(rc));
rc = -1;
}
end:
free(probe_ctx);
return rc;
return 0;
}
static void
@ -2913,107 +2664,6 @@ bdev_nvme_abort(struct nvme_bdev_ns *nvme_ns, struct nvme_io_channel *nvme_ch,
return rc;
}
static void
bdev_nvme_get_spdk_running_config(FILE *fp)
{
struct nvme_bdev_ctrlr *nvme_bdev_ctrlr;
fprintf(fp, "\n[Nvme]");
fprintf(fp, "\n"
"# NVMe Device Whitelist\n"
"# Users may specify which NVMe devices to claim by their transport id.\n"
"# See spdk_nvme_transport_id_parse() in spdk/nvme.h for the correct format.\n"
"# The second argument is the assigned name, which can be referenced from\n"
"# other sections in the configuration file. For NVMe devices, a namespace\n"
"# is automatically appended to each name in the format <YourName>nY, where\n"
"# Y is the NSID (starts at 1).\n");
TAILQ_FOREACH(nvme_bdev_ctrlr, &g_nvme_bdev_ctrlrs, tailq) {
const char *trtype;
const char *prchk_flags;
trtype = spdk_nvme_transport_id_trtype_str(nvme_bdev_ctrlr->connected_trid->trtype);
if (!trtype) {
continue;
}
if (nvme_bdev_ctrlr->connected_trid->trtype == SPDK_NVME_TRANSPORT_PCIE) {
fprintf(fp, "TransportID \"trtype:%s traddr:%s\" %s\n",
trtype,
nvme_bdev_ctrlr->connected_trid->traddr, nvme_bdev_ctrlr->name);
} else {
const char *adrfam;
adrfam = spdk_nvme_transport_id_adrfam_str(nvme_bdev_ctrlr->connected_trid->adrfam);
prchk_flags = spdk_nvme_prchk_flags_str(nvme_bdev_ctrlr->prchk_flags);
if (adrfam) {
fprintf(fp, "TransportID \"trtype:%s adrfam:%s traddr:%s trsvcid:%s subnqn:%s\" %s",
trtype, adrfam,
nvme_bdev_ctrlr->connected_trid->traddr, nvme_bdev_ctrlr->connected_trid->trsvcid,
nvme_bdev_ctrlr->connected_trid->subnqn, nvme_bdev_ctrlr->name);
} else {
fprintf(fp, "TransportID \"trtype:%s traddr:%s trsvcid:%s subnqn:%s\" %s",
trtype,
nvme_bdev_ctrlr->connected_trid->traddr, nvme_bdev_ctrlr->connected_trid->trsvcid,
nvme_bdev_ctrlr->connected_trid->subnqn, nvme_bdev_ctrlr->name);
}
if (prchk_flags) {
fprintf(fp, " \"%s\"\n", prchk_flags);
} else {
fprintf(fp, "\n");
}
}
}
fprintf(fp, "\n"
"# The number of attempts per I/O when an I/O fails. Do not include\n"
"# this key to get the default behavior.\n");
fprintf(fp, "RetryCount %d\n", g_opts.retry_count);
fprintf(fp, "\n"
"# Timeout for each command, in microseconds. If 0, don't track timeouts.\n");
fprintf(fp, "TimeoutUsec %"PRIu64"\n", g_opts.timeout_us);
fprintf(fp, "\n"
"# Action to take on command time out. Only valid when Timeout is greater\n"
"# than 0. This may be 'Reset' to reset the controller, 'Abort' to abort\n"
"# the command, or 'None' to just print a message but do nothing.\n"
"# Admin command timeouts will always result in a reset.\n");
switch (g_opts.action_on_timeout) {
case SPDK_BDEV_NVME_TIMEOUT_ACTION_NONE:
fprintf(fp, "ActionOnTimeout None\n");
break;
case SPDK_BDEV_NVME_TIMEOUT_ACTION_RESET:
fprintf(fp, "ActionOnTimeout Reset\n");
break;
case SPDK_BDEV_NVME_TIMEOUT_ACTION_ABORT:
fprintf(fp, "ActionOnTimeout Abort\n");
break;
}
fprintf(fp, "\n"
"# Set how often the admin queue is polled for asynchronous events.\n"
"# Units in microseconds.\n");
fprintf(fp, "AdminPollRate %"PRIu64"\n", g_opts.nvme_adminq_poll_period_us);
fprintf(fp, "IOPollRate %" PRIu64"\n", g_opts.nvme_ioq_poll_period_us);
fprintf(fp, "\n"
"# Disable handling of hotplug (runtime insert and remove) events,\n"
"# users can set to Yes if want to enable it.\n"
"# Default: No\n");
fprintf(fp, "HotplugEnable %s\n", g_nvme_hotplug_enabled ? "Yes" : "No");
fprintf(fp, "\n"
"# Set how often the hotplug is processed for insert and remove events."
"# Units in microseconds.\n");
fprintf(fp, "HotplugPollRate %"PRIu64"\n", g_nvme_hotplug_poll_period_us);
if (g_nvme_hostnqn) {
fprintf(fp, "HostNQN %s\n", g_nvme_hostnqn);
}
fprintf(fp, "DelayCmdSubmit %s\n", g_opts.delay_cmd_submit ? "True" : "False");
fprintf(fp, "\n");
}
static void
nvme_ctrlr_config_json_standard_namespace(struct spdk_json_write_ctx *w, struct nvme_bdev_ns *ns)
{

View File

@ -42,7 +42,6 @@
#include "vbdev_ocf.h"
#include "spdk/bdev_module.h"
#include "spdk/conf.h"
#include "spdk/thread.h"
#include "spdk/string.h"
#include "spdk/log.h"
@ -1260,10 +1259,7 @@ error_free:
static int
vbdev_ocf_init(void)
{
const char *vbdev_name, *modename, *cache_line_size, *cache_name, *core_name;
struct spdk_conf_section *sp;
int status;
uint64_t cache_line_size_uint64;
status = vbdev_ocf_ctx_init();
if (status) {
@ -1278,53 +1274,6 @@ vbdev_ocf_init(void)
return status;
}
sp = spdk_conf_find_section(NULL, "OCF");
if (sp == NULL) {
return 0;
}
for (int i = 0; ; i++) {
if (!spdk_conf_section_get_nval(sp, "OCF", i)) {
break;
}
vbdev_name = spdk_conf_section_get_nmval(sp, "OCF", i, 0);
if (!vbdev_name) {
SPDK_ERRLOG("No vbdev name specified\n");
continue;
}
modename = spdk_conf_section_get_nmval(sp, "OCF", i, 1);
if (!modename) {
SPDK_ERRLOG("No modename specified for OCF vbdev '%s'\n", vbdev_name);
continue;
}
cache_line_size = spdk_conf_section_get_nmval(sp, "OCF", i, 2);
if (!cache_line_size) {
SPDK_ERRLOG("No cache line size specified for OCF vbdev '%s'\n", vbdev_name);
continue;
}
cache_line_size_uint64 = strtoull(cache_line_size, NULL, 10);
cache_name = spdk_conf_section_get_nmval(sp, "OCF", i, 3);
if (!cache_name) {
SPDK_ERRLOG("No cache device specified for OCF vbdev '%s'\n", vbdev_name);
continue;
}
core_name = spdk_conf_section_get_nmval(sp, "OCF", i, 4);
if (!core_name) {
SPDK_ERRLOG("No core devices specified for OCF vbdev '%s'\n", vbdev_name);
continue;
}
status = init_vbdev(vbdev_name, modename, cache_line_size_uint64, cache_name, core_name, false);
if (status) {
SPDK_ERRLOG("Config initialization failed with code: %d\n", status);
}
}
return status;
}
@ -1797,7 +1746,6 @@ static struct spdk_bdev_module ocf_if = {
.module_init = vbdev_ocf_init,
.fini_start = fini_start,
.module_fini = vbdev_ocf_module_fini,
.config_text = NULL,
.get_ctx_size = vbdev_ocf_get_ctx_size,
.examine_config = vbdev_ocf_examine,
.examine_disk = vbdev_ocf_examine_disk,

View File

@ -31,7 +31,6 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "spdk/conf.h"
#include "spdk/string.h"
#include "spdk/likely.h"
#include "spdk/util.h"
@ -401,41 +400,6 @@ delete_pmem_disk(struct spdk_bdev *bdev, spdk_delete_pmem_complete cb_fn, void *
spdk_bdev_unregister(bdev, cb_fn, cb_arg);
}
static void
bdev_pmem_read_conf(void)
{
struct spdk_conf_section *sp;
struct spdk_bdev *bdev;
const char *pmem_file;
const char *bdev_name;
int i;
sp = spdk_conf_find_section(NULL, "Pmem");
if (sp == NULL) {
return;
}
for (i = 0; ; i++) {
if (!spdk_conf_section_get_nval(sp, "Blk", i)) {
break;
}
pmem_file = spdk_conf_section_get_nmval(sp, "Blk", i, 0);
if (pmem_file == NULL) {
SPDK_ERRLOG("Pmem: missing filename\n");
continue;
}
bdev_name = spdk_conf_section_get_nmval(sp, "Blk", i, 1);
if (bdev_name == NULL) {
SPDK_ERRLOG("Pmem: missing bdev name\n");
continue;
}
create_pmem_disk(pmem_file, bdev_name, &bdev);
}
}
static int
bdev_pmem_initialize(void)
{
@ -452,8 +416,6 @@ bdev_pmem_initialize(void)
#endif
spdk_io_device_register(&g_pmem_disks, bdev_pmem_create_cb, bdev_pmem_destroy_cb, 0, "pmem_bdev");
bdev_pmem_read_conf();
return 0;
}

View File

@ -34,7 +34,6 @@
#include "bdev_raid.h"
#include "spdk/env.h"
#include "spdk/thread.h"
#include "spdk/conf.h"
#include "spdk/log.h"
#include "spdk/string.h"
#include "spdk/util.h"
@ -904,154 +903,6 @@ raid_bdev_level_to_str(enum raid_level level)
return "";
}
/*
* brief:
* raid_bdev_parse_raid is used to parse the raid bdev from config file based on
* pre-defined raid bdev format in config file.
* Format of config file:
* [RAID1]
* Name raid1
* StripSize 64
* NumDevices 2
* RaidLevel 0
* Devices Nvme0n1 Nvme1n1
*
* [RAID2]
* Name raid2
* StripSize 64
* NumDevices 3
* RaidLevel 0
* Devices Nvme2n1 Nvme3n1 Nvme4n1
*
* params:
* conf_section - pointer to config section
* returns:
* 0 - success
* non zero - failure
*/
static int
raid_bdev_parse_raid(struct spdk_conf_section *conf_section)
{
const char *raid_name;
uint32_t strip_size;
uint8_t num_base_bdevs;
const char *raid_level_str;
enum raid_level level;
const char *base_bdev_name;
struct raid_bdev_config *raid_cfg;
int rc, i, val;
raid_name = spdk_conf_section_get_val(conf_section, "Name");
if (raid_name == NULL) {
SPDK_ERRLOG("raid_name is null\n");
return -EINVAL;
}
val = spdk_conf_section_get_intval(conf_section, "StripSize");
if (val < 0) {
return -EINVAL;
}
strip_size = val;
val = spdk_conf_section_get_intval(conf_section, "NumDevices");
if (val < 0) {
return -EINVAL;
}
num_base_bdevs = val;
raid_level_str = spdk_conf_section_get_val(conf_section, "RaidLevel");
if (raid_level_str == NULL) {
SPDK_ERRLOG("Missing RaidLevel\n");
return -EINVAL;
}
level = raid_bdev_parse_raid_level(raid_level_str);
if (level == INVALID_RAID_LEVEL) {
SPDK_ERRLOG("Invalid RaidLevel\n");
return -EINVAL;
}
SPDK_DEBUGLOG(bdev_raid, "%s %" PRIu32 " %u %u\n",
raid_name, strip_size, num_base_bdevs, level);
rc = raid_bdev_config_add(raid_name, strip_size, num_base_bdevs, level,
&raid_cfg);
if (rc != 0) {
SPDK_ERRLOG("Failed to add raid bdev config\n");
return rc;
}
for (i = 0; true; i++) {
base_bdev_name = spdk_conf_section_get_nmval(conf_section, "Devices", 0, i);
if (base_bdev_name == NULL) {
break;
}
if (i >= num_base_bdevs) {
raid_bdev_config_cleanup(raid_cfg);
SPDK_ERRLOG("Number of devices mentioned is more than count\n");
return -EINVAL;
}
rc = raid_bdev_config_add_base_bdev(raid_cfg, base_bdev_name, i);
if (rc != 0) {
raid_bdev_config_cleanup(raid_cfg);
SPDK_ERRLOG("Failed to add base bdev to raid bdev config\n");
return rc;
}
}
if (i != raid_cfg->num_base_bdevs) {
raid_bdev_config_cleanup(raid_cfg);
SPDK_ERRLOG("Number of devices mentioned is less than count\n");
return -EINVAL;
}
rc = raid_bdev_create(raid_cfg);
if (rc != 0) {
raid_bdev_config_cleanup(raid_cfg);
SPDK_ERRLOG("Failed to create raid bdev\n");
return rc;
}
rc = raid_bdev_add_base_devices(raid_cfg);
if (rc != 0) {
SPDK_ERRLOG("Failed to add any base bdev to raid bdev\n");
/* Config is not removed in this case. */
}
return 0;
}
/*
* brief:
* raid_bdev_parse_config is used to find the raid bdev config section and parse it
* Format of config file:
* params:
* none
* returns:
* 0 - success
* non zero - failure
*/
static int
raid_bdev_parse_config(void)
{
int ret;
struct spdk_conf_section *conf_section;
conf_section = spdk_conf_first_section(NULL);
while (conf_section != NULL) {
if (spdk_conf_section_match_prefix(conf_section, "RAID")) {
ret = raid_bdev_parse_raid(conf_section);
if (ret < 0) {
SPDK_ERRLOG("Unable to parse raid bdev section\n");
return ret;
}
}
conf_section = spdk_conf_next_section(conf_section);
}
return 0;
}
/*
* brief:
* raid_bdev_fini_start is called when bdev layer is starting the
@ -1099,48 +950,6 @@ raid_bdev_get_ctx_size(void)
return sizeof(struct raid_bdev_io);
}
/*
* brief:
* raid_bdev_get_running_config is used to get the configuration options.
*
* params:
* fp - The pointer to a file that will be written to the configuration options.
* returns:
* none
*/
static void
raid_bdev_get_running_config(FILE *fp)
{
struct raid_bdev *raid_bdev;
struct raid_base_bdev_info *base_info;
int index = 1;
TAILQ_FOREACH(raid_bdev, &g_raid_bdev_configured_list, state_link) {
fprintf(fp,
"\n"
"[RAID%d]\n"
" Name %s\n"
" StripSize %" PRIu32 "\n"
" NumDevices %u\n"
" RaidLevel %s\n",
index, raid_bdev->bdev.name, raid_bdev->strip_size_kb,
raid_bdev->num_base_bdevs,
raid_bdev_level_to_str(raid_bdev->level));
fprintf(fp,
" Devices ");
RAID_FOR_EACH_BASE_BDEV(raid_bdev, base_info) {
if (base_info->bdev) {
fprintf(fp,
"%s ",
base_info->bdev->name);
}
}
fprintf(fp,
"\n");
index++;
}
}
/*
* brief:
* raid_bdev_can_claim_bdev is the function to check if this base_bdev can be
@ -1187,7 +996,6 @@ static struct spdk_bdev_module g_raid_if = {
.module_fini = raid_bdev_exit,
.get_ctx_size = raid_bdev_get_ctx_size,
.examine_config = raid_bdev_examine,
.config_text = raid_bdev_get_running_config,
.async_init = false,
.async_fini = false,
};
@ -1205,18 +1013,6 @@ SPDK_BDEV_MODULE_REGISTER(raid, &g_raid_if)
static int
raid_bdev_init(void)
{
int ret;
/* Parse config file for raids */
ret = raid_bdev_parse_config();
if (ret < 0) {
SPDK_ERRLOG("raid bdev init failed parsing\n");
raid_bdev_free();
return ret;
}
SPDK_DEBUGLOG(bdev_raid, "raid_bdev_init completed successfully\n");
return 0;
}

View File

@ -40,7 +40,6 @@
#include <sys/eventfd.h>
#include <sys/epoll.h>
#include "spdk/conf.h"
#include "spdk/env.h"
#include "spdk/bdev.h"
#include "spdk/thread.h"
@ -835,77 +834,10 @@ bdev_rbd_group_destroy_cb(void *io_device, void *ctx_buf)
static int
bdev_rbd_library_init(void)
{
int i, rc = 0;
const char *val;
const char *pool_name;
const char *rbd_name;
struct spdk_bdev *bdev;
uint32_t block_size;
long int tmp;
struct spdk_conf_section *sp;
spdk_io_device_register(&rbd_if, bdev_rbd_group_create_cb, bdev_rbd_group_destroy_cb,
sizeof(struct bdev_rbd_group_channel),
"bdev_rbd_poll_groups");
sizeof(struct bdev_rbd_group_channel), "bdev_rbd_poll_groups");
sp = spdk_conf_find_section(NULL, "Ceph");
if (sp == NULL) {
/*
* Ceph section not found. Do not initialize any rbd LUNS.
*/
goto end;
}
/* Init rbd block devices */
for (i = 0; ; i++) {
val = spdk_conf_section_get_nval(sp, "Ceph", i);
if (val == NULL) {
break;
}
/* get the Rbd_pool name */
pool_name = spdk_conf_section_get_nmval(sp, "Ceph", i, 0);
if (pool_name == NULL) {
SPDK_ERRLOG("Ceph%d: rbd pool name needs to be provided\n", i);
rc = -1;
goto end;
}
rbd_name = spdk_conf_section_get_nmval(sp, "Ceph", i, 1);
if (rbd_name == NULL) {
SPDK_ERRLOG("Ceph%d: format error\n", i);
rc = -1;
goto end;
}
val = spdk_conf_section_get_nmval(sp, "Ceph", i, 2);
if (val == NULL) {
block_size = 512; /* default value */
} else {
tmp = spdk_strtol(val, 10);
if (tmp <= 0) {
SPDK_ERRLOG("Invalid block size\n");
rc = -1;
goto end;
} else if (tmp & 0x1ff) {
SPDK_ERRLOG("current block_size = %ld, it should be multiple of 512\n",
tmp);
rc = -1;
goto end;
}
block_size = (uint32_t)tmp;
}
/* TODO(?): user_id and rbd config values */
rc = bdev_rbd_create(&bdev, NULL, NULL, pool_name, NULL, rbd_name, block_size);
if (rc) {
goto end;
}
}
end:
return rc;
return 0;
}
static void

View File

@ -142,12 +142,6 @@ mock_rte_lcore_count(void)
/* SPDK stubs */
DEFINE_STUB(spdk_bdev_queue_io_wait, int, (struct spdk_bdev *bdev, struct spdk_io_channel *ch,
struct spdk_bdev_io_wait_entry *entry), 0);
DEFINE_STUB(spdk_conf_find_section, struct spdk_conf_section *,
(struct spdk_conf *cp, const char *name), NULL);
DEFINE_STUB(spdk_conf_section_get_nval, char *,
(struct spdk_conf_section *sp, const char *key, int idx), NULL);
DEFINE_STUB(spdk_conf_section_get_nmval, char *,
(struct spdk_conf_section *sp, const char *key, int idx1, int idx2), NULL);
DEFINE_STUB_V(spdk_bdev_module_list_add, (struct spdk_bdev_module *bdev_module));
DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *g_bdev_io));
DEFINE_STUB_V(spdk_bdev_io_put_aux_buf, (struct spdk_bdev_io *bdev_io, void *aux_buf));

View File

@ -40,13 +40,6 @@
#include "bdev/pmem/bdev_pmem.c"
DEFINE_STUB(spdk_conf_find_section, struct spdk_conf_section *,
(struct spdk_conf *cp, const char *name), NULL);
DEFINE_STUB(spdk_conf_section_get_nval, char *,
(struct spdk_conf_section *sp, const char *key, int idx), NULL);
DEFINE_STUB(spdk_conf_section_get_nmval, char *,
(struct spdk_conf_section *sp, const char *key, int idx1, int idx2), NULL);
static struct spdk_bdev_module *g_bdev_pmem_module;
static int g_bdev_module_cnt;

View File

@ -464,75 +464,6 @@ spdk_bdev_module_release_bdev(struct spdk_bdev *bdev)
bdev->internal.claim_module = NULL;
}
struct spdk_conf_section *
spdk_conf_first_section(struct spdk_conf *cp)
{
if (g_config_level_create) {
return (void *) 0x1;
}
return NULL;
}
bool
spdk_conf_section_match_prefix(const struct spdk_conf_section *sp, const char *name_prefix)
{
if (g_config_level_create) {
return true;
}
return false;
}
char *
spdk_conf_section_get_val(struct spdk_conf_section *sp, const char *key)
{
struct rpc_bdev_raid_create *req = g_rpc_req;
if (g_config_level_create) {
if (strcmp(key, "Name") == 0) {
return req->name;
} else if (strcmp(key, "RaidLevel") == 0) {
return (char *)raid_bdev_level_to_str(req->level);
}
}
return NULL;
}
int
spdk_conf_section_get_intval(struct spdk_conf_section *sp, const char *key)
{
struct rpc_bdev_raid_create *req = g_rpc_req;
if (g_config_level_create) {
if (strcmp(key, "StripSize") == 0) {
return req->strip_size_kb;
} else if (strcmp(key, "NumDevices") == 0) {
return req->base_bdevs.num_base_bdevs;
}
}
return 0;
}
char *
spdk_conf_section_get_nmval(struct spdk_conf_section *sp, const char *key, int idx1, int idx2)
{
struct rpc_bdev_raid_create *req = g_rpc_req;
if (g_config_level_create) {
if (strcmp(key, "Devices") == 0) {
if (idx2 >= g_max_base_drives) {
return NULL;
}
return req->base_bdevs.base_bdevs[idx2];
}
}
return NULL;
}
int
spdk_bdev_module_claim_bdev(struct spdk_bdev *bdev, struct spdk_bdev_desc *desc,
struct spdk_bdev_module *module)
@ -1101,16 +1032,6 @@ create_raid_bdev_create_req(struct rpc_bdev_raid_create *r, const char *raid_nam
g_test_multi_raids = 0;
}
static void
create_raid_bdev_create_config(struct rpc_bdev_raid_create *r, const char *raid_name,
uint8_t bbdev_start_idx, bool create_base_bdev)
{
create_test_req(r, raid_name, bbdev_start_idx, create_base_bdev);
g_config_level_create = 1;
g_test_multi_raids = 0;
}
static void
free_test_req(struct rpc_bdev_raid_create *r)
{
@ -2063,111 +1984,6 @@ test_io_type_supported(void)
CU_ASSERT(raid_bdev_io_type_supported(NULL, SPDK_BDEV_IO_TYPE_INVALID) == false);
}
static void
test_create_raid_from_config(void)
{
struct rpc_bdev_raid_create req;
struct spdk_bdev *bdev;
struct rpc_bdev_raid_delete destroy_req;
bool can_claim;
struct raid_bdev_config *raid_cfg;
uint8_t base_bdev_slot;
set_globals();
create_raid_bdev_create_config(&req, "raid1", 0, true);
CU_ASSERT(raid_bdev_init() == 0);
verify_raid_config_present("raid1", true);
verify_raid_bdev_present("raid1", true);
TAILQ_FOREACH(bdev, &g_bdev_list, internal.link) {
raid_bdev_examine(bdev);
}
can_claim = raid_bdev_can_claim_bdev("Invalid", &raid_cfg, &base_bdev_slot);
CU_ASSERT(can_claim == false);
verify_raid_config(&req, true);
verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE);
create_raid_bdev_delete_req(&destroy_req, "raid1", 0);
rpc_bdev_raid_delete(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
raid_bdev_exit();
free_test_req(&req);
base_bdevs_cleanup();
reset_globals();
}
static void
test_create_raid_from_config_invalid_params(void)
{
struct rpc_bdev_raid_create req;
set_globals();
create_raid_bdev_create_config(&req, "raid1", 0, true);
free(req.name);
req.name = NULL;
CU_ASSERT(raid_bdev_init() != 0);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
req.strip_size_kb = 1234;
CU_ASSERT(raid_bdev_init() != 0);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
req.level = INVALID_RAID_LEVEL;
CU_ASSERT(raid_bdev_init() != 0);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
req.level = INVALID_RAID_LEVEL;
CU_ASSERT(raid_bdev_init() != 0);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
req.base_bdevs.num_base_bdevs++;
CU_ASSERT(raid_bdev_init() != 0);
req.base_bdevs.num_base_bdevs--;
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
req.base_bdevs.num_base_bdevs--;
CU_ASSERT(raid_bdev_init() != 0);
req.base_bdevs.num_base_bdevs++;
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
if (g_max_base_drives > 1) {
create_raid_bdev_create_config(&req, "raid1", 0, false);
snprintf(req.base_bdevs.base_bdevs[g_max_base_drives - 1], 15, "%s", "Nvme0n1");
CU_ASSERT(raid_bdev_init() != 0);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
}
raid_bdev_exit();
base_bdevs_cleanup();
reset_globals();
}
static void
test_raid_json_dump_info(void)
{
@ -2254,8 +2070,6 @@ int main(int argc, char **argv)
CU_ADD_TEST(suite, test_multi_raid_no_io);
CU_ADD_TEST(suite, test_multi_raid_with_io);
CU_ADD_TEST(suite, test_io_type_supported);
CU_ADD_TEST(suite, test_create_raid_from_config);
CU_ADD_TEST(suite, test_create_raid_from_config_invalid_params);
CU_ADD_TEST(suite, test_raid_json_dump_info);
CU_ADD_TEST(suite, test_context_size);
CU_ADD_TEST(suite, test_raid_level_conversions);