975e48ae8a
Using malloc'ed string for string in iSCSI target has caused scan-build error. Maximum size of initiator address is already defined to be MAX_INITIATOR_ADDR, and hence use fixed size string whose size is MAX_INITIATOR_ADDR + 1 for spdk_iscsi_initiator_mask::mask. This change will reduce the potential malloc failure. Signed-off-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com> Change-Id: Ic39e08986c9377800ce58a1cb5b8401c6b71cf96 Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/459706 Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Ben Walker <benjamin.walker@intel.com> Reviewed-by: Darek Stojaczyk <dariusz.stojaczyk@intel.com>
788 lines
18 KiB
C
788 lines
18 KiB
C
/*-
|
|
* BSD LICENSE
|
|
*
|
|
* Copyright (C) 2008-2012 Daisuke Aoyama <aoyama@peach.ne.jp>.
|
|
* Copyright (c) Intel Corporation.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* * Neither the name of Intel Corporation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "spdk/stdinc.h"
|
|
|
|
#include "spdk/conf.h"
|
|
#include "spdk/string.h"
|
|
|
|
#include "spdk_internal/log.h"
|
|
|
|
#include "iscsi/iscsi.h"
|
|
#include "iscsi/init_grp.h"
|
|
|
|
static struct spdk_iscsi_init_grp *
|
|
iscsi_init_grp_create(int tag)
|
|
{
|
|
struct spdk_iscsi_init_grp *ig;
|
|
|
|
ig = calloc(1, sizeof(*ig));
|
|
if (ig == NULL) {
|
|
SPDK_ERRLOG("calloc() failed for initiator group\n");
|
|
return NULL;
|
|
}
|
|
|
|
ig->tag = tag;
|
|
TAILQ_INIT(&ig->initiator_head);
|
|
TAILQ_INIT(&ig->netmask_head);
|
|
return ig;
|
|
}
|
|
|
|
static struct spdk_iscsi_initiator_name *
|
|
iscsi_init_grp_find_initiator(struct spdk_iscsi_init_grp *ig, char *name)
|
|
{
|
|
struct spdk_iscsi_initiator_name *iname;
|
|
|
|
TAILQ_FOREACH(iname, &ig->initiator_head, tailq) {
|
|
if (!strcmp(iname->name, name)) {
|
|
return iname;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int
|
|
iscsi_init_grp_add_initiator(struct spdk_iscsi_init_grp *ig, char *name)
|
|
{
|
|
struct spdk_iscsi_initiator_name *iname;
|
|
char *p;
|
|
size_t len;
|
|
|
|
if (ig->ninitiators >= MAX_INITIATOR) {
|
|
SPDK_ERRLOG("> MAX_INITIATOR(=%d) is not allowed\n", MAX_INITIATOR);
|
|
return -EPERM;
|
|
}
|
|
|
|
len = strlen(name);
|
|
if (len > MAX_INITIATOR_NAME) {
|
|
SPDK_ERRLOG("Initiator Name is larger than 223 bytes\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
iname = iscsi_init_grp_find_initiator(ig, name);
|
|
if (iname != NULL) {
|
|
return -EEXIST;
|
|
}
|
|
|
|
iname = calloc(1, sizeof(*iname));
|
|
if (iname == NULL) {
|
|
SPDK_ERRLOG("malloc() failed for initiator name str\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
memcpy(iname->name, name, len);
|
|
|
|
/* Replace "ALL" by "ANY" if set */
|
|
p = strstr(iname->name, "ALL");
|
|
if (p != NULL) {
|
|
SPDK_WARNLOG("Please use \"%s\" instead of \"%s\"\n", "ANY", "ALL");
|
|
SPDK_WARNLOG("Converting \"%s\" to \"%s\" automatically\n", "ALL", "ANY");
|
|
memcpy(p, "ANY", 3);
|
|
}
|
|
|
|
TAILQ_INSERT_TAIL(&ig->initiator_head, iname, tailq);
|
|
ig->ninitiators++;
|
|
|
|
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "InitiatorName %s\n", name);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
iscsi_init_grp_delete_initiator(struct spdk_iscsi_init_grp *ig, char *name)
|
|
{
|
|
struct spdk_iscsi_initiator_name *iname;
|
|
|
|
iname = iscsi_init_grp_find_initiator(ig, name);
|
|
if (iname == NULL) {
|
|
return -ENOENT;
|
|
}
|
|
|
|
TAILQ_REMOVE(&ig->initiator_head, iname, tailq);
|
|
ig->ninitiators--;
|
|
free(iname);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
iscsi_init_grp_add_initiators(struct spdk_iscsi_init_grp *ig, int num_inames,
|
|
char **inames)
|
|
{
|
|
int i;
|
|
int rc;
|
|
|
|
for (i = 0; i < num_inames; i++) {
|
|
rc = iscsi_init_grp_add_initiator(ig, inames[i]);
|
|
if (rc < 0) {
|
|
goto cleanup;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
cleanup:
|
|
for (; i > 0; --i) {
|
|
iscsi_init_grp_delete_initiator(ig, inames[i - 1]);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static void
|
|
iscsi_init_grp_delete_all_initiators(struct spdk_iscsi_init_grp *ig)
|
|
{
|
|
struct spdk_iscsi_initiator_name *iname, *tmp;
|
|
|
|
TAILQ_FOREACH_SAFE(iname, &ig->initiator_head, tailq, tmp) {
|
|
TAILQ_REMOVE(&ig->initiator_head, iname, tailq);
|
|
ig->ninitiators--;
|
|
free(iname);
|
|
}
|
|
}
|
|
|
|
static int
|
|
iscsi_init_grp_delete_initiators(struct spdk_iscsi_init_grp *ig, int num_inames, char **inames)
|
|
{
|
|
int i;
|
|
int rc;
|
|
|
|
for (i = 0; i < num_inames; i++) {
|
|
rc = iscsi_init_grp_delete_initiator(ig, inames[i]);
|
|
if (rc < 0) {
|
|
goto cleanup;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
cleanup:
|
|
for (; i > 0; --i) {
|
|
rc = iscsi_init_grp_add_initiator(ig, inames[i - 1]);
|
|
if (rc != 0) {
|
|
iscsi_init_grp_delete_all_initiators(ig);
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static struct spdk_iscsi_initiator_netmask *
|
|
iscsi_init_grp_find_netmask(struct spdk_iscsi_init_grp *ig, const char *mask)
|
|
{
|
|
struct spdk_iscsi_initiator_netmask *netmask;
|
|
|
|
TAILQ_FOREACH(netmask, &ig->netmask_head, tailq) {
|
|
if (!strcmp(netmask->mask, mask)) {
|
|
return netmask;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int
|
|
iscsi_init_grp_add_netmask(struct spdk_iscsi_init_grp *ig, char *mask)
|
|
{
|
|
struct spdk_iscsi_initiator_netmask *imask;
|
|
char *p;
|
|
size_t len;
|
|
|
|
if (ig->nnetmasks >= MAX_NETMASK) {
|
|
SPDK_ERRLOG("> MAX_NETMASK(=%d) is not allowed\n", MAX_NETMASK);
|
|
return -EPERM;
|
|
}
|
|
|
|
len = strlen(mask);
|
|
if (len > MAX_INITIATOR_ADDR) {
|
|
SPDK_ERRLOG("Initiator Name is larger than %d bytes\n", MAX_INITIATOR_ADDR);
|
|
return -EINVAL;
|
|
}
|
|
|
|
imask = iscsi_init_grp_find_netmask(ig, mask);
|
|
if (imask != NULL) {
|
|
return -EEXIST;
|
|
}
|
|
|
|
imask = calloc(1, sizeof(*imask));
|
|
if (imask == NULL) {
|
|
SPDK_ERRLOG("malloc() failed for inititator mask str\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
memcpy(imask->mask, mask, len);
|
|
|
|
/* Replace "ALL" by "ANY" if set */
|
|
p = strstr(imask->mask, "ALL");
|
|
if (p != NULL) {
|
|
SPDK_WARNLOG("Please use \"%s\" instead of \"%s\"\n", "ANY", "ALL");
|
|
SPDK_WARNLOG("Converting \"%s\" to \"%s\" automatically\n", "ALL", "ANY");
|
|
memcpy(p, "ANY", 3);
|
|
}
|
|
|
|
TAILQ_INSERT_TAIL(&ig->netmask_head, imask, tailq);
|
|
ig->nnetmasks++;
|
|
|
|
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Netmask %s\n", mask);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
iscsi_init_grp_delete_netmask(struct spdk_iscsi_init_grp *ig, char *mask)
|
|
{
|
|
struct spdk_iscsi_initiator_netmask *imask;
|
|
|
|
imask = iscsi_init_grp_find_netmask(ig, mask);
|
|
if (imask == NULL) {
|
|
return -ENOENT;
|
|
}
|
|
|
|
TAILQ_REMOVE(&ig->netmask_head, imask, tailq);
|
|
ig->nnetmasks--;
|
|
free(imask);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
iscsi_init_grp_add_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, char **imasks)
|
|
{
|
|
int i;
|
|
int rc;
|
|
|
|
for (i = 0; i < num_imasks; i++) {
|
|
rc = iscsi_init_grp_add_netmask(ig, imasks[i]);
|
|
if (rc != 0) {
|
|
goto cleanup;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
cleanup:
|
|
for (; i > 0; --i) {
|
|
iscsi_init_grp_delete_netmask(ig, imasks[i - 1]);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static void
|
|
iscsi_init_grp_delete_all_netmasks(struct spdk_iscsi_init_grp *ig)
|
|
{
|
|
struct spdk_iscsi_initiator_netmask *imask, *tmp;
|
|
|
|
TAILQ_FOREACH_SAFE(imask, &ig->netmask_head, tailq, tmp) {
|
|
TAILQ_REMOVE(&ig->netmask_head, imask, tailq);
|
|
ig->nnetmasks--;
|
|
free(imask);
|
|
}
|
|
}
|
|
|
|
static int
|
|
iscsi_init_grp_delete_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, char **imasks)
|
|
{
|
|
int i;
|
|
int rc;
|
|
|
|
for (i = 0; i < num_imasks; i++) {
|
|
rc = iscsi_init_grp_delete_netmask(ig, imasks[i]);
|
|
if (rc != 0) {
|
|
goto cleanup;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
cleanup:
|
|
for (; i > 0; --i) {
|
|
rc = iscsi_init_grp_add_netmask(ig, imasks[i - 1]);
|
|
if (rc != 0) {
|
|
iscsi_init_grp_delete_all_netmasks(ig);
|
|
break;
|
|
}
|
|
}
|
|
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(SPDK_LOG_ISCSI, "add initiator group %d\n", tag);
|
|
|
|
val = spdk_conf_section_get_val(sp, "Comment");
|
|
if (val != NULL) {
|
|
SPDK_DEBUGLOG(SPDK_LOG_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(SPDK_LOG_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(SPDK_LOG_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 = spdk_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
|
|
spdk_iscsi_init_grp_register(struct spdk_iscsi_init_grp *ig)
|
|
{
|
|
struct spdk_iscsi_init_grp *tmp;
|
|
int rc = -1;
|
|
|
|
assert(ig != NULL);
|
|
|
|
pthread_mutex_lock(&g_spdk_iscsi.mutex);
|
|
tmp = spdk_iscsi_init_grp_find_by_tag(ig->tag);
|
|
if (tmp == NULL) {
|
|
TAILQ_INSERT_TAIL(&g_spdk_iscsi.ig_head, ig, tailq);
|
|
rc = 0;
|
|
}
|
|
pthread_mutex_unlock(&g_spdk_iscsi.mutex);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Create initiator group from list of initiator ip/hostnames and netmasks
|
|
* The initiator hostname/netmask lists are allocated by the caller on the
|
|
* heap. Freed later by common initiator_group_destroy() code
|
|
*/
|
|
int
|
|
spdk_iscsi_init_grp_create_from_initiator_list(int tag,
|
|
int num_initiator_names,
|
|
char **initiator_names,
|
|
int num_initiator_masks,
|
|
char **initiator_masks)
|
|
{
|
|
int rc = -1;
|
|
struct spdk_iscsi_init_grp *ig = NULL;
|
|
|
|
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
|
|
"add initiator group (from initiator list) tag=%d, #initiators=%d, #masks=%d\n",
|
|
tag, num_initiator_names, num_initiator_masks);
|
|
|
|
ig = iscsi_init_grp_create(tag);
|
|
if (!ig) {
|
|
SPDK_ERRLOG("initiator group create error (%d)\n", tag);
|
|
return rc;
|
|
}
|
|
|
|
rc = iscsi_init_grp_add_initiators(ig, num_initiator_names,
|
|
initiator_names);
|
|
if (rc < 0) {
|
|
SPDK_ERRLOG("add initiator name error\n");
|
|
goto cleanup;
|
|
}
|
|
|
|
rc = iscsi_init_grp_add_netmasks(ig, num_initiator_masks,
|
|
initiator_masks);
|
|
if (rc < 0) {
|
|
SPDK_ERRLOG("add initiator netmask error\n");
|
|
goto cleanup;
|
|
}
|
|
|
|
rc = spdk_iscsi_init_grp_register(ig);
|
|
if (rc < 0) {
|
|
SPDK_ERRLOG("initiator group register error (%d)\n", tag);
|
|
goto cleanup;
|
|
}
|
|
return 0;
|
|
|
|
cleanup:
|
|
spdk_iscsi_init_grp_destroy(ig);
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
spdk_iscsi_init_grp_add_initiators_from_initiator_list(int tag,
|
|
int num_initiator_names,
|
|
char **initiator_names,
|
|
int num_initiator_masks,
|
|
char **initiator_masks)
|
|
{
|
|
int rc = -1;
|
|
struct spdk_iscsi_init_grp *ig;
|
|
|
|
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
|
|
"add initiator to initiator group: tag=%d, #initiators=%d, #masks=%d\n",
|
|
tag, num_initiator_names, num_initiator_masks);
|
|
|
|
pthread_mutex_lock(&g_spdk_iscsi.mutex);
|
|
ig = spdk_iscsi_init_grp_find_by_tag(tag);
|
|
if (!ig) {
|
|
pthread_mutex_unlock(&g_spdk_iscsi.mutex);
|
|
SPDK_ERRLOG("initiator group (%d) is not found\n", tag);
|
|
return rc;
|
|
}
|
|
|
|
rc = iscsi_init_grp_add_initiators(ig, num_initiator_names,
|
|
initiator_names);
|
|
if (rc < 0) {
|
|
SPDK_ERRLOG("add initiator name error\n");
|
|
goto error;
|
|
}
|
|
|
|
rc = iscsi_init_grp_add_netmasks(ig, num_initiator_masks,
|
|
initiator_masks);
|
|
if (rc < 0) {
|
|
SPDK_ERRLOG("add initiator netmask error\n");
|
|
iscsi_init_grp_delete_initiators(ig, num_initiator_names,
|
|
initiator_names);
|
|
}
|
|
|
|
error:
|
|
pthread_mutex_unlock(&g_spdk_iscsi.mutex);
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
spdk_iscsi_init_grp_delete_initiators_from_initiator_list(int tag,
|
|
int num_initiator_names,
|
|
char **initiator_names,
|
|
int num_initiator_masks,
|
|
char **initiator_masks)
|
|
{
|
|
int rc = -1;
|
|
struct spdk_iscsi_init_grp *ig;
|
|
|
|
SPDK_DEBUGLOG(SPDK_LOG_ISCSI,
|
|
"delete initiator from initiator group: tag=%d, #initiators=%d, #masks=%d\n",
|
|
tag, num_initiator_names, num_initiator_masks);
|
|
|
|
pthread_mutex_lock(&g_spdk_iscsi.mutex);
|
|
ig = spdk_iscsi_init_grp_find_by_tag(tag);
|
|
if (!ig) {
|
|
pthread_mutex_unlock(&g_spdk_iscsi.mutex);
|
|
SPDK_ERRLOG("initiator group (%d) is not found\n", tag);
|
|
return rc;
|
|
}
|
|
|
|
rc = iscsi_init_grp_delete_initiators(ig, num_initiator_names,
|
|
initiator_names);
|
|
if (rc < 0) {
|
|
SPDK_ERRLOG("delete initiator name error\n");
|
|
goto error;
|
|
}
|
|
|
|
rc = iscsi_init_grp_delete_netmasks(ig, num_initiator_masks,
|
|
initiator_masks);
|
|
if (rc < 0) {
|
|
SPDK_ERRLOG("delete initiator netmask error\n");
|
|
iscsi_init_grp_add_initiators(ig, num_initiator_names,
|
|
initiator_names);
|
|
goto error;
|
|
}
|
|
|
|
error:
|
|
pthread_mutex_unlock(&g_spdk_iscsi.mutex);
|
|
return rc;
|
|
}
|
|
|
|
void
|
|
spdk_iscsi_init_grp_destroy(struct spdk_iscsi_init_grp *ig)
|
|
{
|
|
if (!ig) {
|
|
return;
|
|
}
|
|
|
|
iscsi_init_grp_delete_all_initiators(ig);
|
|
iscsi_init_grp_delete_all_netmasks(ig);
|
|
free(ig);
|
|
};
|
|
|
|
struct spdk_iscsi_init_grp *
|
|
spdk_iscsi_init_grp_find_by_tag(int tag)
|
|
{
|
|
struct spdk_iscsi_init_grp *ig;
|
|
|
|
TAILQ_FOREACH(ig, &g_spdk_iscsi.ig_head, tailq) {
|
|
if (ig->tag == tag) {
|
|
return ig;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
spdk_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
|
|
spdk_iscsi_init_grps_destroy(void)
|
|
{
|
|
struct spdk_iscsi_init_grp *ig, *tmp;
|
|
|
|
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_init_grp_array_destroy\n");
|
|
pthread_mutex_lock(&g_spdk_iscsi.mutex);
|
|
TAILQ_FOREACH_SAFE(ig, &g_spdk_iscsi.ig_head, tailq, tmp) {
|
|
TAILQ_REMOVE(&g_spdk_iscsi.ig_head, ig, tailq);
|
|
spdk_iscsi_init_grp_destroy(ig);
|
|
}
|
|
pthread_mutex_unlock(&g_spdk_iscsi.mutex);
|
|
}
|
|
|
|
struct spdk_iscsi_init_grp *
|
|
spdk_iscsi_init_grp_unregister(int tag)
|
|
{
|
|
struct spdk_iscsi_init_grp *ig;
|
|
|
|
pthread_mutex_lock(&g_spdk_iscsi.mutex);
|
|
TAILQ_FOREACH(ig, &g_spdk_iscsi.ig_head, tailq) {
|
|
if (ig->tag == tag) {
|
|
TAILQ_REMOVE(&g_spdk_iscsi.ig_head, ig, tailq);
|
|
pthread_mutex_unlock(&g_spdk_iscsi.mutex);
|
|
return ig;
|
|
}
|
|
}
|
|
pthread_mutex_unlock(&g_spdk_iscsi.mutex);
|
|
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
|
|
spdk_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_spdk_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)
|
|
{
|
|
struct spdk_iscsi_initiator_name *iname;
|
|
struct spdk_iscsi_initiator_netmask *imask;
|
|
|
|
spdk_json_write_object_begin(w);
|
|
|
|
spdk_json_write_named_int32(w, "tag", ig->tag);
|
|
|
|
spdk_json_write_named_array_begin(w, "initiators");
|
|
TAILQ_FOREACH(iname, &ig->initiator_head, tailq) {
|
|
spdk_json_write_string(w, iname->name);
|
|
}
|
|
spdk_json_write_array_end(w);
|
|
|
|
spdk_json_write_named_array_begin(w, "netmasks");
|
|
TAILQ_FOREACH(imask, &ig->netmask_head, tailq) {
|
|
spdk_json_write_string(w, imask->mask);
|
|
}
|
|
spdk_json_write_array_end(w);
|
|
|
|
spdk_json_write_object_end(w);
|
|
}
|
|
|
|
static void
|
|
iscsi_init_grp_config_json(struct spdk_iscsi_init_grp *ig,
|
|
struct spdk_json_write_ctx *w)
|
|
{
|
|
spdk_json_write_object_begin(w);
|
|
|
|
spdk_json_write_named_string(w, "method", "add_initiator_group");
|
|
|
|
spdk_json_write_name(w, "params");
|
|
iscsi_init_grp_info_json(ig, w);
|
|
|
|
spdk_json_write_object_end(w);
|
|
}
|
|
|
|
void
|
|
spdk_iscsi_init_grps_info_json(struct spdk_json_write_ctx *w)
|
|
{
|
|
struct spdk_iscsi_init_grp *ig;
|
|
|
|
TAILQ_FOREACH(ig, &g_spdk_iscsi.ig_head, tailq) {
|
|
iscsi_init_grp_info_json(ig, w);
|
|
}
|
|
}
|
|
|
|
void
|
|
spdk_iscsi_init_grps_config_json(struct spdk_json_write_ctx *w)
|
|
{
|
|
struct spdk_iscsi_init_grp *ig;
|
|
|
|
TAILQ_FOREACH(ig, &g_spdk_iscsi.ig_head, tailq) {
|
|
iscsi_init_grp_config_json(ig, w);
|
|
}
|
|
}
|