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

iscsi: Remove the prefix spdk_ from names of private functions

Browse Source 
iSCSI library had used the prefix spdk_ for most functions regardless
of private or public. Using the prefix spdk_ only for public functions
will be helpful to distinguish private and public functions, and
will be helpful to investigate issues or do further improvement.

Besides in iscsi.c static variable spdk_arc4random_initialized had
the prefix spdk_, and change it to g_arc4random_initialized according
to the SPDK's good practice.

iSCSI library still have some issues but is more stable than before
and now will be the good time to adjust the naming rule to other
libraries.

This patch doesn't change any behavior.

Change-Id: Ia0b8585a7ce6662cabc0e6f57b7ccb8a40342297
Signed-off-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/449396
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Changpeng Liu <changpeng.liu@intel.com>
This commit is contained in:
Shuhei Matsumoto 2019-03-28 06:53:37 +09:00 committed by Changpeng Liu
parent b7039655ce
commit 893e02a54f
14 changed files with 954 additions and 966 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/iscsi/acceptor.c
View File

@ -46,7 +46,7 @@
#define ACCEPT_TIMEOUT_US 1000 /* 1ms */ #define ACCEPT_TIMEOUT_US 1000 /* 1ms */
static int static int
spdk_iscsi_portal_accept(void *arg) iscsi_portal_accept(void *arg)
{ {
struct spdk_iscsi_portal *portal = arg; struct spdk_iscsi_portal *portal = arg;
struct spdk_sock *sock; struct spdk_sock *sock;
@ -81,7 +81,7 @@ spdk_iscsi_portal_accept(void *arg)
void void
spdk_iscsi_acceptor_start(struct spdk_iscsi_portal *p) spdk_iscsi_acceptor_start(struct spdk_iscsi_portal *p)
{ {
p->acceptor_poller = spdk_poller_register(spdk_iscsi_portal_accept, p, ACCEPT_TIMEOUT_US); p->acceptor_poller = spdk_poller_register(iscsi_portal_accept, p, ACCEPT_TIMEOUT_US);
} }
void void

157
lib/iscsi/conn.c
View File

@ -73,12 +73,12 @@ static pthread_mutex_t g_conns_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct spdk_poller *g_shutdown_timer = NULL; static struct spdk_poller *g_shutdown_timer = NULL;
static uint32_t spdk_iscsi_conn_allocate_reactor(const struct spdk_cpuset *cpumask); static uint32_t iscsi_conn_allocate_reactor(const struct spdk_cpuset *cpumask);
static void spdk_iscsi_conn_full_feature_migrate(void *arg1, void *arg2); static void iscsi_conn_full_feature_migrate(void *arg1, void *arg2);
static void spdk_iscsi_conn_stop(struct spdk_iscsi_conn *conn); static void iscsi_conn_stop(struct spdk_iscsi_conn *conn);
static void spdk_iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group, static void iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group,
struct spdk_sock *sock); struct spdk_sock *sock);
static struct spdk_iscsi_conn * static struct spdk_iscsi_conn *
allocate_conn(void) allocate_conn(void)
@ -110,7 +110,7 @@ free_conn(struct spdk_iscsi_conn *conn)
} }
static struct spdk_iscsi_conn * static struct spdk_iscsi_conn *
spdk_find_iscsi_connection_by_id(int cid) find_iscsi_connection_by_id(int cid)
{ {
if (g_conns_array[cid].is_valid == 1) { if (g_conns_array[cid].is_valid == 1) {
return &g_conns_array[cid]; return &g_conns_array[cid];
@ -177,7 +177,7 @@ err:
} }
static void static void
spdk_iscsi_poll_group_add_conn_sock(struct spdk_iscsi_conn *conn) iscsi_poll_group_add_conn_sock(struct spdk_iscsi_conn *conn)
{ {
struct spdk_iscsi_poll_group *poll_group; struct spdk_iscsi_poll_group *poll_group;
int rc; int rc;
@ -186,14 +186,14 @@ spdk_iscsi_poll_group_add_conn_sock(struct spdk_iscsi_conn *conn)
poll_group = &g_spdk_iscsi.poll_group[conn->lcore]; poll_group = &g_spdk_iscsi.poll_group[conn->lcore];
rc = spdk_sock_group_add_sock(poll_group->sock_group, conn->sock, spdk_iscsi_conn_sock_cb, conn); rc = spdk_sock_group_add_sock(poll_group->sock_group, conn->sock, iscsi_conn_sock_cb, conn);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("Failed to add sock=%p of conn=%p\n", conn->sock, conn); SPDK_ERRLOG("Failed to add sock=%p of conn=%p\n", conn->sock, conn);
} }
} }
static void static void
spdk_iscsi_poll_group_remove_conn_sock(struct spdk_iscsi_conn *conn) iscsi_poll_group_remove_conn_sock(struct spdk_iscsi_conn *conn)
{ {
struct spdk_iscsi_poll_group *poll_group; struct spdk_iscsi_poll_group *poll_group;
int rc; int rc;
@ -209,7 +209,7 @@ spdk_iscsi_poll_group_remove_conn_sock(struct spdk_iscsi_conn *conn)
} }
static void static void
spdk_iscsi_poll_group_add_conn(struct spdk_iscsi_conn *conn) iscsi_poll_group_add_conn(struct spdk_iscsi_conn *conn)
{ {
struct spdk_iscsi_poll_group *poll_group; struct spdk_iscsi_poll_group *poll_group;
@ -219,11 +219,11 @@ spdk_iscsi_poll_group_add_conn(struct spdk_iscsi_conn *conn)
conn->is_stopped = false; conn->is_stopped = false;
STAILQ_INSERT_TAIL(&poll_group->connections, conn, link); STAILQ_INSERT_TAIL(&poll_group->connections, conn, link);
spdk_iscsi_poll_group_add_conn_sock(conn); iscsi_poll_group_add_conn_sock(conn);
} }
static void static void
spdk_iscsi_poll_group_remove_conn(struct spdk_iscsi_conn *conn) iscsi_poll_group_remove_conn(struct spdk_iscsi_conn *conn)
{ {
struct spdk_iscsi_poll_group *poll_group; struct spdk_iscsi_poll_group *poll_group;
@ -347,7 +347,7 @@ spdk_iscsi_conn_construct(struct spdk_iscsi_portal *portal,
conn->lcore = spdk_env_get_current_core(); conn->lcore = spdk_env_get_current_core();
__sync_fetch_and_add(&g_num_connections[conn->lcore], 1); __sync_fetch_and_add(&g_num_connections[conn->lcore], 1);
spdk_iscsi_poll_group_add_conn(conn); iscsi_poll_group_add_conn(conn);
return 0; return 0;
error_return: error_return:
@ -380,7 +380,8 @@ spdk_iscsi_conn_free_pdu(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pd
spdk_put_pdu(pdu); spdk_put_pdu(pdu);
} }
static int spdk_iscsi_conn_free_tasks(struct spdk_iscsi_conn *conn) static int
iscsi_conn_free_tasks(struct spdk_iscsi_conn *conn)
{ {
struct spdk_iscsi_pdu *pdu, *tmp_pdu; struct spdk_iscsi_pdu *pdu, *tmp_pdu;
struct spdk_iscsi_task *iscsi_task, *tmp_iscsi_task; struct spdk_iscsi_task *iscsi_task, *tmp_iscsi_task;
@ -413,7 +414,7 @@ static int spdk_iscsi_conn_free_tasks(struct spdk_iscsi_conn *conn)
} }
static void static void
_spdk_iscsi_conn_free(struct spdk_iscsi_conn *conn) _iscsi_conn_free(struct spdk_iscsi_conn *conn)
{ {
if (conn == NULL) { if (conn == NULL) {
return; return;
@ -431,7 +432,7 @@ _spdk_iscsi_conn_free(struct spdk_iscsi_conn *conn)
} }
static void static void
spdk_iscsi_conn_cleanup_backend(struct spdk_iscsi_conn *conn) iscsi_conn_cleanup_backend(struct spdk_iscsi_conn *conn)
{ {
int rc; int rc;
struct spdk_iscsi_tgt_node *target; struct spdk_iscsi_tgt_node *target;
@ -451,7 +452,7 @@ spdk_iscsi_conn_cleanup_backend(struct spdk_iscsi_conn *conn)
} }
static void static void
spdk_iscsi_conn_free(struct spdk_iscsi_conn *conn) iscsi_conn_free(struct spdk_iscsi_conn *conn)
{ {
struct spdk_iscsi_sess *sess; struct spdk_iscsi_sess *sess;
int idx; int idx;
@ -496,53 +497,53 @@ spdk_iscsi_conn_free(struct spdk_iscsi_conn *conn)
end: end:
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "cleanup free conn\n"); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "cleanup free conn\n");
_spdk_iscsi_conn_free(conn); _iscsi_conn_free(conn);
pthread_mutex_unlock(&g_conns_mutex); pthread_mutex_unlock(&g_conns_mutex);
} }
static int static int
_spdk_iscsi_conn_check_shutdown(void *arg) _iscsi_conn_check_shutdown(void *arg)
{ {
struct spdk_iscsi_conn *conn = arg; struct spdk_iscsi_conn *conn = arg;
int rc; int rc;
rc = spdk_iscsi_conn_free_tasks(conn); rc = iscsi_conn_free_tasks(conn);
if (rc < 0) { if (rc < 0) {
return 1; return 1;
} }
spdk_poller_unregister(&conn->shutdown_timer); spdk_poller_unregister(&conn->shutdown_timer);
spdk_iscsi_conn_stop(conn); iscsi_conn_stop(conn);
spdk_iscsi_conn_free(conn); iscsi_conn_free(conn);
return 1; return 1;
} }
static void static void
_spdk_iscsi_conn_destruct(struct spdk_iscsi_conn *conn) _iscsi_conn_destruct(struct spdk_iscsi_conn *conn)
{ {
int rc; int rc;
spdk_clear_all_transfer_task(conn, NULL, NULL); spdk_clear_all_transfer_task(conn, NULL, NULL);
spdk_iscsi_poll_group_remove_conn_sock(conn); iscsi_poll_group_remove_conn_sock(conn);
spdk_sock_close(&conn->sock); spdk_sock_close(&conn->sock);
spdk_poller_unregister(&conn->logout_timer); spdk_poller_unregister(&conn->logout_timer);
spdk_poller_unregister(&conn->flush_poller); spdk_poller_unregister(&conn->flush_poller);
rc = spdk_iscsi_conn_free_tasks(conn); rc = iscsi_conn_free_tasks(conn);
if (rc < 0) { if (rc < 0) {
/* The connection cannot be freed yet. Check back later. */ /* The connection cannot be freed yet. Check back later. */
conn->shutdown_timer = spdk_poller_register(_spdk_iscsi_conn_check_shutdown, conn, 1000); conn->shutdown_timer = spdk_poller_register(_iscsi_conn_check_shutdown, conn, 1000);
} else { } else {
spdk_iscsi_conn_stop(conn); iscsi_conn_stop(conn);
spdk_iscsi_conn_free(conn); iscsi_conn_free(conn);
} }
} }
static int static int
_spdk_iscsi_conn_check_pending_tasks(void *arg) _iscsi_conn_check_pending_tasks(void *arg)
{ {
struct spdk_iscsi_conn *conn = arg; struct spdk_iscsi_conn *conn = arg;
@ -552,7 +553,7 @@ _spdk_iscsi_conn_check_pending_tasks(void *arg)
spdk_poller_unregister(&conn->shutdown_timer); spdk_poller_unregister(&conn->shutdown_timer);
_spdk_iscsi_conn_destruct(conn); _iscsi_conn_destruct(conn);
return 1; return 1;
} }
@ -568,18 +569,18 @@ spdk_iscsi_conn_destruct(struct spdk_iscsi_conn *conn)
conn->state = ISCSI_CONN_STATE_EXITED; conn->state = ISCSI_CONN_STATE_EXITED;
if (conn->sess != NULL && conn->pending_task_cnt > 0) { if (conn->sess != NULL && conn->pending_task_cnt > 0) {
spdk_iscsi_conn_cleanup_backend(conn); iscsi_conn_cleanup_backend(conn);
} }
if (conn->dev != NULL && spdk_scsi_dev_has_pending_tasks(conn->dev)) { if (conn->dev != NULL && spdk_scsi_dev_has_pending_tasks(conn->dev)) {
conn->shutdown_timer = spdk_poller_register(_spdk_iscsi_conn_check_pending_tasks, conn, 1000); conn->shutdown_timer = spdk_poller_register(_iscsi_conn_check_pending_tasks, conn, 1000);
} else { } else {
_spdk_iscsi_conn_destruct(conn); _iscsi_conn_destruct(conn);
} }
} }
static int static int
spdk_iscsi_get_active_conns(void) iscsi_get_active_conns(void)
{ {
struct spdk_iscsi_conn *conn; struct spdk_iscsi_conn *conn;
int num = 0; int num = 0;
@ -587,7 +588,7 @@ spdk_iscsi_get_active_conns(void)
pthread_mutex_lock(&g_conns_mutex); pthread_mutex_lock(&g_conns_mutex);
for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) { for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {
conn = spdk_find_iscsi_connection_by_id(i); conn = find_iscsi_connection_by_id(i);
if (conn == NULL) { if (conn == NULL) {
continue; continue;
} }
@ -598,7 +599,7 @@ spdk_iscsi_get_active_conns(void)
} }
static void static void
spdk_iscsi_conns_cleanup(void) iscsi_conns_cleanup(void)
{ {
free(g_num_connections); free(g_num_connections);
munmap(g_conns_array, sizeof(struct spdk_iscsi_conn) * munmap(g_conns_array, sizeof(struct spdk_iscsi_conn) *
@ -611,24 +612,24 @@ spdk_iscsi_conns_cleanup(void)
} }
static void static void
spdk_iscsi_conn_check_shutdown_cb(void *arg1, void *arg2) iscsi_conn_check_shutdown_cb(void *arg1, void *arg2)
{ {
spdk_iscsi_conns_cleanup(); iscsi_conns_cleanup();
spdk_shutdown_iscsi_conns_done(); spdk_shutdown_iscsi_conns_done();
} }
static int static int
spdk_iscsi_conn_check_shutdown(void *arg) iscsi_conn_check_shutdown(void *arg)
{ {
struct spdk_event *event; struct spdk_event *event;
if (spdk_iscsi_get_active_conns() != 0) { if (iscsi_get_active_conns() != 0) {
return 1; return 1;
} }
spdk_poller_unregister(&g_shutdown_timer); spdk_poller_unregister(&g_shutdown_timer);
event = spdk_event_allocate(spdk_env_get_current_core(), event = spdk_event_allocate(spdk_env_get_current_core(),
spdk_iscsi_conn_check_shutdown_cb, NULL, NULL); iscsi_conn_check_shutdown_cb, NULL, NULL);
spdk_event_call(event); spdk_event_call(event);
return 1; return 1;
@ -745,7 +746,7 @@ error:
* This function will stop executing the specified connection. * This function will stop executing the specified connection.
*/ */
static void static void
spdk_iscsi_conn_stop(struct spdk_iscsi_conn *conn) iscsi_conn_stop(struct spdk_iscsi_conn *conn)
{ {
struct spdk_iscsi_tgt_node *target; struct spdk_iscsi_tgt_node *target;
@ -763,7 +764,7 @@ spdk_iscsi_conn_stop(struct spdk_iscsi_conn *conn)
assert(conn->lcore == spdk_env_get_current_core()); assert(conn->lcore == spdk_env_get_current_core());
__sync_fetch_and_sub(&g_num_connections[conn->lcore], 1); __sync_fetch_and_sub(&g_num_connections[conn->lcore], 1);
spdk_iscsi_poll_group_remove_conn(conn); iscsi_poll_group_remove_conn(conn);
} }
void spdk_shutdown_iscsi_conns(void) void spdk_shutdown_iscsi_conns(void)
@ -774,7 +775,7 @@ void spdk_shutdown_iscsi_conns(void)
pthread_mutex_lock(&g_conns_mutex); pthread_mutex_lock(&g_conns_mutex);
for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) { for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {
conn = spdk_find_iscsi_connection_by_id(i); conn = find_iscsi_connection_by_id(i);
if (conn == NULL) { if (conn == NULL) {
continue; continue;
} }
@ -788,8 +789,7 @@ void spdk_shutdown_iscsi_conns(void)
} }
pthread_mutex_unlock(&g_conns_mutex); pthread_mutex_unlock(&g_conns_mutex);
g_shutdown_timer = spdk_poller_register(spdk_iscsi_conn_check_shutdown, NULL, g_shutdown_timer = spdk_poller_register(iscsi_conn_check_shutdown, NULL, 1000);
1000);
} }
int int
@ -805,7 +805,7 @@ spdk_iscsi_drop_conns(struct spdk_iscsi_conn *conn, const char *conn_match,
num = 0; num = 0;
pthread_mutex_lock(&g_conns_mutex); pthread_mutex_lock(&g_conns_mutex);
for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) { for (i = 0; i < MAX_ISCSI_CONNECTIONS; i++) {
xconn = spdk_find_iscsi_connection_by_id(i); xconn = find_iscsi_connection_by_id(i);
if (xconn == NULL) { if (xconn == NULL) {
continue; continue;
@ -962,8 +962,8 @@ spdk_iscsi_task_mgmt_cpl(struct spdk_scsi_task *scsi_task)
} }
static void static void
spdk_iscsi_task_copy_to_rsp_scsi_status(struct spdk_iscsi_task *primary, iscsi_task_copy_to_rsp_scsi_status(struct spdk_iscsi_task *primary,
struct spdk_scsi_task *task) struct spdk_scsi_task *task)
{ {
memcpy(primary->rsp_sense_data, task->sense_data, task->sense_data_len); memcpy(primary->rsp_sense_data, task->sense_data, task->sense_data_len);
primary->rsp_sense_data_len = task->sense_data_len; primary->rsp_sense_data_len = task->sense_data_len;
@ -971,8 +971,8 @@ spdk_iscsi_task_copy_to_rsp_scsi_status(struct spdk_iscsi_task *primary,
} }
static void static void
spdk_iscsi_task_copy_from_rsp_scsi_status(struct spdk_scsi_task *task, iscsi_task_copy_from_rsp_scsi_status(struct spdk_scsi_task *task,
struct spdk_iscsi_task *primary) struct spdk_iscsi_task *primary)
{ {
memcpy(task->sense_data, primary->rsp_sense_data, memcpy(task->sense_data, primary->rsp_sense_data,
primary->rsp_sense_data_len); primary->rsp_sense_data_len);
@ -1018,10 +1018,10 @@ process_read_task_completion(struct spdk_iscsi_conn *conn,
TAILQ_FOREACH(tmp, &primary->subtask_list, subtask_link) { TAILQ_FOREACH(tmp, &primary->subtask_list, subtask_link) {
spdk_scsi_task_copy_status(&tmp->scsi, &task->scsi); spdk_scsi_task_copy_status(&tmp->scsi, &task->scsi);
} }
spdk_iscsi_task_copy_to_rsp_scsi_status(primary, &task->scsi); iscsi_task_copy_to_rsp_scsi_status(primary, &task->scsi);
} }
} else if (primary->rsp_scsi_status != SPDK_SCSI_STATUS_GOOD) { } else if (primary->rsp_scsi_status != SPDK_SCSI_STATUS_GOOD) {
spdk_iscsi_task_copy_from_rsp_scsi_status(&task->scsi, primary); iscsi_task_copy_from_rsp_scsi_status(&task->scsi, primary);
} }
if ((task != primary) && if ((task != primary) &&
@ -1079,13 +1079,13 @@ spdk_iscsi_task_cpl(struct spdk_scsi_task *scsi_task)
primary->scsi.data_transferred += task->scsi.data_transferred; primary->scsi.data_transferred += task->scsi.data_transferred;
} }
} else if (primary->rsp_scsi_status == SPDK_SCSI_STATUS_GOOD) { } else if (primary->rsp_scsi_status == SPDK_SCSI_STATUS_GOOD) {
spdk_iscsi_task_copy_to_rsp_scsi_status(primary, &task->scsi); iscsi_task_copy_to_rsp_scsi_status(primary, &task->scsi);
} }
if (primary->bytes_completed == primary->scsi.transfer_len) { if (primary->bytes_completed == primary->scsi.transfer_len) {
spdk_del_transfer_task(conn, primary->tag); spdk_del_transfer_task(conn, primary->tag);
if (primary->rsp_scsi_status != SPDK_SCSI_STATUS_GOOD) { if (primary->rsp_scsi_status != SPDK_SCSI_STATUS_GOOD) {
spdk_iscsi_task_copy_from_rsp_scsi_status(&primary->scsi, primary); iscsi_task_copy_from_rsp_scsi_status(&primary->scsi, primary);
} }
spdk_iscsi_task_response(conn, primary); spdk_iscsi_task_response(conn, primary);
/* /*
@ -1109,8 +1109,8 @@ spdk_iscsi_task_cpl(struct spdk_scsi_task *scsi_task)
} }
static int static int
spdk_iscsi_get_pdu_length(struct spdk_iscsi_pdu *pdu, int header_digest, iscsi_get_pdu_length(struct spdk_iscsi_pdu *pdu, int header_digest,
int data_digest) int data_digest)
{ {
int data_len, enable_digest, total; int data_len, enable_digest, total;
@ -1188,7 +1188,7 @@ spdk_iscsi_conn_handle_nop(struct spdk_iscsi_conn *conn)
* should be closed. * should be closed.
*/ */
static int static int
spdk_iscsi_conn_flush_pdus_internal(struct spdk_iscsi_conn *conn) iscsi_conn_flush_pdus_internal(struct spdk_iscsi_conn *conn)
{ {
const int num_iovs = 32; const int num_iovs = 32;
struct iovec iovs[num_iovs]; struct iovec iovs[num_iovs];
@ -1244,9 +1244,8 @@ spdk_iscsi_conn_flush_pdus_internal(struct spdk_iscsi_conn *conn)
* time only the unwritten portion will be sent to writev(). * time only the unwritten portion will be sent to writev().
*/ */
while (bytes > 0) { while (bytes > 0) {
pdu_length = spdk_iscsi_get_pdu_length(pdu, pdu_length = iscsi_get_pdu_length(pdu, conn->header_digest,
conn->header_digest, conn->data_digest);
conn->data_digest);
pdu_length -= pdu->writev_offset; pdu_length -= pdu->writev_offset;
if (bytes >= pdu_length) { if (bytes >= pdu_length) {
@ -1289,17 +1288,17 @@ spdk_iscsi_conn_flush_pdus_internal(struct spdk_iscsi_conn *conn)
* function will spin until all PDUs have successfully been flushed. * function will spin until all PDUs have successfully been flushed.
*/ */
static int static int
spdk_iscsi_conn_flush_pdus(void *_conn) iscsi_conn_flush_pdus(void *_conn)
{ {
struct spdk_iscsi_conn *conn = _conn; struct spdk_iscsi_conn *conn = _conn;
int rc; int rc;
if (conn->state == ISCSI_CONN_STATE_RUNNING) { if (conn->state == ISCSI_CONN_STATE_RUNNING) {
rc = spdk_iscsi_conn_flush_pdus_internal(conn); rc = iscsi_conn_flush_pdus_internal(conn);
if (rc == 0 && conn->flush_poller != NULL) { if (rc == 0 && conn->flush_poller != NULL) {
spdk_poller_unregister(&conn->flush_poller); spdk_poller_unregister(&conn->flush_poller);
} else if (rc == 1 && conn->flush_poller == NULL) { } else if (rc == 1 && conn->flush_poller == NULL) {
conn->flush_poller = spdk_poller_register(spdk_iscsi_conn_flush_pdus, conn->flush_poller = spdk_poller_register(iscsi_conn_flush_pdus,
conn, 50); conn, 50);
} }
} else { } else {
@ -1310,7 +1309,7 @@ spdk_iscsi_conn_flush_pdus(void *_conn)
* closing the connection. * closing the connection.
*/ */
do { do {
rc = spdk_iscsi_conn_flush_pdus_internal(conn); rc = iscsi_conn_flush_pdus_internal(conn);
} while (rc == 1); } while (rc == 1);
} }
@ -1327,7 +1326,7 @@ spdk_iscsi_conn_flush_pdus(void *_conn)
} }
static int static int
spdk_iscsi_dif_verify(struct spdk_iscsi_pdu *pdu, struct spdk_dif_ctx *dif_ctx) iscsi_dif_verify(struct spdk_iscsi_pdu *pdu, struct spdk_dif_ctx *dif_ctx)
{ {
struct iovec iov; struct iovec iov;
struct spdk_dif_error err_blk = {}; struct spdk_dif_error err_blk = {};
@ -1354,7 +1353,7 @@ spdk_iscsi_conn_write_pdu(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *p
int rc; int rc;
if (spdk_unlikely(spdk_iscsi_get_dif_ctx(conn, pdu, &pdu->dif_ctx))) { if (spdk_unlikely(spdk_iscsi_get_dif_ctx(conn, pdu, &pdu->dif_ctx))) {
rc = spdk_iscsi_dif_verify(pdu, &pdu->dif_ctx); rc = iscsi_dif_verify(pdu, &pdu->dif_ctx);
if (rc != 0) { if (rc != 0) {
spdk_iscsi_conn_free_pdu(conn, pdu); spdk_iscsi_conn_free_pdu(conn, pdu);
conn->state = ISCSI_CONN_STATE_EXITING; conn->state = ISCSI_CONN_STATE_EXITING;
@ -1378,13 +1377,13 @@ spdk_iscsi_conn_write_pdu(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *p
} }
TAILQ_INSERT_TAIL(&conn->write_pdu_list, pdu, tailq); TAILQ_INSERT_TAIL(&conn->write_pdu_list, pdu, tailq);
spdk_iscsi_conn_flush_pdus(conn); iscsi_conn_flush_pdus(conn);
} }
#define GET_PDU_LOOP_COUNT 16 #define GET_PDU_LOOP_COUNT 16
static int static int
spdk_iscsi_conn_handle_incoming_pdus(struct spdk_iscsi_conn *conn) iscsi_conn_handle_incoming_pdus(struct spdk_iscsi_conn *conn)
{ {
struct spdk_iscsi_pdu *pdu; struct spdk_iscsi_pdu *pdu;
int i, rc; int i, rc;
@ -1423,7 +1422,7 @@ spdk_iscsi_conn_handle_incoming_pdus(struct spdk_iscsi_conn *conn)
} }
static void static void
spdk_iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group, struct spdk_sock *sock) iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group, struct spdk_sock *sock)
{ {
struct spdk_iscsi_conn *conn = arg; struct spdk_iscsi_conn *conn = arg;
int rc; int rc;
@ -1436,15 +1435,15 @@ spdk_iscsi_conn_sock_cb(void *arg, struct spdk_sock_group *group, struct spdk_so
} }
/* Handle incoming PDUs */ /* Handle incoming PDUs */
rc = spdk_iscsi_conn_handle_incoming_pdus(conn); rc = iscsi_conn_handle_incoming_pdus(conn);
if (rc < 0) { if (rc < 0) {
conn->state = ISCSI_CONN_STATE_EXITING; conn->state = ISCSI_CONN_STATE_EXITING;
spdk_iscsi_conn_flush_pdus(conn); iscsi_conn_flush_pdus(conn);
} }
} }
static void static void
spdk_iscsi_conn_full_feature_migrate(void *arg1, void *arg2) iscsi_conn_full_feature_migrate(void *arg1, void *arg2)
{ {
struct spdk_iscsi_conn *conn = arg1; struct spdk_iscsi_conn *conn = arg1;
@ -1454,7 +1453,7 @@ spdk_iscsi_conn_full_feature_migrate(void *arg1, void *arg2)
/* The poller has been unregistered, so now we can re-register it on the new core. */ /* The poller has been unregistered, so now we can re-register it on the new core. */
conn->lcore = spdk_env_get_current_core(); conn->lcore = spdk_env_get_current_core();
spdk_iscsi_poll_group_add_conn(conn); iscsi_poll_group_add_conn(conn);
} }
void void
@ -1464,7 +1463,7 @@ spdk_iscsi_conn_migration(struct spdk_iscsi_conn *conn)
struct spdk_event *event; struct spdk_event *event;
struct spdk_iscsi_tgt_node *target; struct spdk_iscsi_tgt_node *target;
lcore = spdk_iscsi_conn_allocate_reactor(conn->portal->cpumask); lcore = iscsi_conn_allocate_reactor(conn->portal->cpumask);
if (conn->sess->session_type == SESSION_TYPE_NORMAL) { if (conn->sess->session_type == SESSION_TYPE_NORMAL) {
target = conn->sess->target; target = conn->sess->target;
pthread_mutex_lock(&target->mutex); pthread_mutex_lock(&target->mutex);
@ -1488,13 +1487,13 @@ spdk_iscsi_conn_migration(struct spdk_iscsi_conn *conn)
pthread_mutex_unlock(&target->mutex); pthread_mutex_unlock(&target->mutex);
} }
spdk_iscsi_poll_group_remove_conn_sock(conn); iscsi_poll_group_remove_conn_sock(conn);
spdk_poller_unregister(&conn->flush_poller); spdk_poller_unregister(&conn->flush_poller);
spdk_iscsi_conn_stop(conn); iscsi_conn_stop(conn);
__sync_fetch_and_add(&g_num_connections[lcore], 1); __sync_fetch_and_add(&g_num_connections[lcore], 1);
conn->last_nopin = spdk_get_ticks(); conn->last_nopin = spdk_get_ticks();
event = spdk_event_allocate(lcore, spdk_iscsi_conn_full_feature_migrate, event = spdk_event_allocate(lcore, iscsi_conn_full_feature_migrate,
conn, NULL); conn, NULL);
spdk_event_call(event); spdk_event_call(event);
} }
@ -1512,7 +1511,7 @@ spdk_iscsi_conn_get_min_per_core(void)
} }
static uint32_t static uint32_t
spdk_iscsi_conn_allocate_reactor(const struct spdk_cpuset *cpumask) iscsi_conn_allocate_reactor(const struct spdk_cpuset *cpumask)
{ {
uint32_t i, selected_core; uint32_t i, selected_core;
int32_t num_pollers, min_pollers; int32_t num_pollers, min_pollers;

111
lib/iscsi/init_grp.c
View File

@ -43,7 +43,7 @@
#include "iscsi/init_grp.h" #include "iscsi/init_grp.h"
static struct spdk_iscsi_init_grp * static struct spdk_iscsi_init_grp *
spdk_iscsi_init_grp_create(int tag) iscsi_init_grp_create(int tag)
{ {
struct spdk_iscsi_init_grp *ig; struct spdk_iscsi_init_grp *ig;
@ -60,7 +60,7 @@ spdk_iscsi_init_grp_create(int tag)
} }
static struct spdk_iscsi_initiator_name * static struct spdk_iscsi_initiator_name *
spdk_iscsi_init_grp_find_initiator(struct spdk_iscsi_init_grp *ig, char *name) iscsi_init_grp_find_initiator(struct spdk_iscsi_init_grp *ig, char *name)
{ {
struct spdk_iscsi_initiator_name *iname; struct spdk_iscsi_initiator_name *iname;
@ -73,7 +73,7 @@ spdk_iscsi_init_grp_find_initiator(struct spdk_iscsi_init_grp *ig, char *name)
} }
static int static int
spdk_iscsi_init_grp_add_initiator(struct spdk_iscsi_init_grp *ig, char *name) iscsi_init_grp_add_initiator(struct spdk_iscsi_init_grp *ig, char *name)
{ {
struct spdk_iscsi_initiator_name *iname; struct spdk_iscsi_initiator_name *iname;
char *p; char *p;
@ -88,7 +88,7 @@ spdk_iscsi_init_grp_add_initiator(struct spdk_iscsi_init_grp *ig, char *name)
return -EINVAL; return -EINVAL;
} }
iname = spdk_iscsi_init_grp_find_initiator(ig, name); iname = iscsi_init_grp_find_initiator(ig, name);
if (iname != NULL) { if (iname != NULL) {
return -EEXIST; return -EEXIST;
} }
@ -122,11 +122,11 @@ spdk_iscsi_init_grp_add_initiator(struct spdk_iscsi_init_grp *ig, char *name)
} }
static int static int
spdk_iscsi_init_grp_delete_initiator(struct spdk_iscsi_init_grp *ig, char *name) iscsi_init_grp_delete_initiator(struct spdk_iscsi_init_grp *ig, char *name)
{ {
struct spdk_iscsi_initiator_name *iname; struct spdk_iscsi_initiator_name *iname;
iname = spdk_iscsi_init_grp_find_initiator(ig, name); iname = iscsi_init_grp_find_initiator(ig, name);
if (iname == NULL) { if (iname == NULL) {
return -ENOENT; return -ENOENT;
} }
@ -139,13 +139,14 @@ spdk_iscsi_init_grp_delete_initiator(struct spdk_iscsi_init_grp *ig, char *name)
} }
static int static int
spdk_iscsi_init_grp_add_initiators(struct spdk_iscsi_init_grp *ig, int num_inames, char **inames) iscsi_init_grp_add_initiators(struct spdk_iscsi_init_grp *ig, int num_inames,
char **inames)
{ {
int i; int i;
int rc; int rc;
for (i = 0; i < num_inames; i++) { for (i = 0; i < num_inames; i++) {
rc = spdk_iscsi_init_grp_add_initiator(ig, inames[i]); rc = iscsi_init_grp_add_initiator(ig, inames[i]);
if (rc < 0) { if (rc < 0) {
goto cleanup; goto cleanup;
} }
@ -154,13 +155,13 @@ spdk_iscsi_init_grp_add_initiators(struct spdk_iscsi_init_grp *ig, int num_iname
cleanup: cleanup:
for (; i > 0; --i) { for (; i > 0; --i) {
spdk_iscsi_init_grp_delete_initiator(ig, inames[i - 1]); iscsi_init_grp_delete_initiator(ig, inames[i - 1]);
} }
return rc; return rc;
} }
static void static void
spdk_iscsi_init_grp_delete_all_initiators(struct spdk_iscsi_init_grp *ig) iscsi_init_grp_delete_all_initiators(struct spdk_iscsi_init_grp *ig)
{ {
struct spdk_iscsi_initiator_name *iname, *tmp; struct spdk_iscsi_initiator_name *iname, *tmp;
@ -173,13 +174,13 @@ spdk_iscsi_init_grp_delete_all_initiators(struct spdk_iscsi_init_grp *ig)
} }
static int static int
spdk_iscsi_init_grp_delete_initiators(struct spdk_iscsi_init_grp *ig, int num_inames, char **inames) iscsi_init_grp_delete_initiators(struct spdk_iscsi_init_grp *ig, int num_inames, char **inames)
{ {
int i; int i;
int rc; int rc;
for (i = 0; i < num_inames; i++) { for (i = 0; i < num_inames; i++) {
rc = spdk_iscsi_init_grp_delete_initiator(ig, inames[i]); rc = iscsi_init_grp_delete_initiator(ig, inames[i]);
if (rc < 0) { if (rc < 0) {
goto cleanup; goto cleanup;
} }
@ -188,9 +189,9 @@ spdk_iscsi_init_grp_delete_initiators(struct spdk_iscsi_init_grp *ig, int num_in
cleanup: cleanup:
for (; i > 0; --i) { for (; i > 0; --i) {
rc = spdk_iscsi_init_grp_add_initiator(ig, inames[i - 1]); rc = iscsi_init_grp_add_initiator(ig, inames[i - 1]);
if (rc != 0) { if (rc != 0) {
spdk_iscsi_init_grp_delete_all_initiators(ig); iscsi_init_grp_delete_all_initiators(ig);
break; break;
} }
} }
@ -198,7 +199,7 @@ cleanup:
} }
static struct spdk_iscsi_initiator_netmask * static struct spdk_iscsi_initiator_netmask *
spdk_iscsi_init_grp_find_netmask(struct spdk_iscsi_init_grp *ig, const char *mask) iscsi_init_grp_find_netmask(struct spdk_iscsi_init_grp *ig, const char *mask)
{ {
struct spdk_iscsi_initiator_netmask *netmask; struct spdk_iscsi_initiator_netmask *netmask;
@ -211,7 +212,7 @@ spdk_iscsi_init_grp_find_netmask(struct spdk_iscsi_init_grp *ig, const char *mas
} }
static int static int
spdk_iscsi_init_grp_add_netmask(struct spdk_iscsi_init_grp *ig, char *mask) iscsi_init_grp_add_netmask(struct spdk_iscsi_init_grp *ig, char *mask)
{ {
struct spdk_iscsi_initiator_netmask *imask; struct spdk_iscsi_initiator_netmask *imask;
char *p; char *p;
@ -221,7 +222,7 @@ spdk_iscsi_init_grp_add_netmask(struct spdk_iscsi_init_grp *ig, char *mask)
return -EPERM; return -EPERM;
} }
imask = spdk_iscsi_init_grp_find_netmask(ig, mask); imask = iscsi_init_grp_find_netmask(ig, mask);
if (imask != NULL) { if (imask != NULL) {
return -EEXIST; return -EEXIST;
} }
@ -255,11 +256,11 @@ spdk_iscsi_init_grp_add_netmask(struct spdk_iscsi_init_grp *ig, char *mask)
} }
static int static int
spdk_iscsi_init_grp_delete_netmask(struct spdk_iscsi_init_grp *ig, char *mask) iscsi_init_grp_delete_netmask(struct spdk_iscsi_init_grp *ig, char *mask)
{ {
struct spdk_iscsi_initiator_netmask *imask; struct spdk_iscsi_initiator_netmask *imask;
imask = spdk_iscsi_init_grp_find_netmask(ig, mask); imask = iscsi_init_grp_find_netmask(ig, mask);
if (imask == NULL) { if (imask == NULL) {
return -ENOENT; return -ENOENT;
} }
@ -272,13 +273,13 @@ spdk_iscsi_init_grp_delete_netmask(struct spdk_iscsi_init_grp *ig, char *mask)
} }
static int static int
spdk_iscsi_init_grp_add_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, char **imasks) iscsi_init_grp_add_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, char **imasks)
{ {
int i; int i;
int rc; int rc;
for (i = 0; i < num_imasks; i++) { for (i = 0; i < num_imasks; i++) {
rc = spdk_iscsi_init_grp_add_netmask(ig, imasks[i]); rc = iscsi_init_grp_add_netmask(ig, imasks[i]);
if (rc != 0) { if (rc != 0) {
goto cleanup; goto cleanup;
} }
@ -287,13 +288,13 @@ spdk_iscsi_init_grp_add_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks,
cleanup: cleanup:
for (; i > 0; --i) { for (; i > 0; --i) {
spdk_iscsi_init_grp_delete_netmask(ig, imasks[i - 1]); iscsi_init_grp_delete_netmask(ig, imasks[i - 1]);
} }
return rc; return rc;
} }
static void static void
spdk_iscsi_init_grp_delete_all_netmasks(struct spdk_iscsi_init_grp *ig) iscsi_init_grp_delete_all_netmasks(struct spdk_iscsi_init_grp *ig)
{ {
struct spdk_iscsi_initiator_netmask *imask, *tmp; struct spdk_iscsi_initiator_netmask *imask, *tmp;
@ -306,13 +307,13 @@ spdk_iscsi_init_grp_delete_all_netmasks(struct spdk_iscsi_init_grp *ig)
} }
static int static int
spdk_iscsi_init_grp_delete_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, char **imasks) iscsi_init_grp_delete_netmasks(struct spdk_iscsi_init_grp *ig, int num_imasks, char **imasks)
{ {
int i; int i;
int rc; int rc;
for (i = 0; i < num_imasks; i++) { for (i = 0; i < num_imasks; i++) {
rc = spdk_iscsi_init_grp_delete_netmask(ig, imasks[i]); rc = iscsi_init_grp_delete_netmask(ig, imasks[i]);
if (rc != 0) { if (rc != 0) {
goto cleanup; goto cleanup;
} }
@ -321,9 +322,9 @@ spdk_iscsi_init_grp_delete_netmasks(struct spdk_iscsi_init_grp *ig, int num_imas
cleanup: cleanup:
for (; i > 0; --i) { for (; i > 0; --i) {
rc = spdk_iscsi_init_grp_add_netmask(ig, imasks[i - 1]); rc = iscsi_init_grp_add_netmask(ig, imasks[i - 1]);
if (rc != 0) { if (rc != 0) {
spdk_iscsi_init_grp_delete_all_netmasks(ig); iscsi_init_grp_delete_all_netmasks(ig);
break; break;
} }
} }
@ -332,7 +333,7 @@ cleanup:
/* Read spdk iscsi target's config file and create initiator group */ /* Read spdk iscsi target's config file and create initiator group */
static int static int
spdk_iscsi_parse_init_grp(struct spdk_conf_section *sp) iscsi_parse_init_grp(struct spdk_conf_section *sp)
{ {
int i, rc = 0; int i, rc = 0;
const char *val = NULL; const char *val = NULL;
@ -483,21 +484,21 @@ spdk_iscsi_init_grp_create_from_initiator_list(int tag,
"add initiator group (from initiator list) tag=%d, #initiators=%d, #masks=%d\n", "add initiator group (from initiator list) tag=%d, #initiators=%d, #masks=%d\n",
tag, num_initiator_names, num_initiator_masks); tag, num_initiator_names, num_initiator_masks);
ig = spdk_iscsi_init_grp_create(tag); ig = iscsi_init_grp_create(tag);
if (!ig) { if (!ig) {
SPDK_ERRLOG("initiator group create error (%d)\n", tag); SPDK_ERRLOG("initiator group create error (%d)\n", tag);
return rc; return rc;
} }
rc = spdk_iscsi_init_grp_add_initiators(ig, num_initiator_names, rc = iscsi_init_grp_add_initiators(ig, num_initiator_names,
initiator_names); initiator_names);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("add initiator name error\n"); SPDK_ERRLOG("add initiator name error\n");
goto cleanup; goto cleanup;
} }
rc = spdk_iscsi_init_grp_add_netmasks(ig, num_initiator_masks, rc = iscsi_init_grp_add_netmasks(ig, num_initiator_masks,
initiator_masks); initiator_masks);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("add initiator netmask error\n"); SPDK_ERRLOG("add initiator netmask error\n");
goto cleanup; goto cleanup;
@ -537,19 +538,19 @@ spdk_iscsi_init_grp_add_initiators_from_initiator_list(int tag,
return rc; return rc;
} }
rc = spdk_iscsi_init_grp_add_initiators(ig, num_initiator_names, rc = iscsi_init_grp_add_initiators(ig, num_initiator_names,
initiator_names); initiator_names);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("add initiator name error\n"); SPDK_ERRLOG("add initiator name error\n");
goto error; goto error;
} }
rc = spdk_iscsi_init_grp_add_netmasks(ig, num_initiator_masks, rc = iscsi_init_grp_add_netmasks(ig, num_initiator_masks,
initiator_masks); initiator_masks);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("add initiator netmask error\n"); SPDK_ERRLOG("add initiator netmask error\n");
spdk_iscsi_init_grp_delete_initiators(ig, num_initiator_names, iscsi_init_grp_delete_initiators(ig, num_initiator_names,
initiator_names); initiator_names);
} }
error: error:
@ -579,19 +580,19 @@ spdk_iscsi_init_grp_delete_initiators_from_initiator_list(int tag,
return rc; return rc;
} }
rc = spdk_iscsi_init_grp_delete_initiators(ig, num_initiator_names, rc = iscsi_init_grp_delete_initiators(ig, num_initiator_names,
initiator_names); initiator_names);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("delete initiator name error\n"); SPDK_ERRLOG("delete initiator name error\n");
goto error; goto error;
} }
rc = spdk_iscsi_init_grp_delete_netmasks(ig, num_initiator_masks, rc = iscsi_init_grp_delete_netmasks(ig, num_initiator_masks,
initiator_masks); initiator_masks);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("delete initiator netmask error\n"); SPDK_ERRLOG("delete initiator netmask error\n");
spdk_iscsi_init_grp_add_initiators(ig, num_initiator_names, iscsi_init_grp_add_initiators(ig, num_initiator_names,
initiator_names); initiator_names);
goto error; goto error;
} }
@ -607,8 +608,8 @@ spdk_iscsi_init_grp_destroy(struct spdk_iscsi_init_grp *ig)
return; return;
} }
spdk_iscsi_init_grp_delete_all_initiators(ig); iscsi_init_grp_delete_all_initiators(ig);
spdk_iscsi_init_grp_delete_all_netmasks(ig); iscsi_init_grp_delete_all_netmasks(ig);
free(ig); free(ig);
}; };
@ -639,7 +640,7 @@ spdk_iscsi_parse_init_grps(void)
SPDK_ERRLOG("Group 0 is invalid\n"); SPDK_ERRLOG("Group 0 is invalid\n");
return -1; return -1;
} }
rc = spdk_iscsi_parse_init_grp(sp); rc = iscsi_parse_init_grp(sp);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("parse_init_group() failed\n"); SPDK_ERRLOG("parse_init_group() failed\n");
return -1; return -1;
@ -731,8 +732,8 @@ spdk_iscsi_init_grps_config_text(FILE *fp)
} }
static void static void
spdk_iscsi_init_grp_info_json(struct spdk_iscsi_init_grp *ig, iscsi_init_grp_info_json(struct spdk_iscsi_init_grp *ig,
struct spdk_json_write_ctx *w) struct spdk_json_write_ctx *w)
{ {
struct spdk_iscsi_initiator_name *iname; struct spdk_iscsi_initiator_name *iname;
struct spdk_iscsi_initiator_netmask *imask; struct spdk_iscsi_initiator_netmask *imask;
@ -757,15 +758,15 @@ spdk_iscsi_init_grp_info_json(struct spdk_iscsi_init_grp *ig,
} }
static void static void
spdk_iscsi_init_grp_config_json(struct spdk_iscsi_init_grp *ig, iscsi_init_grp_config_json(struct spdk_iscsi_init_grp *ig,
struct spdk_json_write_ctx *w) struct spdk_json_write_ctx *w)
{ {
spdk_json_write_object_begin(w); spdk_json_write_object_begin(w);
spdk_json_write_named_string(w, "method", "add_initiator_group"); spdk_json_write_named_string(w, "method", "add_initiator_group");
spdk_json_write_name(w, "params"); spdk_json_write_name(w, "params");
spdk_iscsi_init_grp_info_json(ig, w); iscsi_init_grp_info_json(ig, w);
spdk_json_write_object_end(w); spdk_json_write_object_end(w);
} }
@ -776,7 +777,7 @@ spdk_iscsi_init_grps_info_json(struct spdk_json_write_ctx *w)
struct spdk_iscsi_init_grp *ig; struct spdk_iscsi_init_grp *ig;
TAILQ_FOREACH(ig, &g_spdk_iscsi.ig_head, tailq) { TAILQ_FOREACH(ig, &g_spdk_iscsi.ig_head, tailq) {
spdk_iscsi_init_grp_info_json(ig, w); iscsi_init_grp_info_json(ig, w);
} }
} }
@ -786,6 +787,6 @@ spdk_iscsi_init_grps_config_json(struct spdk_json_write_ctx *w)
struct spdk_iscsi_init_grp *ig; struct spdk_iscsi_init_grp *ig;
TAILQ_FOREACH(ig, &g_spdk_iscsi.ig_head, tailq) { TAILQ_FOREACH(ig, &g_spdk_iscsi.ig_head, tailq) {
spdk_iscsi_init_grp_config_json(ig, w); iscsi_init_grp_config_json(ig, w);
} }
} }

687
lib/iscsi/iscsi.c
View File

File diff suppressed because it is too large Load Diff

165
lib/iscsi/iscsi_subsystem.c
View File

@ -87,7 +87,7 @@ static void *g_fini_cb_arg;
"\n" "\n"
static void static void
spdk_iscsi_globals_config_text(FILE *fp) iscsi_globals_config_text(FILE *fp)
{ {
const char *authmethod = "None"; const char *authmethod = "None";
char authgroup[32] = "None"; char authgroup[32] = "None";
@ -126,8 +126,8 @@ spdk_iscsi_globals_config_text(FILE *fp)
#define ISCSI_DATA_BUFFER_MASK (ISCSI_DATA_BUFFER_ALIGNMENT - 1) #define ISCSI_DATA_BUFFER_MASK (ISCSI_DATA_BUFFER_ALIGNMENT - 1)
static void static void
spdk_mobj_ctor(struct spdk_mempool *mp, __attribute__((unused)) void *arg, mobj_ctor(struct spdk_mempool *mp, __attribute__((unused)) void *arg,
void *_m, __attribute__((unused)) unsigned i) void *_m, __attribute__((unused)) unsigned i)
{ {
struct spdk_mobj *m = _m; struct spdk_mobj *m = _m;
@ -142,7 +142,8 @@ spdk_mobj_ctor(struct spdk_mempool *mp, __attribute__((unused)) void *arg,
#define IMMEDIATE_DATA_POOL_SIZE(iscsi) (iscsi->MaxConnections * 128) #define IMMEDIATE_DATA_POOL_SIZE(iscsi) (iscsi->MaxConnections * 128)
#define DATA_OUT_POOL_SIZE(iscsi) (iscsi->MaxConnections * MAX_DATA_OUT_PER_CONNECTION) #define DATA_OUT_POOL_SIZE(iscsi) (iscsi->MaxConnections * MAX_DATA_OUT_PER_CONNECTION)
static int spdk_iscsi_initialize_pdu_pool(void) static int
iscsi_initialize_pdu_pool(void)
{ {
struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi; struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi;
int imm_mobj_size = SPDK_BDEV_BUF_SIZE_WITH_MD(spdk_get_max_immediate_data_size()) + int imm_mobj_size = SPDK_BDEV_BUF_SIZE_WITH_MD(spdk_get_max_immediate_data_size()) +
@ -164,7 +165,7 @@ static int spdk_iscsi_initialize_pdu_pool(void)
IMMEDIATE_DATA_POOL_SIZE(iscsi), IMMEDIATE_DATA_POOL_SIZE(iscsi),
imm_mobj_size, 256, imm_mobj_size, 256,
spdk_env_get_socket_id(spdk_env_get_current_core()), spdk_env_get_socket_id(spdk_env_get_current_core()),
spdk_mobj_ctor, NULL); mobj_ctor, NULL);
if (!iscsi->pdu_immediate_data_pool) { if (!iscsi->pdu_immediate_data_pool) {
SPDK_ERRLOG("create PDU immediate data pool failed\n"); SPDK_ERRLOG("create PDU immediate data pool failed\n");
return -1; return -1;
@ -174,7 +175,7 @@ static int spdk_iscsi_initialize_pdu_pool(void)
DATA_OUT_POOL_SIZE(iscsi), DATA_OUT_POOL_SIZE(iscsi),
dout_mobj_size, 256, dout_mobj_size, 256,
spdk_env_get_socket_id(spdk_env_get_current_core()), spdk_env_get_socket_id(spdk_env_get_current_core()),
spdk_mobj_ctor, NULL); mobj_ctor, NULL);
if (!iscsi->pdu_data_out_pool) { if (!iscsi->pdu_data_out_pool) {
SPDK_ERRLOG("create PDU data out pool failed\n"); SPDK_ERRLOG("create PDU data out pool failed\n");
return -1; return -1;
@ -183,8 +184,9 @@ static int spdk_iscsi_initialize_pdu_pool(void)
return 0; return 0;
} }
static void spdk_iscsi_sess_ctor(struct spdk_mempool *pool, void *arg, static void
void *session_buf, unsigned index) iscsi_sess_ctor(struct spdk_mempool *pool, void *arg, void *session_buf,
unsigned index)
{ {
struct spdk_iscsi_globals *iscsi = arg; struct spdk_iscsi_globals *iscsi = arg;
struct spdk_iscsi_sess *sess = session_buf; struct spdk_iscsi_sess *sess = session_buf;
@ -198,7 +200,7 @@ static void spdk_iscsi_sess_ctor(struct spdk_mempool *pool, void *arg,
#define DEFAULT_TASK_POOL_SIZE 32768 #define DEFAULT_TASK_POOL_SIZE 32768
static int static int
spdk_iscsi_initialize_task_pool(void) iscsi_initialize_task_pool(void)
{ {
struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi; struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi;
@ -216,7 +218,8 @@ spdk_iscsi_initialize_task_pool(void)
} }
#define SESSION_POOL_SIZE(iscsi) (iscsi->MaxSessions) #define SESSION_POOL_SIZE(iscsi) (iscsi->MaxSessions)
static int spdk_iscsi_initialize_session_pool(void) static int
iscsi_initialize_session_pool(void)
{ {
struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi; struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi;
@ -224,7 +227,7 @@ static int spdk_iscsi_initialize_session_pool(void)
SESSION_POOL_SIZE(iscsi), SESSION_POOL_SIZE(iscsi),
sizeof(struct spdk_iscsi_sess), 0, sizeof(struct spdk_iscsi_sess), 0,
SPDK_ENV_SOCKET_ID_ANY, SPDK_ENV_SOCKET_ID_ANY,
spdk_iscsi_sess_ctor, iscsi); iscsi_sess_ctor, iscsi);
if (!iscsi->session_pool) { if (!iscsi->session_pool) {
SPDK_ERRLOG("create session pool failed\n"); SPDK_ERRLOG("create session pool failed\n");
return -1; return -1;
@ -234,17 +237,17 @@ static int spdk_iscsi_initialize_session_pool(void)
} }
static int static int
spdk_iscsi_initialize_all_pools(void) iscsi_initialize_all_pools(void)
{ {
if (spdk_iscsi_initialize_pdu_pool() != 0) { if (iscsi_initialize_pdu_pool() != 0) {
return -1; return -1;
} }
if (spdk_iscsi_initialize_session_pool() != 0) { if (iscsi_initialize_session_pool() != 0) {
return -1; return -1;
} }
if (spdk_iscsi_initialize_task_pool() != 0) { if (iscsi_initialize_task_pool() != 0) {
return -1; return -1;
} }
@ -252,7 +255,7 @@ spdk_iscsi_initialize_all_pools(void)
} }
static void static void
spdk_iscsi_check_pool(struct spdk_mempool *pool, size_t count) iscsi_check_pool(struct spdk_mempool *pool, size_t count)
{ {
if (spdk_mempool_count(pool) != count) { if (spdk_mempool_count(pool) != count) {
SPDK_ERRLOG("spdk_mempool_count(%s) == %zu, should be %zu\n", SPDK_ERRLOG("spdk_mempool_count(%s) == %zu, should be %zu\n",
@ -261,19 +264,19 @@ spdk_iscsi_check_pool(struct spdk_mempool *pool, size_t count)
} }
static void static void
spdk_iscsi_check_pools(void) iscsi_check_pools(void)
{ {
struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi; struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi;
spdk_iscsi_check_pool(iscsi->pdu_pool, PDU_POOL_SIZE(iscsi)); iscsi_check_pool(iscsi->pdu_pool, PDU_POOL_SIZE(iscsi));
spdk_iscsi_check_pool(iscsi->session_pool, SESSION_POOL_SIZE(iscsi)); iscsi_check_pool(iscsi->session_pool, SESSION_POOL_SIZE(iscsi));
spdk_iscsi_check_pool(iscsi->pdu_immediate_data_pool, IMMEDIATE_DATA_POOL_SIZE(iscsi)); iscsi_check_pool(iscsi->pdu_immediate_data_pool, IMMEDIATE_DATA_POOL_SIZE(iscsi));
spdk_iscsi_check_pool(iscsi->pdu_data_out_pool, DATA_OUT_POOL_SIZE(iscsi)); iscsi_check_pool(iscsi->pdu_data_out_pool, DATA_OUT_POOL_SIZE(iscsi));
spdk_iscsi_check_pool(iscsi->task_pool, DEFAULT_TASK_POOL_SIZE); iscsi_check_pool(iscsi->task_pool, DEFAULT_TASK_POOL_SIZE);
} }
static void static void
spdk_iscsi_free_pools(void) iscsi_free_pools(void)
{ {
struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi; struct spdk_iscsi_globals *iscsi = &g_spdk_iscsi;
@ -328,7 +331,7 @@ struct spdk_iscsi_pdu *spdk_get_pdu(void)
} }
static void static void
spdk_iscsi_log_globals(void) iscsi_log_globals(void)
{ {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "AuthFile %s\n", SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "AuthFile %s\n",
g_spdk_iscsi.authfile ? g_spdk_iscsi.authfile : "(none)"); g_spdk_iscsi.authfile ? g_spdk_iscsi.authfile : "(none)");
@ -379,7 +382,7 @@ spdk_iscsi_log_globals(void)
} }
static void static void
spdk_iscsi_opts_init(struct spdk_iscsi_opts *opts) iscsi_opts_init(struct spdk_iscsi_opts *opts)
{ {
opts->MaxSessions = DEFAULT_MAX_SESSIONS; opts->MaxSessions = DEFAULT_MAX_SESSIONS;
opts->MaxConnectionsPerSession = DEFAULT_MAX_CONNECTIONS_PER_SESSION; opts->MaxConnectionsPerSession = DEFAULT_MAX_CONNECTIONS_PER_SESSION;
@ -412,7 +415,7 @@ spdk_iscsi_opts_alloc(void)
return NULL; return NULL;
} }
spdk_iscsi_opts_init(opts); iscsi_opts_init(opts);
return opts; return opts;
} }
@ -477,8 +480,8 @@ spdk_iscsi_opts_copy(struct spdk_iscsi_opts *src)
} }
static int static int
spdk_iscsi_read_config_file_params(struct spdk_conf_section *sp, iscsi_read_config_file_params(struct spdk_conf_section *sp,
struct spdk_iscsi_opts *opts) struct spdk_iscsi_opts *opts)
{ {
const char *val; const char *val;
int MaxSessions; int MaxSessions;
@ -625,7 +628,7 @@ spdk_iscsi_read_config_file_params(struct spdk_conf_section *sp,
} }
static int static int
spdk_iscsi_opts_verify(struct spdk_iscsi_opts *opts) iscsi_opts_verify(struct spdk_iscsi_opts *opts)
{ {
if (!opts->nodebase) { if (!opts->nodebase) {
opts->nodebase = strdup(SPDK_ISCSI_DEFAULT_NODEBASE); opts->nodebase = strdup(SPDK_ISCSI_DEFAULT_NODEBASE);
@ -703,7 +706,7 @@ spdk_iscsi_opts_verify(struct spdk_iscsi_opts *opts)
} }
static int static int
spdk_iscsi_parse_options(struct spdk_iscsi_opts **popts) iscsi_parse_options(struct spdk_iscsi_opts **popts)
{ {
struct spdk_iscsi_opts *opts; struct spdk_iscsi_opts *opts;
struct spdk_conf_section *sp; struct spdk_conf_section *sp;
@ -716,13 +719,13 @@ spdk_iscsi_parse_options(struct spdk_iscsi_opts **popts)
} }
/* Process parameters */ /* Process parameters */
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_read_config_file_parmas\n"); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "iscsi_read_config_file_parmas\n");
sp = spdk_conf_find_section(NULL, "iSCSI"); sp = spdk_conf_find_section(NULL, "iSCSI");
if (sp != NULL) { if (sp != NULL) {
rc = spdk_iscsi_read_config_file_params(sp, opts); rc = iscsi_read_config_file_params(sp, opts);
if (rc != 0) { if (rc != 0) {
free(opts); free(opts);
SPDK_ERRLOG("spdk_iscsi_read_config_file_params() failed\n"); SPDK_ERRLOG("iscsi_read_config_file_params() failed\n");
return rc; return rc;
} }
} }
@ -733,11 +736,11 @@ spdk_iscsi_parse_options(struct spdk_iscsi_opts **popts)
} }
static int static int
spdk_iscsi_set_global_params(struct spdk_iscsi_opts *opts) iscsi_set_global_params(struct spdk_iscsi_opts *opts)
{ {
int rc; int rc;
rc = spdk_iscsi_opts_verify(opts); rc = iscsi_opts_verify(opts);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("spdk_iscsi_opts_verify() failed\n"); SPDK_ERRLOG("spdk_iscsi_opts_verify() failed\n");
return rc; return rc;
@ -775,7 +778,7 @@ spdk_iscsi_set_global_params(struct spdk_iscsi_opts *opts)
spdk_iscsi_conn_set_min_per_core(opts->min_connections_per_core); spdk_iscsi_conn_set_min_per_core(opts->min_connections_per_core);
spdk_iscsi_log_globals(); iscsi_log_globals();
return 0; return 0;
} }
@ -957,7 +960,7 @@ spdk_iscsi_find_auth_group_by_tag(int32_t tag)
} }
static void static void
spdk_iscsi_auth_groups_destroy(void) iscsi_auth_groups_destroy(void)
{ {
struct spdk_iscsi_auth_group *group, *tmp; struct spdk_iscsi_auth_group *group, *tmp;
@ -967,7 +970,7 @@ spdk_iscsi_auth_groups_destroy(void)
} }
static int static int
spdk_iscsi_parse_auth_group(struct spdk_conf_section *sp) iscsi_parse_auth_group(struct spdk_conf_section *sp)
{ {
int rc; int rc;
int i; int i;
@ -1011,7 +1014,7 @@ spdk_iscsi_parse_auth_group(struct spdk_conf_section *sp)
} }
static int static int
spdk_iscsi_parse_auth_info(void) iscsi_parse_auth_info(void)
{ {
struct spdk_conf *config; struct spdk_conf *config;
struct spdk_conf_section *sp; struct spdk_conf_section *sp;
@ -1035,15 +1038,15 @@ spdk_iscsi_parse_auth_info(void)
if (spdk_conf_section_match_prefix(sp, "AuthGroup")) { if (spdk_conf_section_match_prefix(sp, "AuthGroup")) {
if (spdk_conf_section_get_num(sp) == 0) { if (spdk_conf_section_get_num(sp) == 0) {
SPDK_ERRLOG("Group 0 is invalid\n"); SPDK_ERRLOG("Group 0 is invalid\n");
spdk_iscsi_auth_groups_destroy(); iscsi_auth_groups_destroy();
spdk_conf_free(config); spdk_conf_free(config);
return -EINVAL; return -EINVAL;
} }
rc = spdk_iscsi_parse_auth_group(sp); rc = iscsi_parse_auth_group(sp);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("parse_auth_group() failed\n"); SPDK_ERRLOG("parse_auth_group() failed\n");
spdk_iscsi_auth_groups_destroy(); iscsi_auth_groups_destroy();
spdk_conf_free(config); spdk_conf_free(config);
return rc; return rc;
} }
@ -1056,7 +1059,7 @@ spdk_iscsi_parse_auth_info(void)
} }
static struct spdk_iscsi_auth_secret * static struct spdk_iscsi_auth_secret *
spdk_iscsi_find_auth_secret(const char *authuser, int ag_tag) iscsi_find_auth_secret(const char *authuser, int ag_tag)
{ {
struct spdk_iscsi_auth_group *group; struct spdk_iscsi_auth_group *group;
struct spdk_iscsi_auth_secret *_secret; struct spdk_iscsi_auth_secret *_secret;
@ -1093,7 +1096,7 @@ spdk_iscsi_chap_get_authinfo(struct iscsi_chap_auth *auth, const char *authuser,
pthread_mutex_lock(&g_spdk_iscsi.mutex); pthread_mutex_lock(&g_spdk_iscsi.mutex);
_secret = spdk_iscsi_find_auth_secret(authuser, ag_tag); _secret = iscsi_find_auth_secret(authuser, ag_tag);
if (_secret == NULL) { if (_secret == NULL) {
pthread_mutex_unlock(&g_spdk_iscsi.mutex); pthread_mutex_unlock(&g_spdk_iscsi.mutex);
@ -1115,19 +1118,19 @@ spdk_iscsi_chap_get_authinfo(struct iscsi_chap_auth *auth, const char *authuser,
} }
static int static int
spdk_iscsi_initialize_global_params(void) iscsi_initialize_global_params(void)
{ {
int rc; int rc;
if (!g_spdk_iscsi_opts) { if (!g_spdk_iscsi_opts) {
rc = spdk_iscsi_parse_options(&g_spdk_iscsi_opts); rc = iscsi_parse_options(&g_spdk_iscsi_opts);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("spdk_iscsi_parse_options() failed\n"); SPDK_ERRLOG("spdk_iscsi_parse_options() failed\n");
return rc; return rc;
} }
} }
rc = spdk_iscsi_set_global_params(g_spdk_iscsi_opts); rc = iscsi_set_global_params(g_spdk_iscsi_opts);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("spdk_iscsi_set_global_params() failed\n"); SPDK_ERRLOG("spdk_iscsi_set_global_params() failed\n");
} }
@ -1139,7 +1142,7 @@ spdk_iscsi_initialize_global_params(void)
} }
static void static void
spdk_iscsi_init_complete(int rc) iscsi_init_complete(int rc)
{ {
spdk_iscsi_init_cb cb_fn = g_init_cb_fn; spdk_iscsi_init_cb cb_fn = g_init_cb_fn;
void *cb_arg = g_init_cb_arg; void *cb_arg = g_init_cb_arg;
@ -1151,7 +1154,7 @@ spdk_iscsi_init_complete(int rc)
} }
static int static int
spdk_iscsi_poll_group_poll(void *ctx) iscsi_poll_group_poll(void *ctx)
{ {
struct spdk_iscsi_poll_group *group = ctx; struct spdk_iscsi_poll_group *group = ctx;
struct spdk_iscsi_conn *conn, *tmp; struct spdk_iscsi_conn *conn, *tmp;
@ -1176,7 +1179,7 @@ spdk_iscsi_poll_group_poll(void *ctx)
} }
static int static int
spdk_iscsi_poll_group_handle_nop(void *ctx) iscsi_poll_group_handle_nop(void *ctx)
{ {
struct spdk_iscsi_poll_group *group = ctx; struct spdk_iscsi_poll_group *group = ctx;
struct spdk_iscsi_conn *conn, *tmp; struct spdk_iscsi_conn *conn, *tmp;
@ -1201,9 +1204,9 @@ iscsi_create_poll_group(void *ctx)
pg->sock_group = spdk_sock_group_create(); pg->sock_group = spdk_sock_group_create();
assert(pg->sock_group != NULL); assert(pg->sock_group != NULL);
pg->poller = spdk_poller_register(spdk_iscsi_poll_group_poll, pg, 0); pg->poller = spdk_poller_register(iscsi_poll_group_poll, pg, 0);
/* set the period to 1 sec */ /* set the period to 1 sec */
pg->nop_poller = spdk_poller_register(spdk_iscsi_poll_group_handle_nop, pg, 1000000); pg->nop_poller = spdk_poller_register(iscsi_poll_group_handle_nop, pg, 1000000);
} }
static void static void
@ -1222,14 +1225,14 @@ iscsi_unregister_poll_group(void *ctx)
} }
static void static void
spdk_initialize_iscsi_poll_group(spdk_msg_fn cpl) initialize_iscsi_poll_group(spdk_msg_fn cpl)
{ {
size_t g_num_poll_groups = spdk_env_get_last_core() + 1; size_t g_num_poll_groups = spdk_env_get_last_core() + 1;
g_spdk_iscsi.poll_group = calloc(g_num_poll_groups, sizeof(struct spdk_iscsi_poll_group)); g_spdk_iscsi.poll_group = calloc(g_num_poll_groups, sizeof(struct spdk_iscsi_poll_group));
if (!g_spdk_iscsi.poll_group) { if (!g_spdk_iscsi.poll_group) {
SPDK_ERRLOG("Failed to allocated iscsi poll group\n"); SPDK_ERRLOG("Failed to allocated iscsi poll group\n");
spdk_iscsi_init_complete(-1); iscsi_init_complete(-1);
return; return;
} }
@ -1238,7 +1241,7 @@ spdk_initialize_iscsi_poll_group(spdk_msg_fn cpl)
} }
static void static void
spdk_iscsi_parse_configuration(void *ctx) iscsi_parse_configuration(void *ctx)
{ {
int rc; int rc;
@ -1261,7 +1264,7 @@ spdk_iscsi_parse_configuration(void *ctx)
if (g_spdk_iscsi.authfile != NULL) { if (g_spdk_iscsi.authfile != NULL) {
if (access(g_spdk_iscsi.authfile, R_OK) == 0) { if (access(g_spdk_iscsi.authfile, R_OK) == 0) {
rc = spdk_iscsi_parse_auth_info(); rc = iscsi_parse_auth_info();
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("spdk_iscsi_parse_auth_info() failed\n"); SPDK_ERRLOG("spdk_iscsi_parse_auth_info() failed\n");
} }
@ -1272,15 +1275,15 @@ spdk_iscsi_parse_configuration(void *ctx)
} }
end: end:
spdk_iscsi_init_complete(rc); iscsi_init_complete(rc);
} }
static int static int
spdk_iscsi_parse_globals(void) iscsi_parse_globals(void)
{ {
int rc; int rc;
rc = spdk_iscsi_initialize_global_params(); rc = iscsi_initialize_global_params();
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("spdk_iscsi_initialize_iscsi_global_params() failed\n"); SPDK_ERRLOG("spdk_iscsi_initialize_iscsi_global_params() failed\n");
return rc; return rc;
@ -1300,7 +1303,7 @@ spdk_iscsi_parse_globals(void)
*/ */
g_spdk_iscsi.MaxConnections = g_spdk_iscsi.MaxSessions; g_spdk_iscsi.MaxConnections = g_spdk_iscsi.MaxSessions;
rc = spdk_iscsi_initialize_all_pools(); rc = iscsi_initialize_all_pools();
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("spdk_initialize_all_pools() failed\n"); SPDK_ERRLOG("spdk_initialize_all_pools() failed\n");
return -1; return -1;
@ -1312,7 +1315,7 @@ spdk_iscsi_parse_globals(void)
return rc; return rc;
} }
spdk_initialize_iscsi_poll_group(spdk_iscsi_parse_configuration); initialize_iscsi_poll_group(iscsi_parse_configuration);
return 0; return 0;
} }
@ -1325,10 +1328,10 @@ spdk_iscsi_init(spdk_iscsi_init_cb cb_fn, void *cb_arg)
g_init_cb_fn = cb_fn; g_init_cb_fn = cb_fn;
g_init_cb_arg = cb_arg; g_init_cb_arg = cb_arg;
rc = spdk_iscsi_parse_globals(); rc = iscsi_parse_globals();
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("spdk_iscsi_parse_globals() failed\n"); SPDK_ERRLOG("spdk_iscsi_parse_globals() failed\n");
spdk_iscsi_init_complete(-1); iscsi_init_complete(-1);
} }
/* /*
@ -1349,15 +1352,15 @@ spdk_iscsi_fini(spdk_iscsi_fini_cb cb_fn, void *cb_arg)
} }
static void static void
spdk_iscsi_fini_done(void *arg) iscsi_fini_done(void *arg)
{ {
spdk_iscsi_check_pools(); iscsi_check_pools();
spdk_iscsi_free_pools(); iscsi_free_pools();
spdk_iscsi_shutdown_tgt_nodes(); spdk_iscsi_shutdown_tgt_nodes();
spdk_iscsi_init_grps_destroy(); spdk_iscsi_init_grps_destroy();
spdk_iscsi_portal_grps_destroy(); spdk_iscsi_portal_grps_destroy();
spdk_iscsi_auth_groups_destroy(); iscsi_auth_groups_destroy();
free(g_spdk_iscsi.authfile); free(g_spdk_iscsi.authfile);
free(g_spdk_iscsi.nodebase); free(g_spdk_iscsi.nodebase);
free(g_spdk_iscsi.poll_group); free(g_spdk_iscsi.poll_group);
@ -1370,16 +1373,16 @@ void
spdk_shutdown_iscsi_conns_done(void) spdk_shutdown_iscsi_conns_done(void)
{ {
if (g_spdk_iscsi.poll_group) { if (g_spdk_iscsi.poll_group) {
spdk_for_each_thread(iscsi_unregister_poll_group, NULL, spdk_iscsi_fini_done); spdk_for_each_thread(iscsi_unregister_poll_group, NULL, iscsi_fini_done);
} else { } else {
spdk_iscsi_fini_done(NULL); iscsi_fini_done(NULL);
} }
} }
void void
spdk_iscsi_config_text(FILE *fp) spdk_iscsi_config_text(FILE *fp)
{ {
spdk_iscsi_globals_config_text(fp); iscsi_globals_config_text(fp);
spdk_iscsi_portal_grps_config_text(fp); spdk_iscsi_portal_grps_config_text(fp);
spdk_iscsi_init_grps_config_text(fp); spdk_iscsi_init_grps_config_text(fp);
spdk_iscsi_tgt_nodes_config_text(fp); spdk_iscsi_tgt_nodes_config_text(fp);
@ -1427,8 +1430,8 @@ spdk_iscsi_opts_info_json(struct spdk_json_write_ctx *w)
} }
static void static void
spdk_iscsi_auth_group_info_json(struct spdk_iscsi_auth_group *group, iscsi_auth_group_info_json(struct spdk_iscsi_auth_group *group,
struct spdk_json_write_ctx *w) struct spdk_json_write_ctx *w)
{ {
struct spdk_iscsi_auth_secret *_secret; struct spdk_iscsi_auth_secret *_secret;
@ -1456,15 +1459,15 @@ spdk_iscsi_auth_group_info_json(struct spdk_iscsi_auth_group *group,
} }
static void static void
spdk_iscsi_auth_group_config_json(struct spdk_iscsi_auth_group *group, iscsi_auth_group_config_json(struct spdk_iscsi_auth_group *group,
struct spdk_json_write_ctx *w) struct spdk_json_write_ctx *w)
{ {
spdk_json_write_object_begin(w); spdk_json_write_object_begin(w);
spdk_json_write_named_string(w, "method", "add_iscsi_auth_group"); spdk_json_write_named_string(w, "method", "add_iscsi_auth_group");
spdk_json_write_name(w, "params"); spdk_json_write_name(w, "params");
spdk_iscsi_auth_group_info_json(group, w); iscsi_auth_group_info_json(group, w);
spdk_json_write_object_end(w); spdk_json_write_object_end(w);
} }
@ -1475,22 +1478,22 @@ spdk_iscsi_auth_groups_info_json(struct spdk_json_write_ctx *w)
struct spdk_iscsi_auth_group *group; struct spdk_iscsi_auth_group *group;
TAILQ_FOREACH(group, &g_spdk_iscsi.auth_group_head, tailq) { TAILQ_FOREACH(group, &g_spdk_iscsi.auth_group_head, tailq) {
spdk_iscsi_auth_group_info_json(group, w); iscsi_auth_group_info_json(group, w);
} }
} }
static void static void
spdk_iscsi_auth_groups_config_json(struct spdk_json_write_ctx *w) iscsi_auth_groups_config_json(struct spdk_json_write_ctx *w)
{ {
struct spdk_iscsi_auth_group *group; struct spdk_iscsi_auth_group *group;
TAILQ_FOREACH(group, &g_spdk_iscsi.auth_group_head, tailq) { TAILQ_FOREACH(group, &g_spdk_iscsi.auth_group_head, tailq) {
spdk_iscsi_auth_group_config_json(group, w); iscsi_auth_group_config_json(group, w);
} }
} }
static void static void
spdk_iscsi_opts_config_json(struct spdk_json_write_ctx *w) iscsi_opts_config_json(struct spdk_json_write_ctx *w)
{ {
spdk_json_write_object_begin(w); spdk_json_write_object_begin(w);
@ -1506,11 +1509,11 @@ void
spdk_iscsi_config_json(struct spdk_json_write_ctx *w) spdk_iscsi_config_json(struct spdk_json_write_ctx *w)
{ {
spdk_json_write_array_begin(w); spdk_json_write_array_begin(w);
spdk_iscsi_opts_config_json(w); iscsi_opts_config_json(w);
spdk_iscsi_portal_grps_config_json(w); spdk_iscsi_portal_grps_config_json(w);
spdk_iscsi_init_grps_config_json(w); spdk_iscsi_init_grps_config_json(w);
spdk_iscsi_tgt_nodes_config_json(w); spdk_iscsi_tgt_nodes_config_json(w);
spdk_iscsi_auth_groups_config_json(w); iscsi_auth_groups_config_json(w);
spdk_json_write_array_end(w); spdk_json_write_array_end(w);
} }

148
lib/iscsi/param.c
View File

@ -71,7 +71,7 @@ spdk_iscsi_param_free(struct iscsi_param *params)
} }
static int static int
spdk_iscsi_find_key_in_array(const char *key, const char *array[]) iscsi_find_key_in_array(const char *key, const char *array[])
{ {
int i; int i;
@ -215,7 +215,7 @@ spdk_iscsi_param_set_int(struct iscsi_param *params, const char *key, uint32_t v
* data = "KEY=VAL<NUL>" * data = "KEY=VAL<NUL>"
*/ */
static int static int
spdk_iscsi_parse_param(struct iscsi_param **params, const uint8_t *data, uint32_t data_len) iscsi_parse_param(struct iscsi_param **params, const uint8_t *data, uint32_t data_len)
{ {
int rc; int rc;
uint8_t *key_copy, *val_copy; uint8_t *key_copy, *val_copy;
@ -270,7 +270,7 @@ spdk_iscsi_parse_param(struct iscsi_param **params, const uint8_t *data, uint32_
* comma or zero is counted in, otherwise we need to iterate each parameter * comma or zero is counted in, otherwise we need to iterate each parameter
* value * value
*/ */
max_len = spdk_iscsi_find_key_in_array(key_copy, non_simple_value_params) ? max_len = iscsi_find_key_in_array(key_copy, non_simple_value_params) ?
ISCSI_TEXT_MAX_VAL_LEN : ISCSI_TEXT_MAX_SIMPLE_VAL_LEN; ISCSI_TEXT_MAX_VAL_LEN : ISCSI_TEXT_MAX_SIMPLE_VAL_LEN;
if (val_len > max_len) { if (val_len > max_len) {
SPDK_ERRLOG("Overflow Val %d\n", val_len); SPDK_ERRLOG("Overflow Val %d\n", val_len);
@ -324,7 +324,7 @@ spdk_iscsi_parse_params(struct iscsi_param **params, const uint8_t *data,
if (!p) { if (!p) {
return -1; return -1;
} }
rc = spdk_iscsi_parse_param(params, p, i + strlen(*partial_parameter)); rc = iscsi_parse_param(params, p, i + strlen(*partial_parameter));
free(p); free(p);
if (rc < 0) { if (rc < 0) {
return -1; return -1;
@ -371,7 +371,7 @@ spdk_iscsi_parse_params(struct iscsi_param **params, const uint8_t *data,
} }
while (offset < len && data[offset] != '\0') { while (offset < len && data[offset] != '\0') {
rc = spdk_iscsi_parse_param(params, data + offset, len - offset); rc = iscsi_parse_param(params, data + offset, len - offset);
if (rc < 0) { if (rc < 0) {
return -1; return -1;
} }
@ -459,8 +459,8 @@ static const struct iscsi_param_table sess_param_table[] = {
}; };
static int static int
spdk_iscsi_params_init_internal(struct iscsi_param **params, iscsi_params_init_internal(struct iscsi_param **params,
const struct iscsi_param_table *table) const struct iscsi_param_table *table)
{ {
int rc; int rc;
int i; int i;
@ -488,13 +488,13 @@ spdk_iscsi_params_init_internal(struct iscsi_param **params,
int int
spdk_iscsi_conn_params_init(struct iscsi_param **params) spdk_iscsi_conn_params_init(struct iscsi_param **params)
{ {
return spdk_iscsi_params_init_internal(params, &conn_param_table[0]); return iscsi_params_init_internal(params, &conn_param_table[0]);
} }
int int
spdk_iscsi_sess_params_init(struct iscsi_param **params) spdk_iscsi_sess_params_init(struct iscsi_param **params)
{ {
return spdk_iscsi_params_init_internal(params, &sess_param_table[0]); return iscsi_params_init_internal(params, &sess_param_table[0]);
} }
static const char *chap_type[] = { static const char *chap_type[] = {
@ -537,10 +537,10 @@ static const char *target_declarative_params[] = {
* error: -1 * error: -1
*/ */
static int static int
spdk_iscsi_special_param_construction(struct spdk_iscsi_conn *conn, iscsi_special_param_construction(struct spdk_iscsi_conn *conn,
struct iscsi_param *param, struct iscsi_param *param,
bool FirstBurstLength_flag, char *data, bool FirstBurstLength_flag, char *data,
int alloc_len, int total) int alloc_len, int total)
{ {
int len; int len;
struct iscsi_param *param_first; struct iscsi_param *param_first;
@ -623,13 +623,13 @@ spdk_iscsi_special_param_construction(struct spdk_iscsi_conn *conn,
} }
/** /**
* spdk_iscsi_construct_data_from_param: * iscsi_construct_data_from_param:
* To construct the data which will be returned to the initiator * To construct the data which will be returned to the initiator
* return: length of the negotiated data, -1 indicates error; * return: length of the negotiated data, -1 indicates error;
*/ */
static int static int
spdk_iscsi_construct_data_from_param(struct iscsi_param *param, char *new_val, iscsi_construct_data_from_param(struct iscsi_param *param, char *new_val,
char *data, int alloc_len, int total) char *data, int alloc_len, int total)
{ {
int len; int len;
@ -654,10 +654,11 @@ spdk_iscsi_construct_data_from_param(struct iscsi_param *param, char *new_val,
* type = ISPT_LIST * type = ISPT_LIST
* return: the negotiated value of the key * return: the negotiated value of the key
*/ */
static char *spdk_iscsi_negotiate_param_list(int *add_param_value, static char *
struct iscsi_param *param, iscsi_negotiate_param_list(int *add_param_value,
char *valid_list, char *in_val, struct iscsi_param *param,
char *cur_val) char *valid_list, char *in_val,
char *cur_val)
{ {
char *val_start, *val_end; char *val_start, *val_end;
char *in_start, *in_end; char *in_start, *in_end;
@ -705,10 +706,11 @@ static char *spdk_iscsi_negotiate_param_list(int *add_param_value,
* type = ISPT_NUMERICAL_MIN/MAX, ISPT_NUMERICAL_DECLARATIVE * type = ISPT_NUMERICAL_MIN/MAX, ISPT_NUMERICAL_DECLARATIVE
* return: the negotiated value of the key * return: the negotiated value of the key
*/ */
static char *spdk_iscsi_negotiate_param_numerical(int *add_param_value, static char *
struct iscsi_param *param, iscsi_negotiate_param_numerical(int *add_param_value,
char *valid_list, char *in_val, struct iscsi_param *param,
char *cur_val) char *valid_list, char *in_val,
char *cur_val)
{ {
char *valid_next; char *valid_next;
char *new_val = NULL; char *new_val = NULL;
@ -762,10 +764,11 @@ static char *spdk_iscsi_negotiate_param_numerical(int *add_param_value,
* type = ISPT_BOOLEAN_OR, ISPT_BOOLEAN_AND * type = ISPT_BOOLEAN_OR, ISPT_BOOLEAN_AND
* return: the negotiated value of the key * return: the negotiated value of the key
*/ */
static char *spdk_iscsi_negotiate_param_boolean(int *add_param_value, static char *
struct iscsi_param *param, iscsi_negotiate_param_boolean(int *add_param_value,
char *in_val, char *cur_val, struct iscsi_param *param,
const char *value) char *in_val, char *cur_val,
const char *value)
{ {
char *new_val = NULL; char *new_val = NULL;
@ -798,23 +801,23 @@ static char *spdk_iscsi_negotiate_param_boolean(int *add_param_value,
* return value: the new negotiated value * return value: the new negotiated value
*/ */
static char * static char *
spdk_iscsi_negotiate_param_all(int *add_param_value, struct iscsi_param *param, iscsi_negotiate_param_all(int *add_param_value, struct iscsi_param *param,
char *valid_list, char *in_val, char *cur_val) char *valid_list, char *in_val, char *cur_val)
{ {
char *new_val; char *new_val;
switch (param->type) { switch (param->type) {
case ISPT_LIST: case ISPT_LIST:
new_val = spdk_iscsi_negotiate_param_list(add_param_value, new_val = iscsi_negotiate_param_list(add_param_value,
param, param,
valid_list, valid_list,
in_val, in_val,
cur_val); cur_val);
break; break;
case ISPT_NUMERICAL_MIN: case ISPT_NUMERICAL_MIN:
case ISPT_NUMERICAL_MAX: case ISPT_NUMERICAL_MAX:
case ISPT_NUMERICAL_DECLARATIVE: case ISPT_NUMERICAL_DECLARATIVE:
new_val = spdk_iscsi_negotiate_param_numerical(add_param_value, new_val = iscsi_negotiate_param_numerical(add_param_value,
param, param,
valid_list, valid_list,
in_val, in_val,
@ -822,18 +825,18 @@ spdk_iscsi_negotiate_param_all(int *add_param_value, struct iscsi_param *param,
break; break;
case ISPT_BOOLEAN_OR: case ISPT_BOOLEAN_OR:
new_val = spdk_iscsi_negotiate_param_boolean(add_param_value, new_val = iscsi_negotiate_param_boolean(add_param_value,
param, param,
in_val, in_val,
cur_val, cur_val,
"Yes"); "Yes");
break; break;
case ISPT_BOOLEAN_AND: case ISPT_BOOLEAN_AND:
new_val = spdk_iscsi_negotiate_param_boolean(add_param_value, new_val = iscsi_negotiate_param_boolean(add_param_value,
param, param,
in_val, in_val,
cur_val, cur_val,
"No"); "No");
break; break;
default: default:
@ -850,10 +853,10 @@ spdk_iscsi_negotiate_param_all(int *add_param_value, struct iscsi_param *param,
* connection's params * connection's params
*/ */
static int static int
spdk_iscsi_negotiate_param_init(struct spdk_iscsi_conn *conn, iscsi_negotiate_param_init(struct spdk_iscsi_conn *conn,
struct iscsi_param **cur_param_p, struct iscsi_param **cur_param_p,
struct iscsi_param **params_dst_p, struct iscsi_param **params_dst_p,
struct iscsi_param *param) struct iscsi_param *param)
{ {
int index; int index;
@ -875,8 +878,8 @@ spdk_iscsi_negotiate_param_init(struct spdk_iscsi_conn *conn,
} else { } else {
index = (*cur_param_p)->state_index; index = (*cur_param_p)->state_index;
if (conn->sess_param_state_negotiated[index] && if (conn->sess_param_state_negotiated[index] &&
!spdk_iscsi_find_key_in_array(param->key, !iscsi_find_key_in_array(param->key,
target_declarative_params)) { target_declarative_params)) {
return SPDK_ISCSI_PARAMETER_EXCHANGE_NOT_ONCE; return SPDK_ISCSI_PARAMETER_EXCHANGE_NOT_ONCE;
} }
conn->sess_param_state_negotiated[index] = true; conn->sess_param_state_negotiated[index] = true;
@ -884,8 +887,8 @@ spdk_iscsi_negotiate_param_init(struct spdk_iscsi_conn *conn,
} else { } else {
index = (*cur_param_p)->state_index; index = (*cur_param_p)->state_index;
if (conn->conn_param_state_negotiated[index] && if (conn->conn_param_state_negotiated[index] &&
!spdk_iscsi_find_key_in_array(param->key, !iscsi_find_key_in_array(param->key,
multi_negot_conn_params)) { multi_negot_conn_params)) {
return SPDK_ISCSI_PARAMETER_EXCHANGE_NOT_ONCE; return SPDK_ISCSI_PARAMETER_EXCHANGE_NOT_ONCE;
} }
conn->conn_param_state_negotiated[index] = true; conn->conn_param_state_negotiated[index] = true;
@ -1001,22 +1004,21 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
continue; continue;
} }
/* CHAP keys */ /* CHAP keys */
if (spdk_iscsi_find_key_in_array(param->key, chap_type)) { if (iscsi_find_key_in_array(param->key, chap_type)) {
continue; continue;
} }
/* 12.2, 12.10, 12.11, 12.13, 12.14, 12.17, 12.18, 12.19 */ /* 12.2, 12.10, 12.11, 12.13, 12.14, 12.17, 12.18, 12.19 */
if (discovery && if (discovery &&
spdk_iscsi_find_key_in_array(param->key, iscsi_find_key_in_array(param->key, discovery_ignored_param)) {
discovery_ignored_param)) {
snprintf(in_val, ISCSI_TEXT_MAX_VAL_LEN + 1, "%s", "Irrelevant"); snprintf(in_val, ISCSI_TEXT_MAX_VAL_LEN + 1, "%s", "Irrelevant");
new_val = in_val; new_val = in_val;
add_param_value = 1; add_param_value = 1;
} else { } else {
rc = spdk_iscsi_negotiate_param_init(conn, rc = iscsi_negotiate_param_init(conn,
&cur_param, &cur_param,
&params_dst, &params_dst,
param); param);
if (rc < 0) { if (rc < 0) {
free(valid_list); free(valid_list);
free(in_val); free(in_val);
@ -1064,15 +1066,15 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
} }
/* prevent target's declarative params from being changed by initiator */ /* prevent target's declarative params from being changed by initiator */
if (spdk_iscsi_find_key_in_array(param->key, target_declarative_params)) { if (iscsi_find_key_in_array(param->key, target_declarative_params)) {
add_param_value = 1; add_param_value = 1;
} }
new_val = spdk_iscsi_negotiate_param_all(&add_param_value, new_val = iscsi_negotiate_param_all(&add_param_value,
param, param,
valid_list, valid_list,
in_val, in_val,
cur_val); cur_val);
} }
/* check the negotiated value of the key */ /* check the negotiated value of the key */
@ -1083,16 +1085,16 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
if (add_param_value == 0) { if (add_param_value == 0) {
spdk_iscsi_param_set(params_dst, param->key, new_val); spdk_iscsi_param_set(params_dst, param->key, new_val);
} }
total = spdk_iscsi_construct_data_from_param(param, total = iscsi_construct_data_from_param(param,
new_val, new_val,
data, data,
alloc_len, alloc_len,
total); total);
if (total < 0) { if (total < 0) {
goto final_return; goto final_return;
} }
total = spdk_iscsi_special_param_construction(conn, total = iscsi_special_param_construction(conn,
param, param,
FirstBurstLength_flag, FirstBurstLength_flag,
data, data,

44
lib/iscsi/portal_grp.c
View File

@ -49,7 +49,7 @@
#define PORTNUMSTRLEN 32 #define PORTNUMSTRLEN 32
static struct spdk_iscsi_portal * static struct spdk_iscsi_portal *
spdk_iscsi_portal_find_by_addr(const char *host, const char *port) iscsi_portal_find_by_addr(const char *host, const char *port)
{ {
struct spdk_iscsi_portal *p; struct spdk_iscsi_portal *p;
@ -133,7 +133,7 @@ spdk_iscsi_portal_create(const char *host, const char *port, const char *cpumask
p->acceptor_poller = NULL; p->acceptor_poller = NULL;
pthread_mutex_lock(&g_spdk_iscsi.mutex); pthread_mutex_lock(&g_spdk_iscsi.mutex);
tmp = spdk_iscsi_portal_find_by_addr(host, port); tmp = iscsi_portal_find_by_addr(host, port);
if (tmp != NULL) { if (tmp != NULL) {
pthread_mutex_unlock(&g_spdk_iscsi.mutex); pthread_mutex_unlock(&g_spdk_iscsi.mutex);
SPDK_ERRLOG("portal (%s, %s) already exists\n", host, port); SPDK_ERRLOG("portal (%s, %s) already exists\n", host, port);
@ -173,7 +173,7 @@ spdk_iscsi_portal_destroy(struct spdk_iscsi_portal *p)
} }
static int static int
spdk_iscsi_portal_open(struct spdk_iscsi_portal *p) iscsi_portal_open(struct spdk_iscsi_portal *p)
{ {
struct spdk_sock *sock; struct spdk_sock *sock;
int port; int port;
@ -206,7 +206,7 @@ spdk_iscsi_portal_open(struct spdk_iscsi_portal *p)
} }
static void static void
spdk_iscsi_portal_close(struct spdk_iscsi_portal *p) iscsi_portal_close(struct spdk_iscsi_portal *p)
{ {
if (p->sock) { if (p->sock) {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "close portal (%s, %s)\n", SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "close portal (%s, %s)\n",
@ -217,8 +217,8 @@ spdk_iscsi_portal_close(struct spdk_iscsi_portal *p)
} }
static int static int
spdk_iscsi_parse_portal(const char *portalstring, struct spdk_iscsi_portal **ip, iscsi_parse_portal(const char *portalstring, struct spdk_iscsi_portal **ip,
int dry_run) int dry_run)
{ {
char *host = NULL, *port = NULL, *cpumask = NULL; char *host = NULL, *port = NULL, *cpumask = NULL;
int len, rc = -1; int len, rc = -1;
@ -393,7 +393,7 @@ spdk_iscsi_portal_grp_add_portal(struct spdk_iscsi_portal_grp *pg,
} }
static int static int
spdk_iscsi_parse_portal_grp(struct spdk_conf_section *sp) iscsi_parse_portal_grp(struct spdk_conf_section *sp)
{ {
struct spdk_iscsi_portal_grp *pg; struct spdk_iscsi_portal_grp *pg;
struct spdk_iscsi_portal *p; struct spdk_iscsi_portal *p;
@ -421,7 +421,7 @@ spdk_iscsi_parse_portal_grp(struct spdk_conf_section *sp)
if (label == NULL || portal == NULL) { if (label == NULL || portal == NULL) {
break; break;
} }
rc = spdk_iscsi_parse_portal(portal, &p, 1); rc = iscsi_parse_portal(portal, &p, 1);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("parse portal error (%s)\n", portal); SPDK_ERRLOG("parse portal error (%s)\n", portal);
return -1; return -1;
@ -448,7 +448,7 @@ spdk_iscsi_parse_portal_grp(struct spdk_conf_section *sp)
goto error; goto error;
} }
rc = spdk_iscsi_parse_portal(portal, &p, 0); rc = iscsi_parse_portal(portal, &p, 0);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("parse portal error (%s)\n", portal); SPDK_ERRLOG("parse portal error (%s)\n", portal);
goto error; goto error;
@ -510,7 +510,7 @@ spdk_iscsi_parse_portal_grps(void)
} }
/* Build portal group from cfg section PortalGroup */ /* Build portal group from cfg section PortalGroup */
rc = spdk_iscsi_parse_portal_grp(sp); rc = iscsi_parse_portal_grp(sp);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("parse_portal_group() failed\n"); SPDK_ERRLOG("parse_portal_group() failed\n");
return -1; return -1;
@ -545,7 +545,7 @@ spdk_iscsi_portal_grp_open(struct spdk_iscsi_portal_grp *pg)
int rc; int rc;
TAILQ_FOREACH(p, &pg->head, per_pg_tailq) { TAILQ_FOREACH(p, &pg->head, per_pg_tailq) {
rc = spdk_iscsi_portal_open(p); rc = iscsi_portal_open(p);
if (rc < 0) { if (rc < 0) {
return rc; return rc;
} }
@ -554,12 +554,12 @@ spdk_iscsi_portal_grp_open(struct spdk_iscsi_portal_grp *pg)
} }
static void static void
spdk_iscsi_portal_grp_close(struct spdk_iscsi_portal_grp *pg) iscsi_portal_grp_close(struct spdk_iscsi_portal_grp *pg)
{ {
struct spdk_iscsi_portal *p; struct spdk_iscsi_portal *p;
TAILQ_FOREACH(p, &pg->head, per_pg_tailq) { TAILQ_FOREACH(p, &pg->head, per_pg_tailq) {
spdk_iscsi_portal_close(p); iscsi_portal_close(p);
} }
} }
@ -571,7 +571,7 @@ spdk_iscsi_portal_grp_close_all(void)
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_portal_grp_close_all\n"); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "spdk_iscsi_portal_grp_close_all\n");
pthread_mutex_lock(&g_spdk_iscsi.mutex); pthread_mutex_lock(&g_spdk_iscsi.mutex);
TAILQ_FOREACH(pg, &g_spdk_iscsi.pg_head, tailq) { TAILQ_FOREACH(pg, &g_spdk_iscsi.pg_head, tailq) {
spdk_iscsi_portal_grp_close(pg); iscsi_portal_grp_close(pg);
} }
pthread_mutex_unlock(&g_spdk_iscsi.mutex); pthread_mutex_unlock(&g_spdk_iscsi.mutex);
} }
@ -596,7 +596,7 @@ spdk_iscsi_portal_grp_unregister(int tag)
void void
spdk_iscsi_portal_grp_release(struct spdk_iscsi_portal_grp *pg) spdk_iscsi_portal_grp_release(struct spdk_iscsi_portal_grp *pg)
{ {
spdk_iscsi_portal_grp_close(pg); iscsi_portal_grp_close(pg);
spdk_iscsi_portal_grp_destroy(pg); spdk_iscsi_portal_grp_destroy(pg);
} }
@ -647,8 +647,8 @@ spdk_iscsi_portal_grps_config_text(FILE *fp)
} }
static void static void
spdk_iscsi_portal_grp_info_json(struct spdk_iscsi_portal_grp *pg, iscsi_portal_grp_info_json(struct spdk_iscsi_portal_grp *pg,
struct spdk_json_write_ctx *w) struct spdk_json_write_ctx *w)
{ {
struct spdk_iscsi_portal *portal; struct spdk_iscsi_portal *portal;
@ -673,15 +673,15 @@ spdk_iscsi_portal_grp_info_json(struct spdk_iscsi_portal_grp *pg,
} }
static void static void
spdk_iscsi_portal_grp_config_json(struct spdk_iscsi_portal_grp *pg, iscsi_portal_grp_config_json(struct spdk_iscsi_portal_grp *pg,
struct spdk_json_write_ctx *w) struct spdk_json_write_ctx *w)
{ {
spdk_json_write_object_begin(w); spdk_json_write_object_begin(w);
spdk_json_write_named_string(w, "method", "add_portal_group"); spdk_json_write_named_string(w, "method", "add_portal_group");
spdk_json_write_name(w, "params"); spdk_json_write_name(w, "params");
spdk_iscsi_portal_grp_info_json(pg, w); iscsi_portal_grp_info_json(pg, w);
spdk_json_write_object_end(w); spdk_json_write_object_end(w);
} }
@ -692,7 +692,7 @@ spdk_iscsi_portal_grps_info_json(struct spdk_json_write_ctx *w)
struct spdk_iscsi_portal_grp *pg; struct spdk_iscsi_portal_grp *pg;
TAILQ_FOREACH(pg, &g_spdk_iscsi.pg_head, tailq) { TAILQ_FOREACH(pg, &g_spdk_iscsi.pg_head, tailq) {
spdk_iscsi_portal_grp_info_json(pg, w); iscsi_portal_grp_info_json(pg, w);
} }
} }
@ -702,6 +702,6 @@ spdk_iscsi_portal_grps_config_json(struct spdk_json_write_ctx *w)
struct spdk_iscsi_portal_grp *pg; struct spdk_iscsi_portal_grp *pg;
TAILQ_FOREACH(pg, &g_spdk_iscsi.pg_head, tailq) { TAILQ_FOREACH(pg, &g_spdk_iscsi.pg_head, tailq) {
spdk_iscsi_portal_grp_config_json(pg, w); iscsi_portal_grp_config_json(pg, w);
} }
} }

4
lib/iscsi/task.c
View File

@ -38,7 +38,7 @@
#include "iscsi/task.h" #include "iscsi/task.h"
static void static void
spdk_iscsi_task_free(struct spdk_scsi_task *scsi_task) iscsi_task_free(struct spdk_scsi_task *scsi_task)
{ {
struct spdk_iscsi_task *task = spdk_iscsi_task_from_scsi_task(scsi_task); struct spdk_iscsi_task *task = spdk_iscsi_task_from_scsi_task(scsi_task);
@ -71,7 +71,7 @@ spdk_iscsi_task_get(struct spdk_iscsi_conn *conn, struct spdk_iscsi_task *parent
conn->pending_task_cnt++; conn->pending_task_cnt++;
spdk_scsi_task_construct(&task->scsi, spdk_scsi_task_construct(&task->scsi,
cpl_fn, cpl_fn,
spdk_iscsi_task_free); iscsi_task_free);
if (parent) { if (parent) {
parent->scsi.ref++; parent->scsi.ref++;
task->parent = parent; task->parent = parent;

196
lib/iscsi/tgt_node.c
View File

@ -51,7 +51,7 @@
#define MAX_MASKBUF 128 #define MAX_MASKBUF 128
static bool static bool
spdk_iscsi_ipv6_netmask_allow_addr(const char *netmask, const char *addr) iscsi_ipv6_netmask_allow_addr(const char *netmask, const char *addr)
{ {
struct in6_addr in6_mask; struct in6_addr in6_mask;
struct in6_addr in6_addr; struct in6_addr in6_addr;
@ -115,7 +115,7 @@ spdk_iscsi_ipv6_netmask_allow_addr(const char *netmask, const char *addr)
} }
static bool static bool
spdk_iscsi_ipv4_netmask_allow_addr(const char *netmask, const char *addr) iscsi_ipv4_netmask_allow_addr(const char *netmask, const char *addr)
{ {
struct in_addr in4_mask; struct in_addr in4_mask;
struct in_addr in4_addr; struct in_addr in4_addr;
@ -163,7 +163,7 @@ spdk_iscsi_ipv4_netmask_allow_addr(const char *netmask, const char *addr)
} }
static bool static bool
spdk_iscsi_netmask_allow_addr(const char *netmask, const char *addr) iscsi_netmask_allow_addr(const char *netmask, const char *addr)
{ {
if (netmask == NULL || addr == NULL) { if (netmask == NULL || addr == NULL) {
return false; return false;
@ -173,12 +173,12 @@ spdk_iscsi_netmask_allow_addr(const char *netmask, const char *addr)
} }
if (netmask[0] == '[') { if (netmask[0] == '[') {
/* IPv6 */ /* IPv6 */
if (spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr)) { if (iscsi_ipv6_netmask_allow_addr(netmask, addr)) {
return true; return true;
} }
} else { } else {
/* IPv4 */ /* IPv4 */
if (spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr)) { if (iscsi_ipv4_netmask_allow_addr(netmask, addr)) {
return true; return true;
} }
} }
@ -186,15 +186,15 @@ spdk_iscsi_netmask_allow_addr(const char *netmask, const char *addr)
} }
static bool static bool
spdk_iscsi_init_grp_allow_addr(struct spdk_iscsi_init_grp *igp, iscsi_init_grp_allow_addr(struct spdk_iscsi_init_grp *igp,
const char *addr) const char *addr)
{ {
struct spdk_iscsi_initiator_netmask *imask; struct spdk_iscsi_initiator_netmask *imask;
TAILQ_FOREACH(imask, &igp->netmask_head, tailq) { TAILQ_FOREACH(imask, &igp->netmask_head, tailq) {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "netmask=%s, addr=%s\n", SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "netmask=%s, addr=%s\n",
imask->mask, addr); imask->mask, addr);
if (spdk_iscsi_netmask_allow_addr(imask->mask, addr)) { if (iscsi_netmask_allow_addr(imask->mask, addr)) {
return true; return true;
} }
} }
@ -202,8 +202,8 @@ spdk_iscsi_init_grp_allow_addr(struct spdk_iscsi_init_grp *igp,
} }
static int static int
spdk_iscsi_init_grp_allow_iscsi_name(struct spdk_iscsi_init_grp *igp, iscsi_init_grp_allow_iscsi_name(struct spdk_iscsi_init_grp *igp,
const char *iqn, bool *result) const char *iqn, bool *result)
{ {
struct spdk_iscsi_initiator_name *iname; struct spdk_iscsi_initiator_name *iname;
@ -226,8 +226,8 @@ spdk_iscsi_init_grp_allow_iscsi_name(struct spdk_iscsi_init_grp *igp,
} }
static struct spdk_iscsi_pg_map * static struct spdk_iscsi_pg_map *
spdk_iscsi_tgt_node_find_pg_map(struct spdk_iscsi_tgt_node *target, iscsi_tgt_node_find_pg_map(struct spdk_iscsi_tgt_node *target,
struct spdk_iscsi_portal_grp *pg); struct spdk_iscsi_portal_grp *pg);
bool bool
spdk_iscsi_tgt_node_access(struct spdk_iscsi_conn *conn, spdk_iscsi_tgt_node_access(struct spdk_iscsi_conn *conn,
@ -246,17 +246,17 @@ spdk_iscsi_tgt_node_access(struct spdk_iscsi_conn *conn,
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "pg=%d, iqn=%s, addr=%s\n", SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "pg=%d, iqn=%s, addr=%s\n",
pg->tag, iqn, addr); pg->tag, iqn, addr);
pg_map = spdk_iscsi_tgt_node_find_pg_map(target, pg); pg_map = iscsi_tgt_node_find_pg_map(target, pg);
if (pg_map == NULL) { if (pg_map == NULL) {
return false; return false;
} }
TAILQ_FOREACH(ig_map, &pg_map->ig_map_head, tailq) { TAILQ_FOREACH(ig_map, &pg_map->ig_map_head, tailq) {
rc = spdk_iscsi_init_grp_allow_iscsi_name(ig_map->ig, iqn, &allowed); rc = iscsi_init_grp_allow_iscsi_name(ig_map->ig, iqn, &allowed);
if (rc == 0) { if (rc == 0) {
if (allowed == false) { if (allowed == false) {
goto denied; goto denied;
} else { } else {
if (spdk_iscsi_init_grp_allow_addr(ig_map->ig, addr)) { if (iscsi_init_grp_allow_addr(ig_map->ig, addr)) {
return true; return true;
} }
} }
@ -273,7 +273,7 @@ denied:
} }
static bool static bool
spdk_iscsi_tgt_node_allow_iscsi_name(struct spdk_iscsi_tgt_node *target, const char *iqn) iscsi_tgt_node_allow_iscsi_name(struct spdk_iscsi_tgt_node *target, const char *iqn)
{ {
struct spdk_iscsi_pg_map *pg_map; struct spdk_iscsi_pg_map *pg_map;
struct spdk_iscsi_ig_map *ig_map; struct spdk_iscsi_ig_map *ig_map;
@ -286,7 +286,7 @@ spdk_iscsi_tgt_node_allow_iscsi_name(struct spdk_iscsi_tgt_node *target, const c
TAILQ_FOREACH(pg_map, &target->pg_map_head, tailq) { TAILQ_FOREACH(pg_map, &target->pg_map_head, tailq) {
TAILQ_FOREACH(ig_map, &pg_map->ig_map_head, tailq) { TAILQ_FOREACH(ig_map, &pg_map->ig_map_head, tailq) {
rc = spdk_iscsi_init_grp_allow_iscsi_name(ig_map->ig, iqn, &result); rc = iscsi_init_grp_allow_iscsi_name(ig_map->ig, iqn, &result);
if (rc == 0) { if (rc == 0) {
return result; return result;
} }
@ -336,7 +336,7 @@ spdk_iscsi_send_tgts(struct spdk_iscsi_conn *conn, const char *iiqn,
&& strcasecmp(tiqn, target->name) != 0) { && strcasecmp(tiqn, target->name) != 0) {
continue; continue;
} }
rc = spdk_iscsi_tgt_node_allow_iscsi_name(target, iiqn); rc = iscsi_tgt_node_allow_iscsi_name(target, iiqn);
if (rc == 0) { if (rc == 0) {
continue; continue;
} }
@ -406,7 +406,7 @@ spdk_iscsi_find_tgt_node(const char *target_name)
} }
static int static int
spdk_iscsi_tgt_node_register(struct spdk_iscsi_tgt_node *target) iscsi_tgt_node_register(struct spdk_iscsi_tgt_node *target)
{ {
pthread_mutex_lock(&g_spdk_iscsi.mutex); pthread_mutex_lock(&g_spdk_iscsi.mutex);
@ -422,7 +422,7 @@ spdk_iscsi_tgt_node_register(struct spdk_iscsi_tgt_node *target)
} }
static int static int
spdk_iscsi_tgt_node_unregister(struct spdk_iscsi_tgt_node *target) iscsi_tgt_node_unregister(struct spdk_iscsi_tgt_node *target)
{ {
struct spdk_iscsi_tgt_node *t; struct spdk_iscsi_tgt_node *t;
@ -437,8 +437,8 @@ spdk_iscsi_tgt_node_unregister(struct spdk_iscsi_tgt_node *target)
} }
static struct spdk_iscsi_ig_map * static struct spdk_iscsi_ig_map *
spdk_iscsi_pg_map_find_ig_map(struct spdk_iscsi_pg_map *pg_map, iscsi_pg_map_find_ig_map(struct spdk_iscsi_pg_map *pg_map,
struct spdk_iscsi_init_grp *ig) struct spdk_iscsi_init_grp *ig)
{ {
struct spdk_iscsi_ig_map *ig_map; struct spdk_iscsi_ig_map *ig_map;
@ -452,12 +452,12 @@ spdk_iscsi_pg_map_find_ig_map(struct spdk_iscsi_pg_map *pg_map,
} }
static struct spdk_iscsi_ig_map * static struct spdk_iscsi_ig_map *
spdk_iscsi_pg_map_add_ig_map(struct spdk_iscsi_pg_map *pg_map, iscsi_pg_map_add_ig_map(struct spdk_iscsi_pg_map *pg_map,
struct spdk_iscsi_init_grp *ig) struct spdk_iscsi_init_grp *ig)
{ {
struct spdk_iscsi_ig_map *ig_map; struct spdk_iscsi_ig_map *ig_map;
if (spdk_iscsi_pg_map_find_ig_map(pg_map, ig) != NULL) { if (iscsi_pg_map_find_ig_map(pg_map, ig) != NULL) {
return NULL; return NULL;
} }
@ -475,8 +475,8 @@ spdk_iscsi_pg_map_add_ig_map(struct spdk_iscsi_pg_map *pg_map,
} }
static void static void
_spdk_iscsi_pg_map_delete_ig_map(struct spdk_iscsi_pg_map *pg_map, _iscsi_pg_map_delete_ig_map(struct spdk_iscsi_pg_map *pg_map,
struct spdk_iscsi_ig_map *ig_map) struct spdk_iscsi_ig_map *ig_map)
{ {
TAILQ_REMOVE(&pg_map->ig_map_head, ig_map, tailq); TAILQ_REMOVE(&pg_map->ig_map_head, ig_map, tailq);
pg_map->num_ig_maps--; pg_map->num_ig_maps--;
@ -485,33 +485,33 @@ _spdk_iscsi_pg_map_delete_ig_map(struct spdk_iscsi_pg_map *pg_map,
} }
static int static int
spdk_iscsi_pg_map_delete_ig_map(struct spdk_iscsi_pg_map *pg_map, iscsi_pg_map_delete_ig_map(struct spdk_iscsi_pg_map *pg_map,
struct spdk_iscsi_init_grp *ig) struct spdk_iscsi_init_grp *ig)
{ {
struct spdk_iscsi_ig_map *ig_map; struct spdk_iscsi_ig_map *ig_map;
ig_map = spdk_iscsi_pg_map_find_ig_map(pg_map, ig); ig_map = iscsi_pg_map_find_ig_map(pg_map, ig);
if (ig_map == NULL) { if (ig_map == NULL) {
return -ENOENT; return -ENOENT;
} }
_spdk_iscsi_pg_map_delete_ig_map(pg_map, ig_map); _iscsi_pg_map_delete_ig_map(pg_map, ig_map);
return 0; return 0;
} }
static void static void
spdk_iscsi_pg_map_delete_all_ig_maps(struct spdk_iscsi_pg_map *pg_map) iscsi_pg_map_delete_all_ig_maps(struct spdk_iscsi_pg_map *pg_map)
{ {
struct spdk_iscsi_ig_map *ig_map, *tmp; struct spdk_iscsi_ig_map *ig_map, *tmp;
TAILQ_FOREACH_SAFE(ig_map, &pg_map->ig_map_head, tailq, tmp) { TAILQ_FOREACH_SAFE(ig_map, &pg_map->ig_map_head, tailq, tmp) {
_spdk_iscsi_pg_map_delete_ig_map(pg_map, ig_map); _iscsi_pg_map_delete_ig_map(pg_map, ig_map);
} }
} }
static struct spdk_iscsi_pg_map * static struct spdk_iscsi_pg_map *
spdk_iscsi_tgt_node_find_pg_map(struct spdk_iscsi_tgt_node *target, iscsi_tgt_node_find_pg_map(struct spdk_iscsi_tgt_node *target,
struct spdk_iscsi_portal_grp *pg) struct spdk_iscsi_portal_grp *pg)
{ {
struct spdk_iscsi_pg_map *pg_map; struct spdk_iscsi_pg_map *pg_map;
@ -525,14 +525,14 @@ spdk_iscsi_tgt_node_find_pg_map(struct spdk_iscsi_tgt_node *target,
} }
static struct spdk_iscsi_pg_map * static struct spdk_iscsi_pg_map *
spdk_iscsi_tgt_node_add_pg_map(struct spdk_iscsi_tgt_node *target, iscsi_tgt_node_add_pg_map(struct spdk_iscsi_tgt_node *target,
struct spdk_iscsi_portal_grp *pg) struct spdk_iscsi_portal_grp *pg)
{ {
struct spdk_iscsi_pg_map *pg_map; struct spdk_iscsi_pg_map *pg_map;
char port_name[MAX_TMPBUF]; char port_name[MAX_TMPBUF];
int rc; int rc;
if (spdk_iscsi_tgt_node_find_pg_map(target, pg) != NULL) { if (iscsi_tgt_node_find_pg_map(target, pg) != NULL) {
return NULL; return NULL;
} }
@ -566,8 +566,8 @@ spdk_iscsi_tgt_node_add_pg_map(struct spdk_iscsi_tgt_node *target,
} }
static void static void
_spdk_iscsi_tgt_node_delete_pg_map(struct spdk_iscsi_tgt_node *target, _iscsi_tgt_node_delete_pg_map(struct spdk_iscsi_tgt_node *target,
struct spdk_iscsi_pg_map *pg_map) struct spdk_iscsi_pg_map *pg_map)
{ {
TAILQ_REMOVE(&target->pg_map_head, pg_map, tailq); TAILQ_REMOVE(&target->pg_map_head, pg_map, tailq);
target->num_pg_maps--; target->num_pg_maps--;
@ -579,12 +579,12 @@ _spdk_iscsi_tgt_node_delete_pg_map(struct spdk_iscsi_tgt_node *target,
} }
static int static int
spdk_iscsi_tgt_node_delete_pg_map(struct spdk_iscsi_tgt_node *target, iscsi_tgt_node_delete_pg_map(struct spdk_iscsi_tgt_node *target,
struct spdk_iscsi_portal_grp *pg) struct spdk_iscsi_portal_grp *pg)
{ {
struct spdk_iscsi_pg_map *pg_map; struct spdk_iscsi_pg_map *pg_map;
pg_map = spdk_iscsi_tgt_node_find_pg_map(target, pg); pg_map = iscsi_tgt_node_find_pg_map(target, pg);
if (pg_map == NULL) { if (pg_map == NULL) {
return -ENOENT; return -ENOENT;
} }
@ -594,38 +594,38 @@ spdk_iscsi_tgt_node_delete_pg_map(struct spdk_iscsi_tgt_node *target,
pg_map->num_ig_maps); pg_map->num_ig_maps);
} }
spdk_iscsi_pg_map_delete_all_ig_maps(pg_map); iscsi_pg_map_delete_all_ig_maps(pg_map);
_spdk_iscsi_tgt_node_delete_pg_map(target, pg_map); _iscsi_tgt_node_delete_pg_map(target, pg_map);
return 0; return 0;
} }
static void static void
spdk_iscsi_tgt_node_delete_ig_maps(struct spdk_iscsi_tgt_node *target, iscsi_tgt_node_delete_ig_maps(struct spdk_iscsi_tgt_node *target,
struct spdk_iscsi_init_grp *ig) struct spdk_iscsi_init_grp *ig)
{ {
struct spdk_iscsi_pg_map *pg_map, *tmp; struct spdk_iscsi_pg_map *pg_map, *tmp;
TAILQ_FOREACH_SAFE(pg_map, &target->pg_map_head, tailq, tmp) { TAILQ_FOREACH_SAFE(pg_map, &target->pg_map_head, tailq, tmp) {
spdk_iscsi_pg_map_delete_ig_map(pg_map, ig); iscsi_pg_map_delete_ig_map(pg_map, ig);
if (pg_map->num_ig_maps == 0) { if (pg_map->num_ig_maps == 0) {
_spdk_iscsi_tgt_node_delete_pg_map(target, pg_map); _iscsi_tgt_node_delete_pg_map(target, pg_map);
} }
} }
} }
static void static void
spdk_iscsi_tgt_node_delete_all_pg_maps(struct spdk_iscsi_tgt_node *target) iscsi_tgt_node_delete_all_pg_maps(struct spdk_iscsi_tgt_node *target)
{ {
struct spdk_iscsi_pg_map *pg_map, *tmp; struct spdk_iscsi_pg_map *pg_map, *tmp;
TAILQ_FOREACH_SAFE(pg_map, &target->pg_map_head, tailq, tmp) { TAILQ_FOREACH_SAFE(pg_map, &target->pg_map_head, tailq, tmp) {
spdk_iscsi_pg_map_delete_all_ig_maps(pg_map); iscsi_pg_map_delete_all_ig_maps(pg_map);
_spdk_iscsi_tgt_node_delete_pg_map(target, pg_map); _iscsi_tgt_node_delete_pg_map(target, pg_map);
} }
} }
static void static void
spdk_iscsi_tgt_node_destruct(struct spdk_iscsi_tgt_node *target) iscsi_tgt_node_destruct(struct spdk_iscsi_tgt_node *target)
{ {
if (target == NULL) { if (target == NULL) {
return; return;
@ -633,7 +633,7 @@ spdk_iscsi_tgt_node_destruct(struct spdk_iscsi_tgt_node *target)
free(target->name); free(target->name);
free(target->alias); free(target->alias);
spdk_iscsi_tgt_node_delete_all_pg_maps(target); iscsi_tgt_node_delete_all_pg_maps(target);
spdk_scsi_dev_destruct(target->dev); spdk_scsi_dev_destruct(target->dev);
pthread_mutex_destroy(&target->mutex); pthread_mutex_destroy(&target->mutex);
@ -641,8 +641,8 @@ spdk_iscsi_tgt_node_destruct(struct spdk_iscsi_tgt_node *target)
} }
static int static int
spdk_iscsi_tgt_node_delete_pg_ig_map(struct spdk_iscsi_tgt_node *target, iscsi_tgt_node_delete_pg_ig_map(struct spdk_iscsi_tgt_node *target,
int pg_tag, int ig_tag) int pg_tag, int ig_tag)
{ {
struct spdk_iscsi_portal_grp *pg; struct spdk_iscsi_portal_grp *pg;
struct spdk_iscsi_init_grp *ig; struct spdk_iscsi_init_grp *ig;
@ -660,28 +660,28 @@ spdk_iscsi_tgt_node_delete_pg_ig_map(struct spdk_iscsi_tgt_node *target,
return -ENOENT; return -ENOENT;
} }
pg_map = spdk_iscsi_tgt_node_find_pg_map(target, pg); pg_map = iscsi_tgt_node_find_pg_map(target, pg);
if (pg_map == NULL) { if (pg_map == NULL) {
SPDK_ERRLOG("%s: PortalGroup%d is not mapped\n", target->name, pg_tag); SPDK_ERRLOG("%s: PortalGroup%d is not mapped\n", target->name, pg_tag);
return -ENOENT; return -ENOENT;
} }
ig_map = spdk_iscsi_pg_map_find_ig_map(pg_map, ig); ig_map = iscsi_pg_map_find_ig_map(pg_map, ig);
if (ig_map == NULL) { if (ig_map == NULL) {
SPDK_ERRLOG("%s: InitiatorGroup%d is not mapped\n", target->name, pg_tag); SPDK_ERRLOG("%s: InitiatorGroup%d is not mapped\n", target->name, pg_tag);
return -ENOENT; return -ENOENT;
} }
_spdk_iscsi_pg_map_delete_ig_map(pg_map, ig_map); _iscsi_pg_map_delete_ig_map(pg_map, ig_map);
if (pg_map->num_ig_maps == 0) { if (pg_map->num_ig_maps == 0) {
_spdk_iscsi_tgt_node_delete_pg_map(target, pg_map); _iscsi_tgt_node_delete_pg_map(target, pg_map);
} }
return 0; return 0;
} }
static int static int
spdk_iscsi_tgt_node_add_pg_ig_map(struct spdk_iscsi_tgt_node *target, iscsi_tgt_node_add_pg_ig_map(struct spdk_iscsi_tgt_node *target,
int pg_tag, int ig_tag) int pg_tag, int ig_tag)
{ {
struct spdk_iscsi_portal_grp *pg; struct spdk_iscsi_portal_grp *pg;
struct spdk_iscsi_pg_map *pg_map; struct spdk_iscsi_pg_map *pg_map;
@ -701,9 +701,9 @@ spdk_iscsi_tgt_node_add_pg_ig_map(struct spdk_iscsi_tgt_node *target,
} }
/* get existing pg_map or create new pg_map and add it to target */ /* get existing pg_map or create new pg_map and add it to target */
pg_map = spdk_iscsi_tgt_node_find_pg_map(target, pg); pg_map = iscsi_tgt_node_find_pg_map(target, pg);
if (pg_map == NULL) { if (pg_map == NULL) {
pg_map = spdk_iscsi_tgt_node_add_pg_map(target, pg); pg_map = iscsi_tgt_node_add_pg_map(target, pg);
if (pg_map == NULL) { if (pg_map == NULL) {
goto failed; goto failed;
} }
@ -711,7 +711,7 @@ spdk_iscsi_tgt_node_add_pg_ig_map(struct spdk_iscsi_tgt_node *target,
} }
/* create new ig_map and add it to pg_map */ /* create new ig_map and add it to pg_map */
ig_map = spdk_iscsi_pg_map_add_ig_map(pg_map, ig); ig_map = iscsi_pg_map_add_ig_map(pg_map, ig);
if (ig_map == NULL) { if (ig_map == NULL) {
goto failed; goto failed;
} }
@ -720,7 +720,7 @@ spdk_iscsi_tgt_node_add_pg_ig_map(struct spdk_iscsi_tgt_node *target,
failed: failed:
if (new_pg_map) { if (new_pg_map) {
_spdk_iscsi_tgt_node_delete_pg_map(target, pg_map); _iscsi_tgt_node_delete_pg_map(target, pg_map);
} }
return -1; return -1;
@ -735,8 +735,8 @@ spdk_iscsi_tgt_node_add_pg_ig_maps(struct spdk_iscsi_tgt_node *target,
pthread_mutex_lock(&g_spdk_iscsi.mutex); pthread_mutex_lock(&g_spdk_iscsi.mutex);
for (i = 0; i < num_maps; i++) { for (i = 0; i < num_maps; i++) {
rc = spdk_iscsi_tgt_node_add_pg_ig_map(target, pg_tag_list[i], rc = iscsi_tgt_node_add_pg_ig_map(target, pg_tag_list[i],
ig_tag_list[i]); ig_tag_list[i]);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("could not add map to target\n"); SPDK_ERRLOG("could not add map to target\n");
goto invalid; goto invalid;
@ -747,8 +747,8 @@ spdk_iscsi_tgt_node_add_pg_ig_maps(struct spdk_iscsi_tgt_node *target,
invalid: invalid:
for (; i > 0; --i) { for (; i > 0; --i) {
spdk_iscsi_tgt_node_delete_pg_ig_map(target, pg_tag_list[i - 1], iscsi_tgt_node_delete_pg_ig_map(target, pg_tag_list[i - 1],
ig_tag_list[i - 1]); ig_tag_list[i - 1]);
} }
pthread_mutex_unlock(&g_spdk_iscsi.mutex); pthread_mutex_unlock(&g_spdk_iscsi.mutex);
return -1; return -1;
@ -763,8 +763,8 @@ spdk_iscsi_tgt_node_delete_pg_ig_maps(struct spdk_iscsi_tgt_node *target,
pthread_mutex_lock(&g_spdk_iscsi.mutex); pthread_mutex_lock(&g_spdk_iscsi.mutex);
for (i = 0; i < num_maps; i++) { for (i = 0; i < num_maps; i++) {
rc = spdk_iscsi_tgt_node_delete_pg_ig_map(target, pg_tag_list[i], rc = iscsi_tgt_node_delete_pg_ig_map(target, pg_tag_list[i],
ig_tag_list[i]); ig_tag_list[i]);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("could not delete map from target\n"); SPDK_ERRLOG("could not delete map from target\n");
goto invalid; goto invalid;
@ -775,10 +775,10 @@ spdk_iscsi_tgt_node_delete_pg_ig_maps(struct spdk_iscsi_tgt_node *target,
invalid: invalid:
for (; i > 0; --i) { for (; i > 0; --i) {
rc = spdk_iscsi_tgt_node_add_pg_ig_map(target, pg_tag_list[i - 1], rc = iscsi_tgt_node_add_pg_ig_map(target, pg_tag_list[i - 1],
ig_tag_list[i - 1]); ig_tag_list[i - 1]);
if (rc != 0) { if (rc != 0) {
spdk_iscsi_tgt_node_delete_all_pg_maps(target); iscsi_tgt_node_delete_all_pg_maps(target);
break; break;
} }
} }
@ -787,7 +787,7 @@ invalid:
} }
static int static int
spdk_check_iscsi_name(const char *name) check_iscsi_name(const char *name)
{ {
const unsigned char *up = (const unsigned char *) name; const unsigned char *up = (const unsigned char *) name;
size_t n; size_t n;
@ -893,7 +893,7 @@ spdk_iscsi_tgt_node_construct(int target_index,
snprintf(fullname, sizeof(fullname), "%s", name); snprintf(fullname, sizeof(fullname), "%s", name);
} }
if (spdk_check_iscsi_name(fullname) != 0) { if (check_iscsi_name(fullname) != 0) {
SPDK_ERRLOG("TargetName %s contains an invalid character or format.\n", SPDK_ERRLOG("TargetName %s contains an invalid character or format.\n",
name); name);
return NULL; return NULL;
@ -910,7 +910,7 @@ spdk_iscsi_tgt_node_construct(int target_index,
rc = pthread_mutex_init(&target->mutex, NULL); rc = pthread_mutex_init(&target->mutex, NULL);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("tgt_node%d: mutex_init() failed\n", target->num); SPDK_ERRLOG("tgt_node%d: mutex_init() failed\n", target->num);
spdk_iscsi_tgt_node_destruct(target); iscsi_tgt_node_destruct(target);
return NULL; return NULL;
} }
@ -919,7 +919,7 @@ spdk_iscsi_tgt_node_construct(int target_index,
target->name = strdup(fullname); target->name = strdup(fullname);
if (!target->name) { if (!target->name) {
SPDK_ERRLOG("Could not allocate TargetName\n"); SPDK_ERRLOG("Could not allocate TargetName\n");
spdk_iscsi_tgt_node_destruct(target); iscsi_tgt_node_destruct(target);
return NULL; return NULL;
} }
@ -929,7 +929,7 @@ spdk_iscsi_tgt_node_construct(int target_index,
target->alias = strdup(alias); target->alias = strdup(alias);
if (!target->alias) { if (!target->alias) {
SPDK_ERRLOG("Could not allocate TargetAlias\n"); SPDK_ERRLOG("Could not allocate TargetAlias\n");
spdk_iscsi_tgt_node_destruct(target); iscsi_tgt_node_destruct(target);
return NULL; return NULL;
} }
} }
@ -938,7 +938,7 @@ spdk_iscsi_tgt_node_construct(int target_index,
SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL); SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL);
if (!target->dev) { if (!target->dev) {
SPDK_ERRLOG("Could not construct SCSI device\n"); SPDK_ERRLOG("Could not construct SCSI device\n");
spdk_iscsi_tgt_node_destruct(target); iscsi_tgt_node_destruct(target);
return NULL; return NULL;
} }
@ -946,7 +946,7 @@ spdk_iscsi_tgt_node_construct(int target_index,
rc = spdk_iscsi_tgt_node_add_pg_ig_maps(target, pg_tag_list, ig_tag_list, num_maps); rc = spdk_iscsi_tgt_node_add_pg_ig_maps(target, pg_tag_list, ig_tag_list, num_maps);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("could not add map to target\n"); SPDK_ERRLOG("could not add map to target\n");
spdk_iscsi_tgt_node_destruct(target); iscsi_tgt_node_destruct(target);
return NULL; return NULL;
} }
@ -965,10 +965,10 @@ spdk_iscsi_tgt_node_construct(int target_index,
target->queue_depth = g_spdk_iscsi.MaxQueueDepth; target->queue_depth = g_spdk_iscsi.MaxQueueDepth;
} }
rc = spdk_iscsi_tgt_node_register(target); rc = iscsi_tgt_node_register(target);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("register target is failed\n"); SPDK_ERRLOG("register target is failed\n");
spdk_iscsi_tgt_node_destruct(target); iscsi_tgt_node_destruct(target);
return NULL; return NULL;
} }
@ -976,7 +976,7 @@ spdk_iscsi_tgt_node_construct(int target_index,
} }
static int static int
spdk_iscsi_parse_tgt_node(struct spdk_conf_section *sp) iscsi_parse_tgt_node(struct spdk_conf_section *sp)
{ {
char buf[MAX_TMPBUF]; char buf[MAX_TMPBUF];
struct spdk_iscsi_tgt_node *target; struct spdk_iscsi_tgt_node *target;
@ -1213,7 +1213,7 @@ int spdk_iscsi_parse_tgt_nodes(void)
SPDK_ERRLOG("tag %d is invalid\n", tag); SPDK_ERRLOG("tag %d is invalid\n", tag);
return -1; return -1;
} }
rc = spdk_iscsi_parse_tgt_node(sp); rc = iscsi_parse_tgt_node(sp);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("spdk_iscsi_parse_tgt_node() failed\n"); SPDK_ERRLOG("spdk_iscsi_parse_tgt_node() failed\n");
return -1; return -1;
@ -1232,7 +1232,7 @@ spdk_iscsi_shutdown_tgt_nodes(void)
pthread_mutex_lock(&g_spdk_iscsi.mutex); pthread_mutex_lock(&g_spdk_iscsi.mutex);
TAILQ_FOREACH_SAFE(target, &g_spdk_iscsi.target_head, tailq, tmp) { TAILQ_FOREACH_SAFE(target, &g_spdk_iscsi.target_head, tailq, tmp) {
TAILQ_REMOVE(&g_spdk_iscsi.target_head, target, tailq); TAILQ_REMOVE(&g_spdk_iscsi.target_head, target, tailq);
spdk_iscsi_tgt_node_destruct(target); iscsi_tgt_node_destruct(target);
} }
pthread_mutex_unlock(&g_spdk_iscsi.mutex); pthread_mutex_unlock(&g_spdk_iscsi.mutex);
} }
@ -1245,8 +1245,8 @@ spdk_iscsi_shutdown_tgt_node_by_name(const char *target_name)
pthread_mutex_lock(&g_spdk_iscsi.mutex); pthread_mutex_lock(&g_spdk_iscsi.mutex);
target = spdk_iscsi_find_tgt_node(target_name); target = spdk_iscsi_find_tgt_node(target_name);
if (target != NULL) { if (target != NULL) {
spdk_iscsi_tgt_node_unregister(target); iscsi_tgt_node_unregister(target);
spdk_iscsi_tgt_node_destruct(target); iscsi_tgt_node_destruct(target);
pthread_mutex_unlock(&g_spdk_iscsi.mutex); pthread_mutex_unlock(&g_spdk_iscsi.mutex);
return 0; return 0;
@ -1295,10 +1295,10 @@ void spdk_iscsi_tgt_node_delete_map(struct spdk_iscsi_portal_grp *portal_group,
pthread_mutex_lock(&g_spdk_iscsi.mutex); pthread_mutex_lock(&g_spdk_iscsi.mutex);
TAILQ_FOREACH(target, &g_spdk_iscsi.target_head, tailq) { TAILQ_FOREACH(target, &g_spdk_iscsi.target_head, tailq) {
if (portal_group) { if (portal_group) {
spdk_iscsi_tgt_node_delete_pg_map(target, portal_group); iscsi_tgt_node_delete_pg_map(target, portal_group);
} }
if (initiator_group) { if (initiator_group) {
spdk_iscsi_tgt_node_delete_ig_maps(target, initiator_group); iscsi_tgt_node_delete_ig_maps(target, initiator_group);
} }
} }
pthread_mutex_unlock(&g_spdk_iscsi.mutex); pthread_mutex_unlock(&g_spdk_iscsi.mutex);
@ -1456,8 +1456,8 @@ spdk_iscsi_tgt_nodes_config_text(FILE *fp)
} }
static void static void
spdk_iscsi_tgt_node_info_json(struct spdk_iscsi_tgt_node *target, iscsi_tgt_node_info_json(struct spdk_iscsi_tgt_node *target,
struct spdk_json_write_ctx *w) struct spdk_json_write_ctx *w)
{ {
struct spdk_iscsi_pg_map *pg_map; struct spdk_iscsi_pg_map *pg_map;
struct spdk_iscsi_ig_map *ig_map; struct spdk_iscsi_ig_map *ig_map;
@ -1509,15 +1509,15 @@ spdk_iscsi_tgt_node_info_json(struct spdk_iscsi_tgt_node *target,
} }
static void static void
spdk_iscsi_tgt_node_config_json(struct spdk_iscsi_tgt_node *target, iscsi_tgt_node_config_json(struct spdk_iscsi_tgt_node *target,
struct spdk_json_write_ctx *w) struct spdk_json_write_ctx *w)
{ {
spdk_json_write_object_begin(w); spdk_json_write_object_begin(w);
spdk_json_write_named_string(w, "method", "construct_target_node"); spdk_json_write_named_string(w, "method", "construct_target_node");
spdk_json_write_name(w, "params"); spdk_json_write_name(w, "params");
spdk_iscsi_tgt_node_info_json(target, w); iscsi_tgt_node_info_json(target, w);
spdk_json_write_object_end(w); spdk_json_write_object_end(w);
} }
@ -1528,7 +1528,7 @@ spdk_iscsi_tgt_nodes_info_json(struct spdk_json_write_ctx *w)
struct spdk_iscsi_tgt_node *target; struct spdk_iscsi_tgt_node *target;
TAILQ_FOREACH(target, &g_spdk_iscsi.target_head, tailq) { TAILQ_FOREACH(target, &g_spdk_iscsi.target_head, tailq) {
spdk_iscsi_tgt_node_info_json(target, w); iscsi_tgt_node_info_json(target, w);
} }
} }
@ -1538,6 +1538,6 @@ spdk_iscsi_tgt_nodes_config_json(struct spdk_json_write_ctx *w)
struct spdk_iscsi_tgt_node *target; struct spdk_iscsi_tgt_node *target;
TAILQ_FOREACH(target, &g_spdk_iscsi.target_head, tailq) { TAILQ_FOREACH(target, &g_spdk_iscsi.target_head, tailq) {
spdk_iscsi_tgt_node_config_json(target, w); iscsi_tgt_node_config_json(target, w);
} }
} }

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

@ -74,7 +74,7 @@ create_from_config_file_cases(void)
break; break;
} }
rc = spdk_iscsi_parse_init_grp(sp); rc = iscsi_parse_init_grp(sp);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
spdk_iscsi_init_grps_destroy(); spdk_iscsi_init_grps_destroy();
@ -91,7 +91,7 @@ create_from_config_file_cases(void)
break; break;
} }
rc = spdk_iscsi_parse_init_grp(sp); rc = iscsi_parse_init_grp(sp);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
spdk_iscsi_init_grps_destroy(); spdk_iscsi_init_grps_destroy();
@ -108,7 +108,7 @@ create_initiator_group_success_case(void)
{ {
struct spdk_iscsi_init_grp *ig; struct spdk_iscsi_init_grp *ig;
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
spdk_iscsi_init_grp_destroy(ig); spdk_iscsi_init_grp_destroy(ig);
@ -120,7 +120,7 @@ find_initiator_group_success_case(void)
struct spdk_iscsi_init_grp *ig, *tmp; struct spdk_iscsi_init_grp *ig, *tmp;
int rc; int rc;
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
rc = spdk_iscsi_init_grp_register(ig); rc = spdk_iscsi_init_grp_register(ig);
@ -143,7 +143,7 @@ register_initiator_group_twice_case(void)
struct spdk_iscsi_init_grp *ig, *tmp; struct spdk_iscsi_init_grp *ig, *tmp;
int rc; int rc;
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
rc = spdk_iscsi_init_grp_register(ig); rc = spdk_iscsi_init_grp_register(ig);
@ -173,34 +173,34 @@ add_initiator_name_success_case(void)
char *name1 = "iqn.2017-10.spdk.io:0001"; char *name1 = "iqn.2017-10.spdk.io:0001";
char *name2 = "iqn.2017-10.spdk.io:0002"; char *name2 = "iqn.2017-10.spdk.io:0002";
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
/* add two different names to the empty name list */ /* add two different names to the empty name list */
rc = spdk_iscsi_init_grp_add_initiator(ig, name1); rc = iscsi_init_grp_add_initiator(ig, name1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_init_grp_add_initiator(ig, name2); rc = iscsi_init_grp_add_initiator(ig, name2);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
/* check if two names are added correctly. */ /* check if two names are added correctly. */
iname = spdk_iscsi_init_grp_find_initiator(ig, name1); iname = iscsi_init_grp_find_initiator(ig, name1);
CU_ASSERT(iname != NULL); CU_ASSERT(iname != NULL);
iname = spdk_iscsi_init_grp_find_initiator(ig, name2); iname = iscsi_init_grp_find_initiator(ig, name2);
CU_ASSERT(iname != NULL); CU_ASSERT(iname != NULL);
/* restore the initial state */ /* restore the initial state */
rc = spdk_iscsi_init_grp_delete_initiator(ig, name1); rc = iscsi_init_grp_delete_initiator(ig, name1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
iname = spdk_iscsi_init_grp_find_initiator(ig, name1); iname = iscsi_init_grp_find_initiator(ig, name1);
CU_ASSERT(iname == NULL); CU_ASSERT(iname == NULL);
rc = spdk_iscsi_init_grp_delete_initiator(ig, name2); rc = iscsi_init_grp_delete_initiator(ig, name2);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
iname = spdk_iscsi_init_grp_find_initiator(ig, name2); iname = iscsi_init_grp_find_initiator(ig, name2);
CU_ASSERT(iname == NULL); CU_ASSERT(iname == NULL);
spdk_iscsi_init_grp_destroy(ig); spdk_iscsi_init_grp_destroy(ig);
@ -214,29 +214,29 @@ add_initiator_name_fail_case(void)
struct spdk_iscsi_initiator_name *iname; struct spdk_iscsi_initiator_name *iname;
char *name1 = "iqn.2017-10.spdk.io:0001"; char *name1 = "iqn.2017-10.spdk.io:0001";
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
/* add an name to the full name list */ /* add an name to the full name list */
ig->ninitiators = MAX_INITIATOR; ig->ninitiators = MAX_INITIATOR;
rc = spdk_iscsi_init_grp_add_initiator(ig, name1); rc = iscsi_init_grp_add_initiator(ig, name1);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
ig->ninitiators = 0; ig->ninitiators = 0;
/* add the same name to the name list twice */ /* add the same name to the name list twice */
rc = spdk_iscsi_init_grp_add_initiator(ig, name1); rc = iscsi_init_grp_add_initiator(ig, name1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_init_grp_add_initiator(ig, name1); rc = iscsi_init_grp_add_initiator(ig, name1);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
/* restore the initial state */ /* restore the initial state */
rc = spdk_iscsi_init_grp_delete_initiator(ig, name1); rc = iscsi_init_grp_delete_initiator(ig, name1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
iname = spdk_iscsi_init_grp_find_initiator(ig, name1); iname = iscsi_init_grp_find_initiator(ig, name1);
CU_ASSERT(iname == NULL); CU_ASSERT(iname == NULL);
spdk_iscsi_init_grp_destroy(ig); spdk_iscsi_init_grp_destroy(ig);
@ -251,24 +251,24 @@ delete_all_initiator_names_success_case(void)
char *name1 = "iqn.2017-10.spdk.io:0001"; char *name1 = "iqn.2017-10.spdk.io:0001";
char *name2 = "iqn.2017-10.spdk.io:0002"; char *name2 = "iqn.2017-10.spdk.io:0002";
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
/* add two different names to the empty name list */ /* add two different names to the empty name list */
rc = spdk_iscsi_init_grp_add_initiator(ig, name1); rc = iscsi_init_grp_add_initiator(ig, name1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_init_grp_add_initiator(ig, name2); rc = iscsi_init_grp_add_initiator(ig, name2);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
/* delete all initiator names */ /* delete all initiator names */
spdk_iscsi_init_grp_delete_all_initiators(ig); iscsi_init_grp_delete_all_initiators(ig);
/* check if two names are deleted correctly. */ /* check if two names are deleted correctly. */
iname = spdk_iscsi_init_grp_find_initiator(ig, name1); iname = iscsi_init_grp_find_initiator(ig, name1);
CU_ASSERT(iname == NULL); CU_ASSERT(iname == NULL);
iname = spdk_iscsi_init_grp_find_initiator(ig, name2); iname = iscsi_init_grp_find_initiator(ig, name2);
CU_ASSERT(iname == NULL); CU_ASSERT(iname == NULL);
/* restore the initial state */ /* restore the initial state */
@ -284,34 +284,34 @@ add_netmask_success_case(void)
char *netmask1 = "192.168.2.0"; char *netmask1 = "192.168.2.0";
char *netmask2 = "192.168.2.1"; char *netmask2 = "192.168.2.1";
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
/* add two different netmasks to the empty netmask list */ /* add two different netmasks to the empty netmask list */
rc = spdk_iscsi_init_grp_add_netmask(ig, netmask1); rc = iscsi_init_grp_add_netmask(ig, netmask1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_init_grp_add_netmask(ig, netmask2); rc = iscsi_init_grp_add_netmask(ig, netmask2);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
/* check if two netmasks are added correctly. */ /* check if two netmasks are added correctly. */
imask = spdk_iscsi_init_grp_find_netmask(ig, netmask1); imask = iscsi_init_grp_find_netmask(ig, netmask1);
CU_ASSERT(imask != NULL); CU_ASSERT(imask != NULL);
imask = spdk_iscsi_init_grp_find_netmask(ig, netmask2); imask = iscsi_init_grp_find_netmask(ig, netmask2);
CU_ASSERT(imask != NULL); CU_ASSERT(imask != NULL);
/* restore the initial state */ /* restore the initial state */
rc = spdk_iscsi_init_grp_delete_netmask(ig, netmask1); rc = iscsi_init_grp_delete_netmask(ig, netmask1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
imask = spdk_iscsi_init_grp_find_netmask(ig, netmask1); imask = iscsi_init_grp_find_netmask(ig, netmask1);
CU_ASSERT(imask == NULL); CU_ASSERT(imask == NULL);
rc = spdk_iscsi_init_grp_delete_netmask(ig, netmask2); rc = iscsi_init_grp_delete_netmask(ig, netmask2);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
imask = spdk_iscsi_init_grp_find_netmask(ig, netmask2); imask = iscsi_init_grp_find_netmask(ig, netmask2);
CU_ASSERT(imask == NULL); CU_ASSERT(imask == NULL);
spdk_iscsi_init_grp_destroy(ig); spdk_iscsi_init_grp_destroy(ig);
@ -325,29 +325,29 @@ add_netmask_fail_case(void)
struct spdk_iscsi_initiator_netmask *imask; struct spdk_iscsi_initiator_netmask *imask;
char *netmask1 = "192.168.2.0"; char *netmask1 = "192.168.2.0";
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
/* add an netmask to the full netmask list */ /* add an netmask to the full netmask list */
ig->nnetmasks = MAX_NETMASK; ig->nnetmasks = MAX_NETMASK;
rc = spdk_iscsi_init_grp_add_netmask(ig, netmask1); rc = iscsi_init_grp_add_netmask(ig, netmask1);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
ig->nnetmasks = 0; ig->nnetmasks = 0;
/* add the same netmask to the netmask list twice */ /* add the same netmask to the netmask list twice */
rc = spdk_iscsi_init_grp_add_netmask(ig, netmask1); rc = iscsi_init_grp_add_netmask(ig, netmask1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_init_grp_add_netmask(ig, netmask1); rc = iscsi_init_grp_add_netmask(ig, netmask1);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
/* restore the initial state */ /* restore the initial state */
rc = spdk_iscsi_init_grp_delete_netmask(ig, netmask1); rc = iscsi_init_grp_delete_netmask(ig, netmask1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
imask = spdk_iscsi_init_grp_find_netmask(ig, netmask1); imask = iscsi_init_grp_find_netmask(ig, netmask1);
CU_ASSERT(imask == NULL); CU_ASSERT(imask == NULL);
spdk_iscsi_init_grp_destroy(ig); spdk_iscsi_init_grp_destroy(ig);
@ -362,24 +362,24 @@ delete_all_netmasks_success_case(void)
char *netmask1 = "192.168.2.0"; char *netmask1 = "192.168.2.0";
char *netmask2 = "192.168.2.1"; char *netmask2 = "192.168.2.1";
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
/* add two different netmasks to the empty netmask list */ /* add two different netmasks to the empty netmask list */
rc = spdk_iscsi_init_grp_add_netmask(ig, netmask1); rc = iscsi_init_grp_add_netmask(ig, netmask1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_init_grp_add_netmask(ig, netmask2); rc = iscsi_init_grp_add_netmask(ig, netmask2);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
/* delete all netmasks */ /* delete all netmasks */
spdk_iscsi_init_grp_delete_all_netmasks(ig); iscsi_init_grp_delete_all_netmasks(ig);
/* check if two netmasks are deleted correctly. */ /* check if two netmasks are deleted correctly. */
imask = spdk_iscsi_init_grp_find_netmask(ig, netmask1); imask = iscsi_init_grp_find_netmask(ig, netmask1);
CU_ASSERT(imask == NULL); CU_ASSERT(imask == NULL);
imask = spdk_iscsi_init_grp_find_netmask(ig, netmask2); imask = iscsi_init_grp_find_netmask(ig, netmask2);
CU_ASSERT(imask == NULL); CU_ASSERT(imask == NULL);
/* restore the initial state */ /* restore the initial state */
@ -397,31 +397,31 @@ initiator_name_overwrite_all_to_any_case(void)
char *all_not = "!ALL"; char *all_not = "!ALL";
char *any_not = "!ANY"; char *any_not = "!ANY";
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
rc = spdk_iscsi_init_grp_add_initiator(ig, all); rc = iscsi_init_grp_add_initiator(ig, all);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
iname = spdk_iscsi_init_grp_find_initiator(ig, all); iname = iscsi_init_grp_find_initiator(ig, all);
CU_ASSERT(iname == NULL); CU_ASSERT(iname == NULL);
iname = spdk_iscsi_init_grp_find_initiator(ig, any); iname = iscsi_init_grp_find_initiator(ig, any);
CU_ASSERT(iname != NULL); CU_ASSERT(iname != NULL);
rc = spdk_iscsi_init_grp_delete_initiator(ig, any); rc = iscsi_init_grp_delete_initiator(ig, any);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_init_grp_add_initiator(ig, all_not); rc = iscsi_init_grp_add_initiator(ig, all_not);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
iname = spdk_iscsi_init_grp_find_initiator(ig, all_not); iname = iscsi_init_grp_find_initiator(ig, all_not);
CU_ASSERT(iname == NULL); CU_ASSERT(iname == NULL);
iname = spdk_iscsi_init_grp_find_initiator(ig, any_not); iname = iscsi_init_grp_find_initiator(ig, any_not);
CU_ASSERT(iname != NULL); CU_ASSERT(iname != NULL);
rc = spdk_iscsi_init_grp_delete_initiator(ig, any_not); rc = iscsi_init_grp_delete_initiator(ig, any_not);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
spdk_iscsi_init_grp_destroy(ig); spdk_iscsi_init_grp_destroy(ig);
@ -436,19 +436,19 @@ netmask_overwrite_all_to_any_case(void)
char *all = "ALL"; char *all = "ALL";
char *any = "ANY"; char *any = "ANY";
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
CU_ASSERT(ig != NULL); CU_ASSERT(ig != NULL);
rc = spdk_iscsi_init_grp_add_netmask(ig, all); rc = iscsi_init_grp_add_netmask(ig, all);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
imask = spdk_iscsi_init_grp_find_netmask(ig, all); imask = iscsi_init_grp_find_netmask(ig, all);
CU_ASSERT(imask == NULL); CU_ASSERT(imask == NULL);
imask = spdk_iscsi_init_grp_find_netmask(ig, any); imask = iscsi_init_grp_find_netmask(ig, any);
CU_ASSERT(imask != NULL); CU_ASSERT(imask != NULL);
rc = spdk_iscsi_init_grp_delete_netmask(ig, any); rc = iscsi_init_grp_delete_netmask(ig, any);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
spdk_iscsi_init_grp_destroy(ig); spdk_iscsi_init_grp_destroy(ig);
@ -462,18 +462,18 @@ add_delete_initiator_names_case(void)
struct spdk_iscsi_initiator_name *iname; struct spdk_iscsi_initiator_name *iname;
char *names[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0003"}; char *names[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0003"};
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
SPDK_CU_ASSERT_FATAL(ig != NULL); SPDK_CU_ASSERT_FATAL(ig != NULL);
rc = spdk_iscsi_init_grp_add_initiators(ig, 3, names); rc = iscsi_init_grp_add_initiators(ig, 3, names);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
iname = spdk_iscsi_init_grp_find_initiator(ig, names[i]); iname = iscsi_init_grp_find_initiator(ig, names[i]);
CU_ASSERT(iname != NULL); CU_ASSERT(iname != NULL);
} }
rc = spdk_iscsi_init_grp_delete_initiators(ig, 3, names); rc = iscsi_init_grp_delete_initiators(ig, 3, names);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
if (ig != NULL) { if (ig != NULL) {
@ -490,10 +490,10 @@ add_duplicated_initiator_names_case(void)
struct spdk_iscsi_init_grp *ig; struct spdk_iscsi_init_grp *ig;
char *names[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0001"}; char *names[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0001"};
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
SPDK_CU_ASSERT_FATAL(ig != NULL); SPDK_CU_ASSERT_FATAL(ig != NULL);
rc = spdk_iscsi_init_grp_add_initiators(ig, 3, names); rc = iscsi_init_grp_add_initiators(ig, 3, names);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
if (ig != NULL) { if (ig != NULL) {
@ -512,26 +512,26 @@ delete_nonexisting_initiator_names_case(void)
char *names1[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0003"}; char *names1[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0003"};
char *names2[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0004"}; char *names2[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0004"};
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
SPDK_CU_ASSERT_FATAL(ig != NULL); SPDK_CU_ASSERT_FATAL(ig != NULL);
rc = spdk_iscsi_init_grp_add_initiators(ig, 3, names1); rc = iscsi_init_grp_add_initiators(ig, 3, names1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
iname = spdk_iscsi_init_grp_find_initiator(ig, names1[i]); iname = iscsi_init_grp_find_initiator(ig, names1[i]);
CU_ASSERT(iname != NULL); CU_ASSERT(iname != NULL);
} }
rc = spdk_iscsi_init_grp_delete_initiators(ig, 3, names2); rc = iscsi_init_grp_delete_initiators(ig, 3, names2);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
iname = spdk_iscsi_init_grp_find_initiator(ig, names1[i]); iname = iscsi_init_grp_find_initiator(ig, names1[i]);
CU_ASSERT(iname != NULL); CU_ASSERT(iname != NULL);
} }
rc = spdk_iscsi_init_grp_delete_initiators(ig, 3, names1); rc = iscsi_init_grp_delete_initiators(ig, 3, names1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
if (ig != NULL) { if (ig != NULL) {
@ -549,18 +549,18 @@ add_delete_netmasks_case(void)
struct spdk_iscsi_initiator_netmask *netmask; struct spdk_iscsi_initiator_netmask *netmask;
char *netmasks[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.2"}; char *netmasks[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.2"};
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
SPDK_CU_ASSERT_FATAL(ig != NULL); SPDK_CU_ASSERT_FATAL(ig != NULL);
rc = spdk_iscsi_init_grp_add_netmasks(ig, 3, netmasks); rc = iscsi_init_grp_add_netmasks(ig, 3, netmasks);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
netmask = spdk_iscsi_init_grp_find_netmask(ig, netmasks[i]); netmask = iscsi_init_grp_find_netmask(ig, netmasks[i]);
CU_ASSERT(netmask != NULL); CU_ASSERT(netmask != NULL);
} }
rc = spdk_iscsi_init_grp_delete_netmasks(ig, 3, netmasks); rc = iscsi_init_grp_delete_netmasks(ig, 3, netmasks);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
if (ig != NULL) { if (ig != NULL) {
@ -577,10 +577,10 @@ add_duplicated_netmasks_case(void)
struct spdk_iscsi_init_grp *ig; struct spdk_iscsi_init_grp *ig;
char *netmasks[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.0"}; char *netmasks[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.0"};
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
SPDK_CU_ASSERT_FATAL(ig != NULL); SPDK_CU_ASSERT_FATAL(ig != NULL);
rc = spdk_iscsi_init_grp_add_netmasks(ig, 3, netmasks); rc = iscsi_init_grp_add_netmasks(ig, 3, netmasks);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
if (ig != NULL) { if (ig != NULL) {
@ -599,26 +599,26 @@ delete_nonexisting_netmasks_case(void)
char *netmasks1[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.2"}; char *netmasks1[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.2"};
char *netmasks2[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.3"}; char *netmasks2[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.3"};
ig = spdk_iscsi_init_grp_create(1); ig = iscsi_init_grp_create(1);
SPDK_CU_ASSERT_FATAL(ig != NULL); SPDK_CU_ASSERT_FATAL(ig != NULL);
rc = spdk_iscsi_init_grp_add_netmasks(ig, 3, netmasks1); rc = iscsi_init_grp_add_netmasks(ig, 3, netmasks1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
netmask = spdk_iscsi_init_grp_find_netmask(ig, netmasks1[i]); netmask = iscsi_init_grp_find_netmask(ig, netmasks1[i]);
CU_ASSERT(netmask != NULL); CU_ASSERT(netmask != NULL);
} }
rc = spdk_iscsi_init_grp_delete_netmasks(ig, 3, netmasks2); rc = iscsi_init_grp_delete_netmasks(ig, 3, netmasks2);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
netmask = spdk_iscsi_init_grp_find_netmask(ig, netmasks1[i]); netmask = iscsi_init_grp_find_netmask(ig, netmasks1[i]);
CU_ASSERT(netmask != NULL); CU_ASSERT(netmask != NULL);
} }
rc = spdk_iscsi_init_grp_delete_netmasks(ig, 3, netmasks1); rc = iscsi_init_grp_delete_netmasks(ig, 3, netmasks1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
if (ig != NULL) { if (ig != NULL) {

130
test/unit/lib/iscsi/iscsi.c/iscsi_ut.c
View File

@ -123,24 +123,24 @@ op_login_check_target_test(void)
snprintf(conn.initiator_name, sizeof(conn.initiator_name), snprintf(conn.initiator_name, sizeof(conn.initiator_name),
"%s", UT_INITIATOR_NAME1); "%s", UT_INITIATOR_NAME1);
rc = spdk_iscsi_op_login_check_target(&conn, &rsp_pdu, rc = iscsi_op_login_check_target(&conn, &rsp_pdu,
UT_TARGET_NAME1, &target); UT_TARGET_NAME1, &target);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
/* expect failure */ /* expect failure */
snprintf(conn.initiator_name, sizeof(conn.initiator_name), snprintf(conn.initiator_name, sizeof(conn.initiator_name),
"%s", UT_INITIATOR_NAME1); "%s", UT_INITIATOR_NAME1);
rc = spdk_iscsi_op_login_check_target(&conn, &rsp_pdu, rc = iscsi_op_login_check_target(&conn, &rsp_pdu,
UT_TARGET_NAME2, &target); UT_TARGET_NAME2, &target);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
/* expect failure */ /* expect failure */
snprintf(conn.initiator_name, sizeof(conn.initiator_name), snprintf(conn.initiator_name, sizeof(conn.initiator_name),
"%s", UT_INITIATOR_NAME2); "%s", UT_INITIATOR_NAME2);
rc = spdk_iscsi_op_login_check_target(&conn, &rsp_pdu, rc = iscsi_op_login_check_target(&conn, &rsp_pdu,
UT_TARGET_NAME1, &target); UT_TARGET_NAME1, &target);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
} }
@ -558,7 +558,7 @@ add_transfer_task_test(void)
/* The following tests if the task is queued because R2T tasks are full. */ /* The following tests if the task is queued because R2T tasks are full. */
conn.pending_r2t = DEFAULT_MAXR2T; conn.pending_r2t = DEFAULT_MAXR2T;
rc = spdk_add_transfer_task(&conn, &task); rc = add_transfer_task(&conn, &task);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
CU_ASSERT(TAILQ_FIRST(&conn.queued_r2t_tasks) == &task); CU_ASSERT(TAILQ_FIRST(&conn.queued_r2t_tasks) == &task);
@ -569,7 +569,7 @@ add_transfer_task_test(void)
/* The following tests if multiple R2Ts are issued. */ /* The following tests if multiple R2Ts are issued. */
conn.pending_r2t = 0; conn.pending_r2t = 0;
rc = spdk_add_transfer_task(&conn, &task); rc = add_transfer_task(&conn, &task);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
CU_ASSERT(TAILQ_FIRST(&conn.active_r2t_tasks) == &task); CU_ASSERT(TAILQ_FIRST(&conn.active_r2t_tasks) == &task);
@ -637,7 +637,7 @@ get_transfer_task_test(void)
task1.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; task1.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
spdk_iscsi_task_set_pdu(&task1, pdu1); spdk_iscsi_task_set_pdu(&task1, pdu1);
rc = spdk_add_transfer_task(&conn, &task1); rc = add_transfer_task(&conn, &task1);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
pdu2 = spdk_get_pdu(); pdu2 = spdk_get_pdu();
@ -647,13 +647,13 @@ get_transfer_task_test(void)
task2.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; task2.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
spdk_iscsi_task_set_pdu(&task2, pdu2); spdk_iscsi_task_set_pdu(&task2, pdu2);
rc = spdk_add_transfer_task(&conn, &task2); rc = add_transfer_task(&conn, &task2);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
task = spdk_get_transfer_task(&conn, 1); task = get_transfer_task(&conn, 1);
CU_ASSERT(task == &task1); CU_ASSERT(task == &task1);
task = spdk_get_transfer_task(&conn, 2); task = get_transfer_task(&conn, 2);
CU_ASSERT(task == &task2); CU_ASSERT(task == &task2);
while (!TAILQ_EMPTY(&conn.active_r2t_tasks)) { while (!TAILQ_EMPTY(&conn.active_r2t_tasks)) {
@ -703,7 +703,7 @@ del_transfer_task_test(void)
spdk_iscsi_task_set_pdu(&task1, pdu1); spdk_iscsi_task_set_pdu(&task1, pdu1);
task1.tag = 11; task1.tag = 11;
rc = spdk_add_transfer_task(&conn, &task1); rc = add_transfer_task(&conn, &task1);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
pdu2 = spdk_get_pdu(); pdu2 = spdk_get_pdu();
@ -714,7 +714,7 @@ del_transfer_task_test(void)
spdk_iscsi_task_set_pdu(&task2, pdu2); spdk_iscsi_task_set_pdu(&task2, pdu2);
task2.tag = 12; task2.tag = 12;
rc = spdk_add_transfer_task(&conn, &task2); rc = add_transfer_task(&conn, &task2);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
pdu3 = spdk_get_pdu(); pdu3 = spdk_get_pdu();
@ -725,7 +725,7 @@ del_transfer_task_test(void)
spdk_iscsi_task_set_pdu(&task3, pdu3); spdk_iscsi_task_set_pdu(&task3, pdu3);
task3.tag = 13; task3.tag = 13;
rc = spdk_add_transfer_task(&conn, &task3); rc = add_transfer_task(&conn, &task3);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
pdu4 = spdk_get_pdu(); pdu4 = spdk_get_pdu();
@ -736,7 +736,7 @@ del_transfer_task_test(void)
spdk_iscsi_task_set_pdu(&task4, pdu4); spdk_iscsi_task_set_pdu(&task4, pdu4);
task4.tag = 14; task4.tag = 14;
rc = spdk_add_transfer_task(&conn, &task4); rc = add_transfer_task(&conn, &task4);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
pdu5 = spdk_get_pdu(); pdu5 = spdk_get_pdu();
@ -747,30 +747,30 @@ del_transfer_task_test(void)
spdk_iscsi_task_set_pdu(&task5, pdu5); spdk_iscsi_task_set_pdu(&task5, pdu5);
task5.tag = 15; task5.tag = 15;
rc = spdk_add_transfer_task(&conn, &task5); rc = add_transfer_task(&conn, &task5);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
CU_ASSERT(spdk_get_transfer_task(&conn, 1) == &task1); CU_ASSERT(get_transfer_task(&conn, 1) == &task1);
CU_ASSERT(spdk_get_transfer_task(&conn, 5) == NULL); CU_ASSERT(get_transfer_task(&conn, 5) == NULL);
spdk_del_transfer_task(&conn, 11); spdk_del_transfer_task(&conn, 11);
CU_ASSERT(spdk_get_transfer_task(&conn, 1) == NULL); CU_ASSERT(get_transfer_task(&conn, 1) == NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 5) == &task5); CU_ASSERT(get_transfer_task(&conn, 5) == &task5);
CU_ASSERT(spdk_get_transfer_task(&conn, 2) == &task2); CU_ASSERT(get_transfer_task(&conn, 2) == &task2);
spdk_del_transfer_task(&conn, 12); spdk_del_transfer_task(&conn, 12);
CU_ASSERT(spdk_get_transfer_task(&conn, 2) == NULL); CU_ASSERT(get_transfer_task(&conn, 2) == NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 3) == &task3); CU_ASSERT(get_transfer_task(&conn, 3) == &task3);
spdk_del_transfer_task(&conn, 13); spdk_del_transfer_task(&conn, 13);
CU_ASSERT(spdk_get_transfer_task(&conn, 3) == NULL); CU_ASSERT(get_transfer_task(&conn, 3) == NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 4) == &task4); CU_ASSERT(get_transfer_task(&conn, 4) == &task4);
spdk_del_transfer_task(&conn, 14); spdk_del_transfer_task(&conn, 14);
CU_ASSERT(spdk_get_transfer_task(&conn, 4) == NULL); CU_ASSERT(get_transfer_task(&conn, 4) == NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 5) == &task5); CU_ASSERT(get_transfer_task(&conn, 5) == &task5);
spdk_del_transfer_task(&conn, 15); spdk_del_transfer_task(&conn, 15);
CU_ASSERT(spdk_get_transfer_task(&conn, 5) == NULL); CU_ASSERT(get_transfer_task(&conn, 5) == NULL);
while (!TAILQ_EMPTY(&conn.active_r2t_tasks)) { while (!TAILQ_EMPTY(&conn.active_r2t_tasks)) {
task = TAILQ_FIRST(&conn.active_r2t_tasks); task = TAILQ_FIRST(&conn.active_r2t_tasks);
@ -828,7 +828,7 @@ clear_all_transfer_tasks_test(void)
task1->scsi.lun = &lun1; task1->scsi.lun = &lun1;
spdk_iscsi_task_set_pdu(task1, pdu1); spdk_iscsi_task_set_pdu(task1, pdu1);
rc = spdk_add_transfer_task(&conn, task1); rc = add_transfer_task(&conn, task1);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
mgmt_pdu1 = spdk_get_pdu(); mgmt_pdu1 = spdk_get_pdu();
@ -849,7 +849,7 @@ clear_all_transfer_tasks_test(void)
task2->scsi.lun = &lun1; task2->scsi.lun = &lun1;
spdk_iscsi_task_set_pdu(task2, pdu2); spdk_iscsi_task_set_pdu(task2, pdu2);
rc = spdk_add_transfer_task(&conn, task2); rc = add_transfer_task(&conn, task2);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
task3 = spdk_iscsi_task_get(&conn, NULL, NULL); task3 = spdk_iscsi_task_get(&conn, NULL, NULL);
@ -864,7 +864,7 @@ clear_all_transfer_tasks_test(void)
task3->scsi.lun = &lun1; task3->scsi.lun = &lun1;
spdk_iscsi_task_set_pdu(task3, pdu3); spdk_iscsi_task_set_pdu(task3, pdu3);
rc = spdk_add_transfer_task(&conn, task3); rc = add_transfer_task(&conn, task3);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
task4 = spdk_iscsi_task_get(&conn, NULL, NULL); task4 = spdk_iscsi_task_get(&conn, NULL, NULL);
@ -879,7 +879,7 @@ clear_all_transfer_tasks_test(void)
task4->scsi.lun = &lun2; task4->scsi.lun = &lun2;
spdk_iscsi_task_set_pdu(task4, pdu4); spdk_iscsi_task_set_pdu(task4, pdu4);
rc = spdk_add_transfer_task(&conn, task4); rc = add_transfer_task(&conn, task4);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
task5 = spdk_iscsi_task_get(&conn, NULL, NULL); task5 = spdk_iscsi_task_get(&conn, NULL, NULL);
@ -894,7 +894,7 @@ clear_all_transfer_tasks_test(void)
task5->scsi.lun = &lun2; task5->scsi.lun = &lun2;
spdk_iscsi_task_set_pdu(task5, pdu5); spdk_iscsi_task_set_pdu(task5, pdu5);
rc = spdk_add_transfer_task(&conn, task5); rc = add_transfer_task(&conn, task5);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
mgmt_pdu2 = spdk_get_pdu(); mgmt_pdu2 = spdk_get_pdu();
@ -915,46 +915,46 @@ clear_all_transfer_tasks_test(void)
task6->scsi.lun = &lun2; task6->scsi.lun = &lun2;
spdk_iscsi_task_set_pdu(task6, pdu6); spdk_iscsi_task_set_pdu(task6, pdu6);
rc = spdk_add_transfer_task(&conn, task6); rc = add_transfer_task(&conn, task6);
CU_ASSERT(rc == SPDK_SUCCESS); CU_ASSERT(rc == SPDK_SUCCESS);
CU_ASSERT(conn.ttt == 4); CU_ASSERT(conn.ttt == 4);
CU_ASSERT(spdk_get_transfer_task(&conn, 1) == task1); CU_ASSERT(get_transfer_task(&conn, 1) == task1);
CU_ASSERT(spdk_get_transfer_task(&conn, 2) == task2); CU_ASSERT(get_transfer_task(&conn, 2) == task2);
CU_ASSERT(spdk_get_transfer_task(&conn, 3) == task3); CU_ASSERT(get_transfer_task(&conn, 3) == task3);
CU_ASSERT(spdk_get_transfer_task(&conn, 4) == task4); CU_ASSERT(get_transfer_task(&conn, 4) == task4);
CU_ASSERT(spdk_get_transfer_task(&conn, 5) == NULL); CU_ASSERT(get_transfer_task(&conn, 5) == NULL);
spdk_clear_all_transfer_task(&conn, &lun1, mgmt_pdu1); spdk_clear_all_transfer_task(&conn, &lun1, mgmt_pdu1);
CU_ASSERT(!TAILQ_EMPTY(&conn.queued_r2t_tasks)); CU_ASSERT(!TAILQ_EMPTY(&conn.queued_r2t_tasks));
CU_ASSERT(spdk_get_transfer_task(&conn, 1) == NULL); CU_ASSERT(get_transfer_task(&conn, 1) == NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 2) == task2); CU_ASSERT(get_transfer_task(&conn, 2) == task2);
CU_ASSERT(spdk_get_transfer_task(&conn, 3) == task3); CU_ASSERT(get_transfer_task(&conn, 3) == task3);
CU_ASSERT(spdk_get_transfer_task(&conn, 4) == task4); CU_ASSERT(get_transfer_task(&conn, 4) == task4);
CU_ASSERT(spdk_get_transfer_task(&conn, 5) == task5); CU_ASSERT(get_transfer_task(&conn, 5) == task5);
CU_ASSERT(spdk_get_transfer_task(&conn, 6) == NULL); CU_ASSERT(get_transfer_task(&conn, 6) == NULL);
spdk_clear_all_transfer_task(&conn, &lun1, NULL); spdk_clear_all_transfer_task(&conn, &lun1, NULL);
CU_ASSERT(TAILQ_EMPTY(&conn.queued_r2t_tasks)); CU_ASSERT(TAILQ_EMPTY(&conn.queued_r2t_tasks));
CU_ASSERT(spdk_get_transfer_task(&conn, 1) == NULL); CU_ASSERT(get_transfer_task(&conn, 1) == NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 2) == NULL); CU_ASSERT(get_transfer_task(&conn, 2) == NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 3) == NULL); CU_ASSERT(get_transfer_task(&conn, 3) == NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 4) == task4); CU_ASSERT(get_transfer_task(&conn, 4) == task4);
CU_ASSERT(spdk_get_transfer_task(&conn, 5) == task5); CU_ASSERT(get_transfer_task(&conn, 5) == task5);
CU_ASSERT(spdk_get_transfer_task(&conn, 6) == task6); CU_ASSERT(get_transfer_task(&conn, 6) == task6);
spdk_clear_all_transfer_task(&conn, &lun2, mgmt_pdu2); spdk_clear_all_transfer_task(&conn, &lun2, mgmt_pdu2);
CU_ASSERT(spdk_get_transfer_task(&conn, 4) == NULL); CU_ASSERT(get_transfer_task(&conn, 4) == NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 5) == NULL); CU_ASSERT(get_transfer_task(&conn, 5) == NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 6) == task6); CU_ASSERT(get_transfer_task(&conn, 6) == task6);
spdk_clear_all_transfer_task(&conn, NULL, NULL); spdk_clear_all_transfer_task(&conn, NULL, NULL);
CU_ASSERT(spdk_get_transfer_task(&conn, 6) == NULL); CU_ASSERT(get_transfer_task(&conn, 6) == NULL);
CU_ASSERT(TAILQ_EMPTY(&conn.active_r2t_tasks)); CU_ASSERT(TAILQ_EMPTY(&conn.active_r2t_tasks));
while (!TAILQ_EMPTY(&g_write_pdu_list)) { while (!TAILQ_EMPTY(&g_write_pdu_list)) {
@ -989,14 +989,14 @@ abort_queued_datain_task_test(void)
/* Slot of data in tasks are full */ /* Slot of data in tasks are full */
conn.data_in_cnt = MAX_LARGE_DATAIN_PER_CONNECTION; conn.data_in_cnt = MAX_LARGE_DATAIN_PER_CONNECTION;
rc = _spdk_iscsi_conn_abort_queued_datain_task(&conn, task); rc = _iscsi_conn_abort_queued_datain_task(&conn, task);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
/* Only one slot remains and no subtasks are submitted yet. */ /* Only one slot remains and no subtasks are submitted yet. */
conn.data_in_cnt--; conn.data_in_cnt--;
task->current_datain_offset = 0; task->current_datain_offset = 0;
rc = _spdk_iscsi_conn_abort_queued_datain_task(&conn, task); rc = _iscsi_conn_abort_queued_datain_task(&conn, task);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks)); CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks));
@ -1008,7 +1008,7 @@ abort_queued_datain_task_test(void)
task->scsi.transfer_len = SPDK_BDEV_LARGE_BUF_MAX_SIZE * 3; task->scsi.transfer_len = SPDK_BDEV_LARGE_BUF_MAX_SIZE * 3;
task->current_datain_offset = SPDK_BDEV_LARGE_BUF_MAX_SIZE; task->current_datain_offset = SPDK_BDEV_LARGE_BUF_MAX_SIZE;
rc = _spdk_iscsi_conn_abort_queued_datain_task(&conn, task); rc = _iscsi_conn_abort_queued_datain_task(&conn, task);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
CU_ASSERT(task->current_datain_offset == SPDK_BDEV_LARGE_BUF_MAX_SIZE * 2); CU_ASSERT(task->current_datain_offset == SPDK_BDEV_LARGE_BUF_MAX_SIZE * 2);
CU_ASSERT(conn.data_in_cnt == MAX_LARGE_DATAIN_PER_CONNECTION); CU_ASSERT(conn.data_in_cnt == MAX_LARGE_DATAIN_PER_CONNECTION);
@ -1016,7 +1016,7 @@ abort_queued_datain_task_test(void)
/* Additional one slot becomes vacant. */ /* Additional one slot becomes vacant. */
conn.data_in_cnt--; conn.data_in_cnt--;
rc = _spdk_iscsi_conn_abort_queued_datain_task(&conn, task); rc = _iscsi_conn_abort_queued_datain_task(&conn, task);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks)); CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks));
@ -1043,13 +1043,13 @@ abort_queued_datain_task_test(void)
conn.data_in_cnt--; conn.data_in_cnt--;
rc = spdk_iscsi_conn_abort_queued_datain_task(&conn, 1); rc = iscsi_conn_abort_queued_datain_task(&conn, 1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_conn_abort_queued_datain_task(&conn, 2); rc = iscsi_conn_abort_queued_datain_task(&conn, 2);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_conn_abort_queued_datain_task(&conn, 3); rc = iscsi_conn_abort_queued_datain_task(&conn, 3);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks)); CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks));
@ -1170,7 +1170,7 @@ abort_queued_datain_tasks_test(void)
spdk_iscsi_task_set_pdu(task6, pdu6); spdk_iscsi_task_set_pdu(task6, pdu6);
TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task6, link); TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task6, link);
rc = spdk_iscsi_conn_abort_queued_datain_tasks(&conn, &lun1, mgmt_pdu1); rc = iscsi_conn_abort_queued_datain_tasks(&conn, &lun1, mgmt_pdu1);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
CU_ASSERT(!datain_task_is_queued(&conn, task1)); CU_ASSERT(!datain_task_is_queued(&conn, task1));
CU_ASSERT(datain_task_is_queued(&conn, task2)); CU_ASSERT(datain_task_is_queued(&conn, task2));
@ -1179,7 +1179,7 @@ abort_queued_datain_tasks_test(void)
CU_ASSERT(datain_task_is_queued(&conn, task5)); CU_ASSERT(datain_task_is_queued(&conn, task5));
CU_ASSERT(datain_task_is_queued(&conn, task6)); CU_ASSERT(datain_task_is_queued(&conn, task6));
rc = spdk_iscsi_conn_abort_queued_datain_tasks(&conn, &lun2, mgmt_pdu2); rc = iscsi_conn_abort_queued_datain_tasks(&conn, &lun2, mgmt_pdu2);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
CU_ASSERT(!datain_task_is_queued(&conn, task2)); CU_ASSERT(!datain_task_is_queued(&conn, task2));
CU_ASSERT(datain_task_is_queued(&conn, task3)); CU_ASSERT(datain_task_is_queued(&conn, task3));

2
test/unit/lib/iscsi/param.c/param_ut.c
View File

@ -170,7 +170,7 @@ list_negotiation_test(void)
do { \ do { \
snprintf(valid_list_buf, sizeof(valid_list_buf), "%s", valid_list); \ snprintf(valid_list_buf, sizeof(valid_list_buf), "%s", valid_list); \
snprintf(in_val_buf, sizeof(in_val_buf), "%s", in_val); \ snprintf(in_val_buf, sizeof(in_val_buf), "%s", in_val); \
new_val = spdk_iscsi_negotiate_param_list(&add_param_value, &param, valid_list_buf, in_val_buf, NULL); \ new_val = iscsi_negotiate_param_list(&add_param_value, &param, valid_list_buf, in_val_buf, NULL); \
if (expected_result) { \ if (expected_result) { \
SPDK_CU_ASSERT_FATAL(new_val != NULL); \ SPDK_CU_ASSERT_FATAL(new_val != NULL); \
CU_ASSERT_STRING_EQUAL(new_val, expected_result); \ CU_ASSERT_STRING_EQUAL(new_val, expected_result); \

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

@ -178,7 +178,7 @@ parse_portal_ipv4_normal_case(void)
spdk_cpuset_set_cpu(cpumask_val, 0, true); spdk_cpuset_set_cpu(cpumask_val, 0, true);
rc = spdk_iscsi_parse_portal(string, &p, 0); rc = iscsi_parse_portal(string, &p, 0);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
SPDK_CU_ASSERT_FATAL(p != NULL); SPDK_CU_ASSERT_FATAL(p != NULL);
CU_ASSERT(strcmp(p->host, host_str) == 0); CU_ASSERT(strcmp(p->host, host_str) == 0);
@ -206,7 +206,7 @@ parse_portal_ipv6_normal_case(void)
spdk_cpuset_set_cpu(cpumask_val, 0, true); spdk_cpuset_set_cpu(cpumask_val, 0, true);
rc = spdk_iscsi_parse_portal(string, &p, 0); rc = iscsi_parse_portal(string, &p, 0);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
SPDK_CU_ASSERT_FATAL(p != NULL); SPDK_CU_ASSERT_FATAL(p != NULL);
CU_ASSERT(strcmp(p->host, host_str) == 0); CU_ASSERT(strcmp(p->host, host_str) == 0);
@ -231,7 +231,7 @@ parse_portal_ipv4_skip_cpumask_case(void)
cpumask_val = spdk_app_get_core_mask(); cpumask_val = spdk_app_get_core_mask();
rc = spdk_iscsi_parse_portal(string, &p, 0); rc = iscsi_parse_portal(string, &p, 0);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
SPDK_CU_ASSERT_FATAL(p != NULL); SPDK_CU_ASSERT_FATAL(p != NULL);
CU_ASSERT(strcmp(p->host, host_str) == 0); CU_ASSERT(strcmp(p->host, host_str) == 0);
@ -254,7 +254,7 @@ parse_portal_ipv6_skip_cpumask_case(void)
cpumask_val = spdk_app_get_core_mask(); cpumask_val = spdk_app_get_core_mask();
rc = spdk_iscsi_parse_portal(string, &p, 0); rc = iscsi_parse_portal(string, &p, 0);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
SPDK_CU_ASSERT_FATAL(p != NULL); SPDK_CU_ASSERT_FATAL(p != NULL);
CU_ASSERT(strcmp(p->host, host_str) == 0); CU_ASSERT(strcmp(p->host, host_str) == 0);
@ -277,7 +277,7 @@ parse_portal_ipv4_skip_port_and_cpumask_case(void)
cpumask_val = spdk_app_get_core_mask(); cpumask_val = spdk_app_get_core_mask();
rc = spdk_iscsi_parse_portal(string, &p, 0); rc = iscsi_parse_portal(string, &p, 0);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
SPDK_CU_ASSERT_FATAL(p != NULL); SPDK_CU_ASSERT_FATAL(p != NULL);
CU_ASSERT(strcmp(p->host, host_str) == 0); CU_ASSERT(strcmp(p->host, host_str) == 0);
@ -300,7 +300,7 @@ parse_portal_ipv6_skip_port_and_cpumask_case(void)
cpumask_val = spdk_app_get_core_mask(); cpumask_val = spdk_app_get_core_mask();
rc = spdk_iscsi_parse_portal(string, &p, 0); rc = iscsi_parse_portal(string, &p, 0);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
SPDK_CU_ASSERT_FATAL(p != NULL); SPDK_CU_ASSERT_FATAL(p != NULL);
CU_ASSERT(strcmp(p->host, host_str) == 0); CU_ASSERT(strcmp(p->host, host_str) == 0);

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

@ -170,7 +170,7 @@ config_file_fail_cases(void)
if (sp == NULL) { if (sp == NULL) {
break; break;
} }
rc = spdk_iscsi_parse_tgt_node(sp); rc = iscsi_parse_tgt_node(sp);
CU_ASSERT(rc < 0); CU_ASSERT(rc < 0);
section_index++; section_index++;
} }
@ -189,10 +189,10 @@ allow_any_allowed(void)
addr1 = "2001:ad6:1234:5678:9abc::"; addr1 = "2001:ad6:1234:5678:9abc::";
addr2 = "192.168.2.1"; addr2 = "192.168.2.1";
result = spdk_iscsi_netmask_allow_addr(netmask, addr1); result = iscsi_netmask_allow_addr(netmask, addr1);
CU_ASSERT(result == true); CU_ASSERT(result == true);
result = spdk_iscsi_netmask_allow_addr(netmask, addr2); result = iscsi_netmask_allow_addr(netmask, addr2);
CU_ASSERT(result == true); CU_ASSERT(result == true);
} }
@ -206,16 +206,16 @@ allow_ipv6_allowed(void)
netmask = "[2001:ad6:1234::]/48"; netmask = "[2001:ad6:1234::]/48";
addr = "2001:ad6:1234:5678:9abc::"; addr = "2001:ad6:1234:5678:9abc::";
result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); result = iscsi_ipv6_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == true); CU_ASSERT(result == true);
result = spdk_iscsi_netmask_allow_addr(netmask, addr); result = iscsi_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == true); CU_ASSERT(result == true);
/* Netmask prefix bits == 128 (all bits must match) */ /* Netmask prefix bits == 128 (all bits must match) */
netmask = "[2001:ad6:1234:5678:9abc::1]/128"; netmask = "[2001:ad6:1234:5678:9abc::1]/128";
addr = "2001:ad6:1234:5678:9abc::1"; addr = "2001:ad6:1234:5678:9abc::1";
result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); result = iscsi_ipv6_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == true); CU_ASSERT(result == true);
} }
@ -229,16 +229,16 @@ allow_ipv6_denied(void)
netmask = "[2001:ad6:1234::]/56"; netmask = "[2001:ad6:1234::]/56";
addr = "2001:ad6:1234:5678:9abc::"; addr = "2001:ad6:1234:5678:9abc::";
result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); result = iscsi_ipv6_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
result = spdk_iscsi_netmask_allow_addr(netmask, addr); result = iscsi_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
/* Netmask prefix bits == 128 (all bits must match) */ /* Netmask prefix bits == 128 (all bits must match) */
netmask = "[2001:ad6:1234:5678:9abc::1]/128"; netmask = "[2001:ad6:1234:5678:9abc::1]/128";
addr = "2001:ad6:1234:5678:9abc::2"; addr = "2001:ad6:1234:5678:9abc::2";
result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); result = iscsi_ipv6_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
} }
@ -252,19 +252,19 @@ allow_ipv6_invalid(void)
/* Netmask prefix bits > 128 */ /* Netmask prefix bits > 128 */
netmask = "[2001:ad6:1234::]/129"; netmask = "[2001:ad6:1234::]/129";
addr = "2001:ad6:1234:5678:9abc::"; addr = "2001:ad6:1234:5678:9abc::";
result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); result = iscsi_ipv6_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
/* Netmask prefix bits == 0 */ /* Netmask prefix bits == 0 */
netmask = "[2001:ad6:1234::]/0"; netmask = "[2001:ad6:1234::]/0";
addr = "2001:ad6:1234:5678:9abc::"; addr = "2001:ad6:1234:5678:9abc::";
result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); result = iscsi_ipv6_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
/* Netmask prefix bits < 0 */ /* Netmask prefix bits < 0 */
netmask = "[2001:ad6:1234::]/-1"; netmask = "[2001:ad6:1234::]/-1";
addr = "2001:ad6:1234:5678:9abc::"; addr = "2001:ad6:1234:5678:9abc::";
result = spdk_iscsi_ipv6_netmask_allow_addr(netmask, addr); result = iscsi_ipv6_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
} }
@ -278,16 +278,16 @@ allow_ipv4_allowed(void)
netmask = "192.168.2.0/24"; netmask = "192.168.2.0/24";
addr = "192.168.2.1"; addr = "192.168.2.1";
result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); result = iscsi_ipv4_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == true); CU_ASSERT(result == true);
result = spdk_iscsi_netmask_allow_addr(netmask, addr); result = iscsi_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == true); CU_ASSERT(result == true);
/* Netmask prefix == 32 (all bits must match) */ /* Netmask prefix == 32 (all bits must match) */
netmask = "192.168.2.1/32"; netmask = "192.168.2.1/32";
addr = "192.168.2.1"; addr = "192.168.2.1";
result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); result = iscsi_ipv4_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == true); CU_ASSERT(result == true);
} }
@ -301,16 +301,16 @@ allow_ipv4_denied(void)
netmask = "192.168.2.0"; netmask = "192.168.2.0";
addr = "192.168.2.1"; addr = "192.168.2.1";
result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); result = iscsi_ipv4_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
result = spdk_iscsi_netmask_allow_addr(netmask, addr); result = iscsi_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
/* Netmask prefix == 32 (all bits must match) */ /* Netmask prefix == 32 (all bits must match) */
netmask = "192.168.2.1/32"; netmask = "192.168.2.1/32";
addr = "192.168.2.2"; addr = "192.168.2.2";
result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); result = iscsi_ipv4_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
} }
@ -324,19 +324,19 @@ allow_ipv4_invalid(void)
/* Netmask prefix bits > 32 */ /* Netmask prefix bits > 32 */
netmask = "192.168.2.0/33"; netmask = "192.168.2.0/33";
addr = "192.168.2.1"; addr = "192.168.2.1";
result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); result = iscsi_ipv4_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
/* Netmask prefix bits == 0 */ /* Netmask prefix bits == 0 */
netmask = "192.168.2.0/0"; netmask = "192.168.2.0/0";
addr = "192.168.2.1"; addr = "192.168.2.1";
result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); result = iscsi_ipv4_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
/* Netmask prefix bits < 0 */ /* Netmask prefix bits < 0 */
netmask = "192.168.2.0/-1"; netmask = "192.168.2.0/-1";
addr = "192.168.2.1"; addr = "192.168.2.1";
result = spdk_iscsi_ipv4_netmask_allow_addr(netmask, addr); result = iscsi_ipv4_netmask_allow_addr(netmask, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
} }
@ -382,8 +382,8 @@ node_access_allowed(void)
snprintf(scsi_dev.name, sizeof(scsi_dev.name), "iqn.2017-10.spdk.io:0001"); snprintf(scsi_dev.name, sizeof(scsi_dev.name), "iqn.2017-10.spdk.io:0001");
tgtnode.dev = &scsi_dev; tgtnode.dev = &scsi_dev;
pg_map = spdk_iscsi_tgt_node_add_pg_map(&tgtnode, &pg); pg_map = iscsi_tgt_node_add_pg_map(&tgtnode, &pg);
spdk_iscsi_pg_map_add_ig_map(pg_map, &ig); iscsi_pg_map_add_ig_map(pg_map, &ig);
/* portal initialization */ /* portal initialization */
memset(&portal, 0, sizeof(struct spdk_iscsi_portal)); memset(&portal, 0, sizeof(struct spdk_iscsi_portal));
@ -401,8 +401,8 @@ node_access_allowed(void)
result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr);
CU_ASSERT(result == true); CU_ASSERT(result == true);
spdk_iscsi_pg_map_delete_ig_map(pg_map, &ig); iscsi_pg_map_delete_ig_map(pg_map, &ig);
spdk_iscsi_tgt_node_delete_pg_map(&tgtnode, &pg); iscsi_tgt_node_delete_pg_map(&tgtnode, &pg);
} }
static void static void
@ -444,8 +444,8 @@ node_access_denied_by_empty_netmask(void)
snprintf(scsi_dev.name, sizeof(scsi_dev.name), "iqn.2017-10.spdk.io:0001"); snprintf(scsi_dev.name, sizeof(scsi_dev.name), "iqn.2017-10.spdk.io:0001");
tgtnode.dev = &scsi_dev; tgtnode.dev = &scsi_dev;
pg_map = spdk_iscsi_tgt_node_add_pg_map(&tgtnode, &pg); pg_map = iscsi_tgt_node_add_pg_map(&tgtnode, &pg);
spdk_iscsi_pg_map_add_ig_map(pg_map, &ig); iscsi_pg_map_add_ig_map(pg_map, &ig);
/* portal initialization */ /* portal initialization */
memset(&portal, 0, sizeof(struct spdk_iscsi_portal)); memset(&portal, 0, sizeof(struct spdk_iscsi_portal));
@ -463,8 +463,8 @@ node_access_denied_by_empty_netmask(void)
result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
spdk_iscsi_pg_map_delete_ig_map(pg_map, &ig); iscsi_pg_map_delete_ig_map(pg_map, &ig);
spdk_iscsi_tgt_node_delete_pg_map(&tgtnode, &pg); iscsi_tgt_node_delete_pg_map(&tgtnode, &pg);
} }
#define IQN1 "iqn.2017-11.spdk.io:0001" #define IQN1 "iqn.2017-11.spdk.io:0001"
@ -528,9 +528,9 @@ node_access_multi_initiator_groups_cases(void)
memset(&pg, 0, sizeof(struct spdk_iscsi_portal_grp)); memset(&pg, 0, sizeof(struct spdk_iscsi_portal_grp));
pg.tag = 1; pg.tag = 1;
pg_map = spdk_iscsi_tgt_node_add_pg_map(&tgtnode, &pg); pg_map = iscsi_tgt_node_add_pg_map(&tgtnode, &pg);
spdk_iscsi_pg_map_add_ig_map(pg_map, &ig1); iscsi_pg_map_add_ig_map(pg_map, &ig1);
spdk_iscsi_pg_map_add_ig_map(pg_map, &ig2); iscsi_pg_map_add_ig_map(pg_map, &ig2);
/* portal initialization */ /* portal initialization */
memset(&portal, 0, sizeof(struct spdk_iscsi_portal)); memset(&portal, 0, sizeof(struct spdk_iscsi_portal));
@ -722,9 +722,9 @@ node_access_multi_initiator_groups_cases(void)
result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr); result = spdk_iscsi_tgt_node_access(&conn, &tgtnode, iqn, addr);
CU_ASSERT(result == false); CU_ASSERT(result == false);
spdk_iscsi_pg_map_delete_ig_map(pg_map, &ig1); iscsi_pg_map_delete_ig_map(pg_map, &ig1);
spdk_iscsi_pg_map_delete_ig_map(pg_map, &ig2); iscsi_pg_map_delete_ig_map(pg_map, &ig2);
spdk_iscsi_tgt_node_delete_pg_map(&tgtnode, &pg); iscsi_tgt_node_delete_pg_map(&tgtnode, &pg);
} }
static void static void
@ -761,28 +761,28 @@ allow_iscsi_name_multi_maps_case(void)
memset(&pg2, 0, sizeof(struct spdk_iscsi_portal_grp)); memset(&pg2, 0, sizeof(struct spdk_iscsi_portal_grp));
pg2.tag = 1; pg2.tag = 1;
pg_map1 = spdk_iscsi_tgt_node_add_pg_map(&tgtnode, &pg1); pg_map1 = iscsi_tgt_node_add_pg_map(&tgtnode, &pg1);
pg_map2 = spdk_iscsi_tgt_node_add_pg_map(&tgtnode, &pg2); pg_map2 = iscsi_tgt_node_add_pg_map(&tgtnode, &pg2);
spdk_iscsi_pg_map_add_ig_map(pg_map1, &ig); iscsi_pg_map_add_ig_map(pg_map1, &ig);
spdk_iscsi_pg_map_add_ig_map(pg_map2, &ig); iscsi_pg_map_add_ig_map(pg_map2, &ig);
/* test for IG1 <-> PG1, PG2 case */ /* test for IG1 <-> PG1, PG2 case */
iqn = IQN1; iqn = IQN1;
iname.name = IQN1; iname.name = IQN1;
result = spdk_iscsi_tgt_node_allow_iscsi_name(&tgtnode, iqn); result = iscsi_tgt_node_allow_iscsi_name(&tgtnode, iqn);
CU_ASSERT(result == true); CU_ASSERT(result == true);
iname.name = IQN2; iname.name = IQN2;
result = spdk_iscsi_tgt_node_allow_iscsi_name(&tgtnode, iqn); result = iscsi_tgt_node_allow_iscsi_name(&tgtnode, iqn);
CU_ASSERT(result == false); CU_ASSERT(result == false);
spdk_iscsi_pg_map_delete_ig_map(pg_map1, &ig); iscsi_pg_map_delete_ig_map(pg_map1, &ig);
spdk_iscsi_pg_map_delete_ig_map(pg_map2, &ig); iscsi_pg_map_delete_ig_map(pg_map2, &ig);
spdk_iscsi_tgt_node_delete_pg_map(&tgtnode, &pg1); iscsi_tgt_node_delete_pg_map(&tgtnode, &pg1);
spdk_iscsi_tgt_node_delete_pg_map(&tgtnode, &pg2); iscsi_tgt_node_delete_pg_map(&tgtnode, &pg2);
} }
/* /*