ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

subsystem/iscsi: remove legacy config support

Browse Source 
This patch removes legacy config support in iscsi subsystem.
All options through the legacy config are already reflected in JSON.

Following RPCs are corresponding to removed legacy config sections:
Initiator groups - iscsi_create_initiator_group and iscsi_initiator_group_*
Subsystem options - iscsi_set_options
Portal groups - iscsi_create_portal_group
Target node - iscsi_create_target_node and iscsi_target_node_*

Signed-off-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Change-Id: I11326a84d4d580b19db422b8522198eea5a5be0d
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/4747
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Community-CI: Broadcom CI
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
This commit is contained in:
Tomasz Zawadzki 2020-10-15 05:54:15 -04:00
parent 2842056073
commit 6d86242dc5
14 changed files with 6 additions and 1172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/iscsi/Makefile
View File

@ -34,7 +34,7 @@
SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
SO_VER := 3
SO_VER := 4
SO_MINOR := 0
CFLAGS += -I$(SPDK_ROOT_DIR)/lib

188
lib/iscsi/init_grp.c
View File

@ -325,121 +325,6 @@ cleanup:
return -1;
}
/* Read spdk iscsi target's config file and create initiator group */
static int
iscsi_parse_init_grp(struct spdk_conf_section *sp)
{
int i, rc = 0;
const char *val = NULL;
int num_initiator_names;
int num_initiator_masks;
char **initiators = NULL, **netmasks = NULL;
int tag = spdk_conf_section_get_num(sp);
SPDK_DEBUGLOG(iscsi, "add initiator group %d\n", tag);
val = spdk_conf_section_get_val(sp, "Comment");
if (val != NULL) {
SPDK_DEBUGLOG(iscsi, "Comment %s\n", val);
}
/* counts number of definitions */
for (i = 0; ; i++) {
val = spdk_conf_section_get_nval(sp, "InitiatorName", i);
if (val == NULL) {
break;
}
}
if (i == 0) {
SPDK_ERRLOG("num_initiator_names = 0\n");
return -EINVAL;
}
num_initiator_names = i;
if (num_initiator_names > MAX_INITIATOR) {
SPDK_ERRLOG("%d > MAX_INITIATOR\n", num_initiator_names);
return -E2BIG;
}
for (i = 0; ; i++) {
val = spdk_conf_section_get_nval(sp, "Netmask", i);
if (val == NULL) {
break;
}
}
if (i == 0) {
SPDK_ERRLOG("num_initiator_mask = 0\n");
return -EINVAL;
}
num_initiator_masks = i;
if (num_initiator_masks > MAX_NETMASK) {
SPDK_ERRLOG("%d > MAX_NETMASK\n", num_initiator_masks);
return -E2BIG;
}
initiators = calloc(num_initiator_names, sizeof(char *));
if (!initiators) {
SPDK_ERRLOG("calloc() failed for temp initiator name array\n");
return -ENOMEM;
}
for (i = 0; i < num_initiator_names; i++) {
val = spdk_conf_section_get_nval(sp, "InitiatorName", i);
if (!val) {
SPDK_ERRLOG("InitiatorName %d not found\n", i);
rc = -EINVAL;
goto cleanup;
}
SPDK_DEBUGLOG(iscsi, "InitiatorName %s\n", val);
initiators[i] = strdup(val);
if (!initiators[i]) {
SPDK_ERRLOG("strdup() failed for temp initiator name\n");
rc = -ENOMEM;
goto cleanup;
}
}
netmasks = calloc(num_initiator_masks, sizeof(char *));
if (!netmasks) {
SPDK_ERRLOG("malloc() failed for portal group\n");
rc = -ENOMEM;
goto cleanup;
}
for (i = 0; i < num_initiator_masks; i++) {
val = spdk_conf_section_get_nval(sp, "Netmask", i);
if (!val) {
SPDK_ERRLOG("Netmask %d not found\n", i);
rc = -EINVAL;
goto cleanup;
}
SPDK_DEBUGLOG(iscsi, "Netmask %s\n", val);
netmasks[i] = strdup(val);
if (!netmasks[i]) {
SPDK_ERRLOG("strdup() failed for temp initiator mask\n");
rc = -ENOMEM;
goto cleanup;
}
}
rc = iscsi_init_grp_create_from_initiator_list(tag,
num_initiator_names, initiators, num_initiator_masks, netmasks);
cleanup:
if (initiators) {
for (i = 0; i < num_initiator_names; i++) {
if (initiators[i]) {
free(initiators[i]);
}
}
free(initiators);
}
if (netmasks) {
for (i = 0; i < num_initiator_masks; i++) {
if (netmasks[i]) {
free(netmasks[i]);
}
}
free(netmasks);
}
return rc;
}
int
iscsi_init_grp_register(struct spdk_iscsi_init_grp *ig)
{
@ -621,30 +506,6 @@ iscsi_init_grp_find_by_tag(int tag)
return NULL;
}
int
iscsi_parse_init_grps(void)
{
struct spdk_conf_section *sp;
int rc;
sp = spdk_conf_first_section(NULL);
while (sp != NULL) {
if (spdk_conf_section_match_prefix(sp, "InitiatorGroup")) {
if (spdk_conf_section_get_num(sp) == 0) {
SPDK_ERRLOG("Group 0 is invalid\n");
return -1;
}
rc = iscsi_parse_init_grp(sp);
if (rc < 0) {
SPDK_ERRLOG("parse_init_group() failed\n");
return -1;
}
}
sp = spdk_conf_next_section(sp);
}
return 0;
}
void
iscsi_init_grps_destroy(void)
{
@ -676,55 +537,6 @@ iscsi_init_grp_unregister(int tag)
return NULL;
}
static const char *initiator_group_section = \
"\n"
"# Users must change the InitiatorGroup section(s) to match the IP\n"
"# addresses and initiator configuration in their environment.\n"
"# Netmask can be used to specify a single IP address or a range of IP addresses\n"
"# Netmask 192.168.1.20 <== single IP address\n"
"# Netmask 192.168.1.0/24 <== IP range 192.168.1.*\n";
#define INITIATOR_GROUP_TMPL \
"[InitiatorGroup%d]\n" \
" Comment \"Initiator Group%d\"\n"
#define INITIATOR_TMPL \
" InitiatorName "
#define NETMASK_TMPL \
" Netmask "
void
iscsi_init_grps_config_text(FILE *fp)
{
struct spdk_iscsi_init_grp *ig;
struct spdk_iscsi_initiator_name *iname;
struct spdk_iscsi_initiator_netmask *imask;
/* Create initiator group section */
fprintf(fp, "%s", initiator_group_section);
/* Dump initiator groups */
TAILQ_FOREACH(ig, &g_iscsi.ig_head, tailq) {
if (NULL == ig) { continue; }
fprintf(fp, INITIATOR_GROUP_TMPL, ig->tag, ig->tag);
/* Dump initiators */
fprintf(fp, INITIATOR_TMPL);
TAILQ_FOREACH(iname, &ig->initiator_head, tailq) {
fprintf(fp, "%s ", iname->name);
}
fprintf(fp, "\n");
/* Dump netmasks */
fprintf(fp, NETMASK_TMPL);
TAILQ_FOREACH(imask, &ig->netmask_head, tailq) {
fprintf(fp, "%s ", imask->mask);
}
fprintf(fp, "\n");
}
}
static void
iscsi_init_grp_info_json(struct spdk_iscsi_init_grp *ig,
struct spdk_json_write_ctx *w)

2
lib/iscsi/init_grp.h
View File

@ -35,7 +35,6 @@
#ifndef SPDK_INIT_GRP_H
#define SPDK_INIT_GRP_H
#include "spdk/conf.h"
#include "iscsi/iscsi.h"
#include "iscsi/conn.h"
@ -75,7 +74,6 @@ struct spdk_iscsi_init_grp *iscsi_init_grp_find_by_tag(int tag);
void iscsi_init_grp_destroy(struct spdk_iscsi_init_grp *ig);
int iscsi_parse_init_grps(void);
void iscsi_init_grps_destroy(void);
void iscsi_init_grps_config_text(FILE *fp);
void iscsi_init_grps_info_json(struct spdk_json_write_ctx *w);
void iscsi_init_grps_config_json(struct spdk_json_write_ctx *w);
#endif /* SPDK_INIT_GRP_H */

1
lib/iscsi/iscsi.h
View File

@ -407,7 +407,6 @@ void spdk_iscsi_init(spdk_iscsi_init_cb cb_fn, void *cb_arg);
typedef void (*spdk_iscsi_fini_cb)(void *arg);
void spdk_iscsi_fini(spdk_iscsi_fini_cb cb_fn, void *cb_arg);
void shutdown_iscsi_conns_done(void);
void spdk_iscsi_config_text(FILE *fp);
void spdk_iscsi_config_json(struct spdk_json_write_ctx *w);
struct spdk_iscsi_opts *iscsi_opts_alloc(void);

279
lib/iscsi/iscsi_subsystem.c
View File

@ -56,73 +56,6 @@ static void *g_init_cb_arg = NULL;
static spdk_iscsi_fini_cb g_fini_cb_fn;
static void *g_fini_cb_arg;
#define ISCSI_CONFIG_TMPL \
"[iSCSI]\n" \
" # node name (not include optional part)\n" \
" # Users can optionally change this to fit their environment.\n" \
" NodeBase \"%s\"\n" \
"\n" \
" # files\n" \
" %s %s\n" \
"\n" \
" # socket I/O timeout sec. (polling is infinity)\n" \
" Timeout %d\n" \
"\n" \
" # authentication information for discovery session\n" \
" DiscoveryAuthMethod %s\n" \
" DiscoveryAuthGroup %s\n" \
"\n" \
" MaxSessions %d\n" \
" MaxConnectionsPerSession %d\n" \
" MaxConnections %d\n" \
" MaxQueueDepth %d\n" \
"\n" \
" # iSCSI initial parameters negotiate with initiators\n" \
" # NOTE: incorrect values might crash\n" \
" DefaultTime2Wait %d\n" \
" DefaultTime2Retain %d\n" \
"\n" \
" FirstBurstLength %d\n" \
" ImmediateData %s\n" \
" ErrorRecoveryLevel %d\n" \
"\n"
static void
iscsi_globals_config_text(FILE *fp)
{
const char *authmethod = "None";
char authgroup[32] = "None";
if (NULL == fp) {
return;
}
if (g_iscsi.require_chap) {
authmethod = "CHAP";
} else if (g_iscsi.mutual_chap) {
authmethod = "CHAP Mutual";
} else if (!g_iscsi.disable_chap) {
authmethod = "Auto";
}
if (g_iscsi.chap_group) {
snprintf(authgroup, sizeof(authgroup), "AuthGroup%d", g_iscsi.chap_group);
}
fprintf(fp, ISCSI_CONFIG_TMPL,
g_iscsi.nodebase,
g_iscsi.authfile ? "AuthFile" : "",
g_iscsi.authfile ? g_iscsi.authfile : "",
g_iscsi.timeout, authmethod, authgroup,
g_iscsi.MaxSessions, g_iscsi.MaxConnectionsPerSession,
g_iscsi.MaxConnections,
g_iscsi.MaxQueueDepth,
g_iscsi.DefaultTime2Wait, g_iscsi.DefaultTime2Retain,
g_iscsi.FirstBurstLength,
(g_iscsi.ImmediateData) ? "Yes" : "No",
g_iscsi.ErrorRecoveryLevel);
}
#define ISCSI_DATA_BUFFER_ALIGNMENT (0x1000)
#define ISCSI_DATA_BUFFER_MASK (ISCSI_DATA_BUFFER_ALIGNMENT - 1)
@ -485,151 +418,6 @@ iscsi_opts_copy(struct spdk_iscsi_opts *src)
return dst;
}
static int
iscsi_read_config_file_params(struct spdk_conf_section *sp,
struct spdk_iscsi_opts *opts)
{
const char *val;
int MaxSessions;
int MaxConnectionsPerSession;
int MaxQueueDepth;
int DefaultTime2Wait;
int DefaultTime2Retain;
int FirstBurstLength;
int ErrorRecoveryLevel;
int timeout;
int nopininterval;
const char *ag_tag;
int ag_tag_i;
int i;
val = spdk_conf_section_get_val(sp, "Comment");
if (val != NULL) {
SPDK_DEBUGLOG(iscsi, "Comment %s\n", val);
}
val = spdk_conf_section_get_val(sp, "AuthFile");
if (val != NULL) {
opts->authfile = strdup(val);
if (!opts->authfile) {
SPDK_ERRLOG("strdup() failed for AuthFile\n");
return -ENOMEM;
}
}
val = spdk_conf_section_get_val(sp, "NodeBase");
if (val != NULL) {
opts->nodebase = strdup(val);
if (!opts->nodebase) {
free(opts->authfile);
SPDK_ERRLOG("strdup() failed for NodeBase\n");
return -ENOMEM;
}
}
MaxSessions = spdk_conf_section_get_intval(sp, "MaxSessions");
if (MaxSessions >= 0) {
opts->MaxSessions = MaxSessions;
}
MaxConnectionsPerSession = spdk_conf_section_get_intval(sp, "MaxConnectionsPerSession");
if (MaxConnectionsPerSession >= 0) {
opts->MaxConnectionsPerSession = MaxConnectionsPerSession;
}
MaxQueueDepth = spdk_conf_section_get_intval(sp, "MaxQueueDepth");
if (MaxQueueDepth >= 0) {
opts->MaxQueueDepth = MaxQueueDepth;
}
DefaultTime2Wait = spdk_conf_section_get_intval(sp, "DefaultTime2Wait");
if (DefaultTime2Wait >= 0) {
opts->DefaultTime2Wait = DefaultTime2Wait;
}
DefaultTime2Retain = spdk_conf_section_get_intval(sp, "DefaultTime2Retain");
if (DefaultTime2Retain >= 0) {
opts->DefaultTime2Retain = DefaultTime2Retain;
}
FirstBurstLength = spdk_conf_section_get_intval(sp, "FirstBurstLength");
if (FirstBurstLength >= 0) {
opts->FirstBurstLength = FirstBurstLength;
}
opts->ImmediateData = spdk_conf_section_get_boolval(sp, "ImmediateData",
opts->ImmediateData);
/* This option is only for test.
* If AllowDuplicateIsid is enabled, it allows different connections carrying
* TSIH=0 login the target within the same session.
*/
opts->AllowDuplicateIsid = spdk_conf_section_get_boolval(sp, "AllowDuplicateIsid",
opts->AllowDuplicateIsid);
ErrorRecoveryLevel = spdk_conf_section_get_intval(sp, "ErrorRecoveryLevel");
if (ErrorRecoveryLevel >= 0) {
opts->ErrorRecoveryLevel = ErrorRecoveryLevel;
}
timeout = spdk_conf_section_get_intval(sp, "Timeout");
if (timeout >= 0) {
opts->timeout = timeout;
}
nopininterval = spdk_conf_section_get_intval(sp, "NopInInterval");
if (nopininterval >= 0) {
opts->nopininterval = nopininterval;
}
val = spdk_conf_section_get_val(sp, "DiscoveryAuthMethod");
if (val != NULL) {
for (i = 0; ; i++) {
val = spdk_conf_section_get_nmval(sp, "DiscoveryAuthMethod", 0, i);
if (val == NULL) {
break;
}
if (strcasecmp(val, "CHAP") == 0) {
opts->require_chap = true;
} else if (strcasecmp(val, "Mutual") == 0) {
opts->require_chap = true;
opts->mutual_chap = true;
} else if (strcasecmp(val, "Auto") == 0) {
opts->disable_chap = false;
opts->require_chap = false;
opts->mutual_chap = false;
} else if (strcasecmp(val, "None") == 0) {
opts->disable_chap = true;
opts->require_chap = false;
opts->mutual_chap = false;
} else {
SPDK_ERRLOG("unknown CHAP mode %s\n", val);
}
}
if (opts->mutual_chap && !opts->require_chap) {
free(opts->authfile);
free(opts->nodebase);
SPDK_ERRLOG("CHAP must set to be required when using mutual CHAP.\n");
return -EINVAL;
}
}
val = spdk_conf_section_get_val(sp, "DiscoveryAuthGroup");
if (val != NULL) {
ag_tag = val;
if (strcasecmp(ag_tag, "None") == 0) {
opts->chap_group = 0;
} else {
if (strncasecmp(ag_tag, "AuthGroup",
strlen("AuthGroup")) != 0
|| sscanf(ag_tag, "%*[^0-9]%d", &ag_tag_i) != 1
|| ag_tag_i == 0) {
SPDK_ERRLOG("invalid auth group %s, ignoring\n", ag_tag);
} else {
opts->chap_group = ag_tag_i;
}
}
}
return 0;
}
static int
iscsi_opts_verify(struct spdk_iscsi_opts *opts)
{
@ -718,36 +506,6 @@ iscsi_opts_verify(struct spdk_iscsi_opts *opts)
return 0;
}
static int
iscsi_parse_options(struct spdk_iscsi_opts **popts)
{
struct spdk_iscsi_opts *opts;
struct spdk_conf_section *sp;
int rc;
opts = iscsi_opts_alloc();
if (!opts) {
SPDK_ERRLOG("iscsi_opts_alloc_failed() failed\n");
return -ENOMEM;
}
/* Process parameters */
SPDK_DEBUGLOG(iscsi, "iscsi_read_config_file_parmas\n");
sp = spdk_conf_find_section(NULL, "iSCSI");
if (sp != NULL) {
rc = iscsi_read_config_file_params(sp, opts);
if (rc != 0) {
free(opts);
SPDK_ERRLOG("iscsi_read_config_file_params() failed\n");
return rc;
}
}
*popts = opts;
return 0;
}
static int
iscsi_set_global_params(struct spdk_iscsi_opts *opts)
{
@ -1136,10 +894,10 @@ iscsi_initialize_global_params(void)
int rc;
if (!g_spdk_iscsi_opts) {
rc = iscsi_parse_options(&g_spdk_iscsi_opts);
if (rc != 0) {
SPDK_ERRLOG("iscsi_parse_options() failed\n");
return rc;
g_spdk_iscsi_opts = iscsi_opts_alloc();
if (!g_spdk_iscsi_opts) {
SPDK_ERRLOG("iscsi_opts_alloc_failed() failed\n");
return -ENOMEM;
}
}
@ -1169,24 +927,7 @@ iscsi_init_complete(int rc)
static void
iscsi_parse_configuration(void)
{
int rc;
rc = iscsi_parse_portal_grps();
if (rc < 0) {
SPDK_ERRLOG("iscsi_parse_portal_grps() failed\n");
goto end;
}
rc = iscsi_parse_init_grps();
if (rc < 0) {
SPDK_ERRLOG("iscsi_parse_init_grps() failed\n");
goto end;
}
rc = iscsi_parse_tgt_nodes();
if (rc < 0) {
SPDK_ERRLOG("iscsi_parse_tgt_nodes() failed\n");
}
int rc = 0;
if (g_iscsi.authfile != NULL) {
if (access(g_iscsi.authfile, R_OK) == 0) {
@ -1200,7 +941,6 @@ iscsi_parse_configuration(void)
}
}
end:
iscsi_init_complete(rc);
}
@ -1462,15 +1202,6 @@ shutdown_iscsi_conns_done(void)
spdk_for_each_channel(&g_iscsi, _iscsi_fini_thread, NULL, _iscsi_fini_dev_unreg);
}
void
spdk_iscsi_config_text(FILE *fp)
{
iscsi_globals_config_text(fp);
iscsi_portal_grps_config_text(fp);
iscsi_init_grps_config_text(fp);
iscsi_tgt_nodes_config_text(fp);
}
void
iscsi_opts_info_json(struct spdk_json_write_ctx *w)
{

189
lib/iscsi/portal_grp.c
View File

@ -212,64 +212,6 @@ iscsi_portal_close(struct spdk_iscsi_portal *p)
}
}
static int
iscsi_parse_portal(const char *portalstring, struct spdk_iscsi_portal **ip)
{
char host[MAX_PORTAL_ADDR + 1] = {};
char port[MAX_PORTAL_PORT + 1] = {};
int len;
const char *p;
if (portalstring == NULL) {
SPDK_ERRLOG("portal error\n");
return -EINVAL;
}
/* IP address */
if (portalstring[0] == '[') {
/* IPv6 */
p = strchr(portalstring + 1, ']');
if (p == NULL) {
SPDK_ERRLOG("portal error\n");
return -EINVAL;
}
p++;
} else {
/* IPv4 */
p = strchr(portalstring, ':');
if (p == NULL) {
p = portalstring + strlen(portalstring);
}
}
len = p - portalstring;
if (len > MAX_PORTAL_ADDR) {
return -EINVAL;
}
memcpy(host, portalstring, len);
host[len] = '\0';
/* Port number (IPv4 and IPv6 are the same) */
if (p[0] == '\0') {
snprintf(port, MAX_PORTAL_PORT, "%d", DEFAULT_PORT);
} else {
p++;
len = strlen(p);
if (len > MAX_PORTAL_PORT) {
return -EINVAL;
}
memcpy(port, p, len);
port[len] = '\0';
}
*ip = iscsi_portal_create(host, port);
if (!*ip) {
return -EINVAL;
}
return 0;
}
int
iscsi_parse_redirect_addr(struct sockaddr_storage *sa,
const char *host, const char *port)
@ -408,69 +350,6 @@ iscsi_portal_grp_set_chap_params(struct spdk_iscsi_portal_grp *pg,
return 0;
}
static int
iscsi_parse_portal_grp(struct spdk_conf_section *sp)
{
struct spdk_iscsi_portal_grp *pg;
struct spdk_iscsi_portal *p;
const char *val;
char *label, *portal;
int i = 0, rc = 0;
SPDK_DEBUGLOG(iscsi, "add portal group (from config file) %d\n",
spdk_conf_section_get_num(sp));
val = spdk_conf_section_get_val(sp, "Comment");
if (val != NULL) {
SPDK_DEBUGLOG(iscsi, "Comment %s\n", val);
}
pg = iscsi_portal_grp_create(spdk_conf_section_get_num(sp), false);
if (!pg) {
SPDK_ERRLOG("portal group malloc error (%s)\n", spdk_conf_section_get_name(sp));
return -1;
}
for (i = 0; ; i++) {
label = spdk_conf_section_get_nmval(sp, "Portal", i, 0);
portal = spdk_conf_section_get_nmval(sp, "Portal", i, 1);
if (label == NULL || portal == NULL) {
break;
}
rc = iscsi_parse_portal(portal, &p);
if (rc < 0) {
SPDK_ERRLOG("parse portal error (%s)\n", portal);
goto error;
}
SPDK_DEBUGLOG(iscsi,
"RIndex=%d, Host=%s, Port=%s, Tag=%d\n",
i, p->host, p->port, spdk_conf_section_get_num(sp));
iscsi_portal_grp_add_portal(pg, p);
}
rc = iscsi_portal_grp_open(pg);
if (rc != 0) {
SPDK_ERRLOG("portal_grp_open failed\n");
goto error;
}
/* Add portal group to the end of the pg list */
rc = iscsi_portal_grp_register(pg);
if (rc != 0) {
SPDK_ERRLOG("register portal failed\n");
goto error;
}
return 0;
error:
iscsi_portal_grp_release(pg);
return -1;
}
struct spdk_iscsi_portal_grp *
iscsi_portal_grp_find_by_tag(int tag)
{
@ -485,32 +364,6 @@ iscsi_portal_grp_find_by_tag(int tag)
return NULL;
}
int
iscsi_parse_portal_grps(void)
{
int rc = 0;
struct spdk_conf_section *sp;
sp = spdk_conf_first_section(NULL);
while (sp != NULL) {
if (spdk_conf_section_match_prefix(sp, "PortalGroup")) {
if (spdk_conf_section_get_num(sp) == 0) {
SPDK_ERRLOG("Group 0 is invalid\n");
return -1;
}
/* Build portal group from cfg section PortalGroup */
rc = iscsi_parse_portal_grp(sp);
if (rc < 0) {
SPDK_ERRLOG("parse_portal_group() failed\n");
return -1;
}
}
sp = spdk_conf_next_section(sp);
}
return 0;
}
void
iscsi_portal_grps_destroy(void)
{
@ -590,48 +443,6 @@ iscsi_portal_grp_release(struct spdk_iscsi_portal_grp *pg)
iscsi_portal_grp_destroy(pg);
}
static const char *portal_group_section = \
"\n"
"# Users must change the PortalGroup section(s) to match the IP addresses\n"
"# for their environment.\n"
"# PortalGroup sections define which network portals the iSCSI target\n"
"# will use to listen for incoming connections. These are also used to\n"
"# determine which targets are accessible over each portal group.\n"
"# Up to 1024 Portal directives are allowed. These define the network\n"
"# portals of the portal group. The user must specify a IP address\n"
"# for each network portal, and may optionally specify a port.\n"
"# If the port is omitted, 3260 will be used\n"
"# Syntax:\n"
"# Portal <Name> <IP address>[:<port>]\n";
#define PORTAL_GROUP_TMPL \
"[PortalGroup%d]\n" \
" Comment \"Portal%d\"\n"
#define PORTAL_TMPL \
" Portal DA1 %s:%s\n"
void
iscsi_portal_grps_config_text(FILE *fp)
{
struct spdk_iscsi_portal *p = NULL;
struct spdk_iscsi_portal_grp *pg = NULL;
/* Create portal group section */
fprintf(fp, "%s", portal_group_section);
/* Dump portal groups */
TAILQ_FOREACH(pg, &g_iscsi.pg_head, tailq) {
if (NULL == pg) { continue; }
fprintf(fp, PORTAL_GROUP_TMPL, pg->tag, pg->tag);
/* Dump portals */
TAILQ_FOREACH(p, &pg->head, per_pg_tailq) {
if (NULL == p) { continue; }
fprintf(fp, PORTAL_TMPL, p->host, p->port);
}
}
}
static void
iscsi_portal_grp_info_json(struct spdk_iscsi_portal_grp *pg,
struct spdk_json_write_ctx *w)

1
lib/iscsi/portal_grp.h
View File

@ -96,7 +96,6 @@ int iscsi_portal_grp_set_chap_params(struct spdk_iscsi_portal_grp *pg,
bool mutual_chap, int32_t chap_group);
void iscsi_portal_grp_close_all(void);
void iscsi_portal_grps_config_text(FILE *fp);
void iscsi_portal_grps_info_json(struct spdk_json_write_ctx *w);
void iscsi_portal_grps_config_json(struct spdk_json_write_ctx *w);

1
lib/iscsi/spdk_iscsi.map
View File

@ -4,7 +4,6 @@
# Functions used by other SPDK libraries
spdk_iscsi_init;
spdk_iscsi_fini;
spdk_iscsi_config_text;
spdk_iscsi_config_json;
local: *;

347
lib/iscsi/tgt_node.c
View File

@ -1111,255 +1111,6 @@ struct spdk_iscsi_tgt_node *iscsi_tgt_node_construct(int target_index,
return target;
}
static int
iscsi_parse_tgt_node(struct spdk_conf_section *sp)
{
char buf[MAX_TMPBUF];
struct spdk_iscsi_tgt_node *target;
int pg_tag_list[MAX_TARGET_MAP], ig_tag_list[MAX_TARGET_MAP];
int num_target_maps;
const char *alias, *pg_tag, *ig_tag;
const char *ag_tag;
const char *val, *name;
int target_num, chap_group, pg_tag_i, ig_tag_i;
bool header_digest, data_digest;
bool disable_chap, require_chap, mutual_chap;
int i;
int lun_id_list[SPDK_SCSI_DEV_MAX_LUN];
const char *bdev_name_list[SPDK_SCSI_DEV_MAX_LUN];
int num_luns, queue_depth;
target_num = spdk_conf_section_get_num(sp);
SPDK_DEBUGLOG(iscsi, "add unit %d\n", target_num);
data_digest = false;
header_digest = false;
name = spdk_conf_section_get_val(sp, "TargetName");
if (name == NULL) {
SPDK_ERRLOG("tgt_node%d: TargetName not found\n", target_num);
return -1;
}
alias = spdk_conf_section_get_val(sp, "TargetAlias");
/* Setup initiator and portal group mapping */
val = spdk_conf_section_get_val(sp, "Mapping");
if (val == NULL) {
/* no map */
SPDK_ERRLOG("tgt_node%d: no Mapping\n", target_num);
return -1;
}
for (i = 0; i < MAX_TARGET_MAP; i++) {
val = spdk_conf_section_get_nmval(sp, "Mapping", i, 0);
if (val == NULL) {
break;
}
pg_tag = spdk_conf_section_get_nmval(sp, "Mapping", i, 0);
ig_tag = spdk_conf_section_get_nmval(sp, "Mapping", i, 1);
if (pg_tag == NULL || ig_tag == NULL) {
SPDK_ERRLOG("tgt_node%d: mapping error\n", target_num);
return -1;
}
if (strncasecmp(pg_tag, "PortalGroup",
strlen("PortalGroup")) != 0
|| sscanf(pg_tag, "%*[^0-9]%d", &pg_tag_i) != 1) {
SPDK_ERRLOG("tgt_node%d: mapping portal error\n", target_num);
return -1;
}
if (strncasecmp(ig_tag, "InitiatorGroup",
strlen("InitiatorGroup")) != 0
|| sscanf(ig_tag, "%*[^0-9]%d", &ig_tag_i) != 1) {
SPDK_ERRLOG("tgt_node%d: mapping initiator error\n", target_num);
return -1;
}
if (pg_tag_i < 1 || ig_tag_i < 1) {
SPDK_ERRLOG("tgt_node%d: invalid group tag\n", target_num);
return -1;
}
pg_tag_list[i] = pg_tag_i;
ig_tag_list[i] = ig_tag_i;
}
num_target_maps = i;
/* Setup AuthMethod */
val = spdk_conf_section_get_val(sp, "AuthMethod");
disable_chap = false;
require_chap = false;
mutual_chap = false;
if (val != NULL) {
for (i = 0; ; i++) {
val = spdk_conf_section_get_nmval(sp, "AuthMethod", 0, i);
if (val == NULL) {
break;
}
if (strcasecmp(val, "CHAP") == 0) {
require_chap = true;
} else if (strcasecmp(val, "Mutual") == 0) {
mutual_chap = true;
} else if (strcasecmp(val, "Auto") == 0) {
disable_chap = false;
require_chap = false;
mutual_chap = false;
} else if (strcasecmp(val, "None") == 0) {
disable_chap = true;
require_chap = false;
mutual_chap = false;
} else {
SPDK_ERRLOG("tgt_node%d: unknown auth\n", target_num);
return -1;
}
}
if (mutual_chap && !require_chap) {
SPDK_ERRLOG("tgt_node%d: Mutual but not CHAP\n", target_num);
return -1;
}
}
if (disable_chap) {
SPDK_DEBUGLOG(iscsi, "AuthMethod None\n");
} else if (!require_chap) {
SPDK_DEBUGLOG(iscsi, "AuthMethod Auto\n");
} else {
SPDK_DEBUGLOG(iscsi, "AuthMethod CHAP %s\n",
mutual_chap ? "Mutual" : "");
}
val = spdk_conf_section_get_val(sp, "AuthGroup");
if (val == NULL) {
chap_group = 0;
} else {
ag_tag = val;
if (strcasecmp(ag_tag, "None") == 0) {
chap_group = 0;
} else {
if (strncasecmp(ag_tag, "AuthGroup",
strlen("AuthGroup")) != 0
|| sscanf(ag_tag, "%*[^0-9]%d", &chap_group) != 1) {
SPDK_ERRLOG("tgt_node%d: auth group error\n", target_num);
return -1;
}
if (chap_group == 0) {
SPDK_ERRLOG("tgt_node%d: invalid auth group 0\n", target_num);
return -1;
}
}
}
if (chap_group == 0) {
SPDK_DEBUGLOG(iscsi, "AuthGroup None\n");
} else {
SPDK_DEBUGLOG(iscsi, "AuthGroup AuthGroup%d\n", chap_group);
}
val = spdk_conf_section_get_val(sp, "UseDigest");
if (val != NULL) {
for (i = 0; ; i++) {
val = spdk_conf_section_get_nmval(sp, "UseDigest", 0, i);
if (val == NULL) {
break;
}
if (strcasecmp(val, "Header") == 0) {
header_digest = true;
} else if (strcasecmp(val, "Data") == 0) {
data_digest = true;
} else if (strcasecmp(val, "Auto") == 0) {
header_digest = false;
data_digest = false;
} else {
SPDK_ERRLOG("tgt_node%d: unknown digest\n", target_num);
return -1;
}
}
}
if (!header_digest && !data_digest) {
SPDK_DEBUGLOG(iscsi, "UseDigest Auto\n");
} else {
SPDK_DEBUGLOG(iscsi, "UseDigest %s %s\n",
header_digest ? "Header" : "",
data_digest ? "Data" : "");
}
val = spdk_conf_section_get_val(sp, "QueueDepth");
if (val == NULL) {
queue_depth = g_iscsi.MaxQueueDepth;
} else {
queue_depth = (int) strtol(val, NULL, 10);
}
num_luns = 0;
for (i = 0; i < SPDK_SCSI_DEV_MAX_LUN; i++) {
snprintf(buf, sizeof(buf), "LUN%d", i);
val = spdk_conf_section_get_val(sp, buf);
if (val == NULL) {
continue;
}
bdev_name_list[num_luns] = val;
lun_id_list[num_luns] = i;
num_luns++;
}
if (num_luns == 0) {
SPDK_ERRLOG("tgt_node%d: No LUN specified for target %s.\n", target_num, name);
return -1;
}
target = iscsi_tgt_node_construct(target_num, name, alias,
pg_tag_list, ig_tag_list, num_target_maps,
bdev_name_list, lun_id_list, num_luns, queue_depth,
disable_chap, require_chap, mutual_chap, chap_group,
header_digest, data_digest);
if (target == NULL) {
SPDK_ERRLOG("tgt_node%d: add_iscsi_target_node error\n", target_num);
return -1;
}
for (i = 0; i < SPDK_SCSI_DEV_MAX_LUN; i++) {
struct spdk_scsi_lun *lun = spdk_scsi_dev_get_lun(target->dev, i);
if (lun) {
SPDK_INFOLOG(iscsi, "device %d: LUN%d %s\n",
spdk_scsi_dev_get_id(target->dev),
spdk_scsi_lun_get_id(lun),
spdk_scsi_lun_get_bdev_name(lun));
}
}
return 0;
}
int iscsi_parse_tgt_nodes(void)
{
struct spdk_conf_section *sp;
int rc;
SPDK_DEBUGLOG(iscsi, "iscsi_parse_tgt_nodes\n");
sp = spdk_conf_first_section(NULL);
while (sp != NULL) {
if (spdk_conf_section_match_prefix(sp, "TargetNode")) {
int tag = spdk_conf_section_get_num(sp);
if (tag > SPDK_TN_TAG_MAX) {
SPDK_ERRLOG("tag %d is invalid\n", tag);
return -1;
}
rc = iscsi_parse_tgt_node(sp);
if (rc < 0) {
SPDK_ERRLOG("spdk_iscsi_parse_tgt_node() failed\n");
return -1;
}
}
sp = spdk_conf_next_section(sp);
}
return 0;
}
void
iscsi_shutdown_tgt_nodes(void)
{
@ -1509,104 +1260,6 @@ iscsi_tgt_node_set_chap_params(struct spdk_iscsi_tgt_node *target,
return 0;
}
static const char *target_nodes_section = \
"\n"
"# Users should change the TargetNode section(s) below to match the\n"
"# desired iSCSI target node configuration.\n"
"# TargetName, Mapping, LUN0 are minimum required\n";
#define TARGET_NODE_TMPL \
"[TargetNode%d]\n" \
" Comment \"Target%d\"\n" \
" TargetName %s\n" \
" TargetAlias \"%s\"\n"
#define TARGET_NODE_PGIG_MAPPING_TMPL \
" Mapping PortalGroup%d InitiatorGroup%d\n"
#define TARGET_NODE_AUTH_TMPL \
" AuthMethod %s\n" \
" AuthGroup %s\n" \
" UseDigest %s\n"
#define TARGET_NODE_QD_TMPL \
" QueueDepth %d\n\n"
#define TARGET_NODE_LUN_TMPL \
" LUN%d %s\n"
void
iscsi_tgt_nodes_config_text(FILE *fp)
{
int l = 0;
struct spdk_scsi_dev *dev = NULL;
struct spdk_iscsi_tgt_node *target = NULL;
struct spdk_iscsi_pg_map *pg_map;
struct spdk_iscsi_ig_map *ig_map;
/* Create target nodes section */
fprintf(fp, "%s", target_nodes_section);
TAILQ_FOREACH(target, &g_iscsi.target_head, tailq) {
int idx;
const char *authmethod = "None";
char authgroup[32] = "None";
const char *usedigest = "Auto";
dev = target->dev;
if (NULL == dev) { continue; }
idx = target->num;
fprintf(fp, TARGET_NODE_TMPL, idx, idx, target->name, spdk_scsi_dev_get_name(dev));
TAILQ_FOREACH(pg_map, &target->pg_map_head, tailq) {
TAILQ_FOREACH(ig_map, &pg_map->ig_map_head, tailq) {
fprintf(fp, TARGET_NODE_PGIG_MAPPING_TMPL,
pg_map->pg->tag,
ig_map->ig->tag);
}
}
if (target->disable_chap) {
authmethod = "None";
} else if (!target->require_chap) {
authmethod = "Auto";
} else if (target->mutual_chap) {
authmethod = "CHAP Mutual";
} else {
authmethod = "CHAP";
}
if (target->chap_group > 0) {
snprintf(authgroup, sizeof(authgroup), "AuthGroup%d", target->chap_group);
}
if (target->header_digest) {
usedigest = "Header";
} else if (target->data_digest) {
usedigest = "Data";
}
fprintf(fp, TARGET_NODE_AUTH_TMPL,
authmethod, authgroup, usedigest);
for (l = 0; l < SPDK_SCSI_DEV_MAX_LUN; l++) {
struct spdk_scsi_lun *lun = spdk_scsi_dev_get_lun(dev, l);
if (!lun) {
continue;
}
fprintf(fp, TARGET_NODE_LUN_TMPL,
spdk_scsi_lun_get_id(lun),
spdk_scsi_lun_get_bdev_name(lun));
}
fprintf(fp, TARGET_NODE_QD_TMPL,
target->queue_depth);
}
}
static void
iscsi_tgt_node_info_json(struct spdk_iscsi_tgt_node *target,
struct spdk_json_write_ctx *w)

3
lib/iscsi/tgt_node.h
View File

@ -97,8 +97,6 @@ struct spdk_iscsi_tgt_node {
void *destruct_cb_arg;
};
int iscsi_parse_tgt_nodes(void);
void iscsi_shutdown_tgt_nodes(void);
void iscsi_shutdown_tgt_node_by_name(const char *target_name,
iscsi_tgt_node_destruct_cb cb_fn, void *cb_arg);
@ -147,7 +145,6 @@ int iscsi_tgt_node_add_lun(struct spdk_iscsi_tgt_node *target,
int iscsi_tgt_node_set_chap_params(struct spdk_iscsi_tgt_node *target,
bool disable_chap, bool require_chap,
bool mutual_chap, int32_t chap_group);
void iscsi_tgt_nodes_config_text(FILE *fp);
void iscsi_tgt_nodes_info_json(struct spdk_json_write_ctx *w);
void iscsi_tgt_nodes_config_json(struct spdk_json_write_ctx *w);
#endif /* SPDK_ISCSI_TGT_NODE_H_ */

1
module/event/subsystems/iscsi/iscsi.c
View File

@ -71,7 +71,6 @@ static struct spdk_subsystem g_spdk_subsystem_iscsi = {
.name = "iscsi",
.init = iscsi_subsystem_init,
.fini = iscsi_subsystem_fini,
.config = spdk_iscsi_config_text,
.write_config_json = iscsi_subsystem_config_json,
};

53
test/unit/lib/iscsi/init_grp.c/init_grp_ut.c
View File

@ -51,58 +51,6 @@ test_setup(void)
return 0;
}
static void
create_from_config_file_cases(void)
{
struct spdk_conf *config;
struct spdk_conf_section *sp;
char section_name[64];
int section_index;
int rc;
config = spdk_conf_allocate();
rc = spdk_conf_read(config, config_file);
CU_ASSERT(rc == 0);
section_index = 0;
while (true) {
snprintf(section_name, sizeof(section_name), "IG_Valid%d", section_index);
sp = spdk_conf_find_section(config, section_name);
if (sp == NULL) {
break;
}
rc = iscsi_parse_init_grp(sp);
CU_ASSERT(rc == 0);
iscsi_init_grps_destroy();
section_index++;
}
section_index = 0;
while (true) {
snprintf(section_name, sizeof(section_name), "IG_Invalid%d", section_index);
sp = spdk_conf_find_section(config, section_name);
if (sp == NULL) {
break;
}
rc = iscsi_parse_init_grp(sp);
CU_ASSERT(rc != 0);
iscsi_init_grps_destroy();
section_index++;
}
spdk_conf_free(config);
}
static void
create_initiator_group_success_case(void)
{
@ -647,7 +595,6 @@ main(int argc, char **argv)
suite = CU_add_suite("init_grp_suite", test_setup, NULL);
CU_ADD_TEST(suite, create_from_config_file_cases);
CU_ADD_TEST(suite, create_initiator_group_success_case);
CU_ADD_TEST(suite, find_initiator_group_success_case);
CU_ADD_TEST(suite, register_initiator_group_twice_case);

81
test/unit/lib/iscsi/portal_grp.c/portal_grp_ut.c
View File

@ -137,83 +137,6 @@ portal_create_twice_case(void)
CU_ASSERT(TAILQ_EMPTY(&g_iscsi.portal_head));
}
static void
parse_portal_ipv4_normal_case(void)
{
const char *string = "192.168.2.0:3260";
const char *host_str = "192.168.2.0";
const char *port_str = "3260";
struct spdk_iscsi_portal *p = NULL;
int rc;
rc = iscsi_parse_portal(string, &p);
CU_ASSERT(rc == 0);
SPDK_CU_ASSERT_FATAL(p != NULL);
CU_ASSERT(strcmp(p->host, host_str) == 0);
CU_ASSERT(strcmp(p->port, port_str) == 0);
iscsi_portal_destroy(p);
CU_ASSERT(TAILQ_EMPTY(&g_iscsi.portal_head));
}
static void
parse_portal_ipv6_normal_case(void)
{
const char *string = "[2001:ad6:1234::]:3260";
const char *host_str = "[2001:ad6:1234::]";
const char *port_str = "3260";
struct spdk_iscsi_portal *p = NULL;
int rc;
rc = iscsi_parse_portal(string, &p);
CU_ASSERT(rc == 0);
SPDK_CU_ASSERT_FATAL(p != NULL);
CU_ASSERT(strcmp(p->host, host_str) == 0);
CU_ASSERT(strcmp(p->port, port_str) == 0);
iscsi_portal_destroy(p);
CU_ASSERT(TAILQ_EMPTY(&g_iscsi.portal_head));
}
static void
parse_portal_ipv4_skip_port_case(void)
{
const char *string = "192.168.2.0";
const char *host_str = "192.168.2.0";
const char *port_str = "3260";
struct spdk_iscsi_portal *p = NULL;
int rc;
rc = iscsi_parse_portal(string, &p);
CU_ASSERT(rc == 0);
SPDK_CU_ASSERT_FATAL(p != NULL);
CU_ASSERT(strcmp(p->host, host_str) == 0);
CU_ASSERT(strcmp(p->port, port_str) == 0);
iscsi_portal_destroy(p);
CU_ASSERT(TAILQ_EMPTY(&g_iscsi.portal_head));
}
static void
parse_portal_ipv6_skip_port_case(void)
{
const char *string = "[2001:ad6:1234::]";
const char *host_str = "[2001:ad6:1234::]";
const char *port_str = "3260";
struct spdk_iscsi_portal *p = NULL;
int rc;
rc = iscsi_parse_portal(string, &p);
CU_ASSERT(rc == 0);
SPDK_CU_ASSERT_FATAL(p != NULL);
CU_ASSERT(strcmp(p->host, host_str) == 0);
CU_ASSERT(strcmp(p->port, port_str) == 0);
iscsi_portal_destroy(p);
CU_ASSERT(TAILQ_EMPTY(&g_iscsi.portal_head));
}
static void
portal_grp_register_unregister_case(void)
{
@ -402,10 +325,6 @@ main(int argc, char **argv)
CU_ADD_TEST(suite, portal_create_ipv4_wildcard_case);
CU_ADD_TEST(suite, portal_create_ipv6_wildcard_case);
CU_ADD_TEST(suite, portal_create_twice_case);
CU_ADD_TEST(suite, parse_portal_ipv4_normal_case);
CU_ADD_TEST(suite, parse_portal_ipv6_normal_case);
CU_ADD_TEST(suite, parse_portal_ipv4_skip_port_case);
CU_ADD_TEST(suite, parse_portal_ipv6_skip_port_case);
CU_ADD_TEST(suite, portal_grp_register_unregister_case);
CU_ADD_TEST(suite, portal_grp_register_twice_case);
CU_ADD_TEST(suite, portal_grp_add_delete_case);

30
test/unit/lib/iscsi/tgt_node.c/tgt_node_ut.c
View File

@ -147,35 +147,6 @@ add_lun_test_cases(void)
CU_ASSERT(rc == 0);
}
static void
config_file_fail_cases(void)
{
struct spdk_conf *config;
struct spdk_conf_section *sp;
char section_name[64];
int section_index;
int rc;
config = spdk_conf_allocate();
rc = spdk_conf_read(config, config_file);
CU_ASSERT(rc == 0);
section_index = 0;
while (true) {
snprintf(section_name, sizeof(section_name), "Failure%d", section_index);
sp = spdk_conf_find_section(config, section_name);
if (sp == NULL) {
break;
}
rc = iscsi_parse_tgt_node(sp);
CU_ASSERT(rc < 0);
section_index++;
}
spdk_conf_free(config);
}
static void
allow_any_allowed(void)
{
@ -810,7 +781,6 @@ main(int argc, char **argv)
suite = CU_add_suite("iscsi_target_node_suite", NULL, NULL);
CU_ADD_TEST(suite, add_lun_test_cases);
CU_ADD_TEST(suite, config_file_fail_cases);
CU_ADD_TEST(suite, allow_any_allowed);
CU_ADD_TEST(suite, allow_ipv6_allowed);
CU_ADD_TEST(suite, allow_ipv6_denied);