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

lib/iscsi: Remove the "spdk_" prefix from internal APIs declared in param.h

Browse Source 
Signed-off-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Change-Id: I8ecdc65f1c0ae88d2de45298db45a8f52e4ed2e5
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/1883
Community-CI: Mellanox Build Bot
Community-CI: Broadcom CI
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Aleksey Marchuk <alexeymar@mellanox.com>
Reviewed-by: Paul Luse <paul.e.luse@intel.com>
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: Seth Howell <seth.howell@intel.com>
This commit is contained in:
Shuhei Matsumoto 2020-04-16 04:22:06 +09:00 committed by Tomasz Zawadzki
parent be1489b9b9
commit be05a8208d
7 changed files with 190 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/iscsi/Makefile
View File

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

8
lib/iscsi/conn.c
View File

@ -282,7 +282,7 @@ spdk_iscsi_conn_construct(struct spdk_iscsi_portal *portal,
} }
/* set default params */ /* set default params */
rc = spdk_iscsi_conn_params_init(&conn->params); rc = iscsi_conn_params_init(&conn->params);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_conn_params_init() failed\n"); SPDK_ERRLOG("iscsi_conn_params_init() failed\n");
goto error_return; goto error_return;
@ -307,7 +307,7 @@ spdk_iscsi_conn_construct(struct spdk_iscsi_portal *portal,
return 0; return 0;
error_return: error_return:
spdk_iscsi_param_free(conn->params); iscsi_param_free(conn->params);
free_conn(conn); free_conn(conn);
return -1; return -1;
} }
@ -434,7 +434,7 @@ 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_param_free(conn->params); iscsi_param_free(conn->params);
free_conn(conn); free_conn(conn);
pthread_mutex_unlock(&g_conns_mutex); pthread_mutex_unlock(&g_conns_mutex);
@ -1266,7 +1266,7 @@ iscsi_conn_send_nopin(struct spdk_iscsi_conn *conn)
/* Only send nopin if we have logged in and are in a normal session. */ /* Only send nopin if we have logged in and are in a normal session. */
if (conn->sess == NULL || if (conn->sess == NULL ||
!conn->full_feature || !conn->full_feature ||
!spdk_iscsi_param_eq_val(conn->sess->params, "SessionType", "Normal")) { !iscsi_param_eq_val(conn->sess->params, "SessionType", "Normal")) {
return; return;
} }
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "send NOPIN isid=%"PRIx64", tsih=%u, cid=%u\n", SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "send NOPIN isid=%"PRIx64", tsih=%u, cid=%u\n",

164
lib/iscsi/iscsi.c
View File

@ -543,7 +543,7 @@ void spdk_free_sess(struct spdk_iscsi_sess *sess)
sess->tag = 0; sess->tag = 0;
sess->target = NULL; sess->target = NULL;
sess->session_type = SESSION_TYPE_INVALID; sess->session_type = SESSION_TYPE_INVALID;
spdk_iscsi_param_free(sess->params); iscsi_param_free(sess->params);
free(sess->conns); free(sess->conns);
spdk_scsi_port_free(&sess->initiator_port); spdk_scsi_port_free(&sess->initiator_port);
spdk_mempool_put(g_iscsi.session_pool, (void *)sess); spdk_mempool_put(g_iscsi.session_pool, (void *)sess);
@ -602,92 +602,92 @@ create_iscsi_sess(struct spdk_iscsi_conn *conn,
sess->current_text_itt = 0xffffffffU; sess->current_text_itt = 0xffffffffU;
/* set default params */ /* set default params */
rc = spdk_iscsi_sess_params_init(&sess->params); rc = iscsi_sess_params_init(&sess->params);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_sess_params_init() failed\n"); SPDK_ERRLOG("iscsi_sess_params_init() failed\n");
goto error_return; goto error_return;
} }
/* replace with config value */ /* replace with config value */
rc = spdk_iscsi_param_set_int(sess->params, "MaxConnections", rc = iscsi_param_set_int(sess->params, "MaxConnections",
sess->MaxConnections); sess->MaxConnections);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n"); SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return; goto error_return;
} }
rc = spdk_iscsi_param_set_int(sess->params, "MaxOutstandingR2T", rc = iscsi_param_set_int(sess->params, "MaxOutstandingR2T",
sess->MaxOutstandingR2T); sess->MaxOutstandingR2T);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n"); SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return; goto error_return;
} }
rc = spdk_iscsi_param_set_int(sess->params, "DefaultTime2Wait", rc = iscsi_param_set_int(sess->params, "DefaultTime2Wait",
sess->DefaultTime2Wait); sess->DefaultTime2Wait);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n"); SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return; goto error_return;
} }
rc = spdk_iscsi_param_set_int(sess->params, "DefaultTime2Retain", rc = iscsi_param_set_int(sess->params, "DefaultTime2Retain",
sess->DefaultTime2Retain); sess->DefaultTime2Retain);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n"); SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return; goto error_return;
} }
rc = spdk_iscsi_param_set_int(sess->params, "FirstBurstLength", rc = iscsi_param_set_int(sess->params, "FirstBurstLength",
sess->FirstBurstLength); sess->FirstBurstLength);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n"); SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return; goto error_return;
} }
rc = spdk_iscsi_param_set_int(sess->params, "MaxBurstLength", rc = iscsi_param_set_int(sess->params, "MaxBurstLength",
sess->MaxBurstLength); sess->MaxBurstLength);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n"); SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return; goto error_return;
} }
rc = spdk_iscsi_param_set(sess->params, "InitialR2T", rc = iscsi_param_set(sess->params, "InitialR2T",
sess->InitialR2T ? "Yes" : "No"); sess->InitialR2T ? "Yes" : "No");
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n"); SPDK_ERRLOG("iscsi_param_set() failed\n");
goto error_return; goto error_return;
} }
rc = spdk_iscsi_param_set(sess->params, "ImmediateData", rc = iscsi_param_set(sess->params, "ImmediateData",
sess->ImmediateData ? "Yes" : "No"); sess->ImmediateData ? "Yes" : "No");
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n"); SPDK_ERRLOG("iscsi_param_set() failed\n");
goto error_return; goto error_return;
} }
rc = spdk_iscsi_param_set(sess->params, "DataPDUInOrder", rc = iscsi_param_set(sess->params, "DataPDUInOrder",
sess->DataPDUInOrder ? "Yes" : "No"); sess->DataPDUInOrder ? "Yes" : "No");
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n"); SPDK_ERRLOG("iscsi_param_set() failed\n");
goto error_return; goto error_return;
} }
rc = spdk_iscsi_param_set(sess->params, "DataSequenceInOrder", rc = iscsi_param_set(sess->params, "DataSequenceInOrder",
sess->DataSequenceInOrder ? "Yes" : "No"); sess->DataSequenceInOrder ? "Yes" : "No");
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n"); SPDK_ERRLOG("iscsi_param_set() failed\n");
goto error_return; goto error_return;
} }
rc = spdk_iscsi_param_set_int(sess->params, "ErrorRecoveryLevel", rc = iscsi_param_set_int(sess->params, "ErrorRecoveryLevel",
sess->ErrorRecoveryLevel); sess->ErrorRecoveryLevel);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n"); SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return; goto error_return;
} }
/* realloc buffer */ /* realloc buffer */
rc = spdk_iscsi_param_set_int(conn->params, "MaxRecvDataSegmentLength", rc = iscsi_param_set_int(conn->params, "MaxRecvDataSegmentLength",
conn->MaxRecvDataSegmentLength); conn->MaxRecvDataSegmentLength);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n"); SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return; goto error_return;
@ -796,9 +796,9 @@ iscsi_append_param(struct spdk_iscsi_conn *conn, const char *key,
struct iscsi_param *param; struct iscsi_param *param;
int rc; int rc;
param = spdk_iscsi_param_find(conn->params, key); param = iscsi_param_find(conn->params, key);
if (param == NULL) { if (param == NULL) {
param = spdk_iscsi_param_find(conn->sess->params, key); param = iscsi_param_find(conn->sess->params, key);
if (param == NULL) { if (param == NULL) {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "no key %.64s\n", key); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "no key %.64s\n", key);
return data_len; return data_len;
@ -853,7 +853,7 @@ iscsi_auth_params(struct spdk_iscsi_conn *conn,
} }
/* CHAP method (RFC1994) */ /* CHAP method (RFC1994) */
if ((algorithm = spdk_iscsi_param_get_val(params, "CHAP_A")) != NULL) { if ((algorithm = iscsi_param_get_val(params, "CHAP_A")) != NULL) {
if (conn->auth.chap_phase != ISCSI_CHAP_PHASE_WAIT_A) { if (conn->auth.chap_phase != ISCSI_CHAP_PHASE_WAIT_A) {
SPDK_ERRLOG("CHAP sequence error\n"); SPDK_ERRLOG("CHAP sequence error\n");
goto error_return; goto error_return;
@ -897,7 +897,7 @@ iscsi_auth_params(struct spdk_iscsi_conn *conn,
data, alloc_len, total); data, alloc_len, total);
conn->auth.chap_phase = ISCSI_CHAP_PHASE_WAIT_NR; conn->auth.chap_phase = ISCSI_CHAP_PHASE_WAIT_NR;
} else if ((name = spdk_iscsi_param_get_val(params, "CHAP_N")) != NULL) { } else if ((name = iscsi_param_get_val(params, "CHAP_N")) != NULL) {
uint8_t resmd5[SPDK_MD5DIGEST_LEN]; uint8_t resmd5[SPDK_MD5DIGEST_LEN];
uint8_t tgtmd5[SPDK_MD5DIGEST_LEN]; uint8_t tgtmd5[SPDK_MD5DIGEST_LEN];
struct spdk_md5ctx md5ctx; struct spdk_md5ctx md5ctx;
@ -908,7 +908,7 @@ iscsi_auth_params(struct spdk_iscsi_conn *conn,
goto error_return; goto error_return;
} }
response = spdk_iscsi_param_get_val(params, "CHAP_R"); response = iscsi_param_get_val(params, "CHAP_R");
if (response == NULL) { if (response == NULL) {
SPDK_ERRLOG("no response\n"); SPDK_ERRLOG("no response\n");
goto error_return; goto error_return;
@ -979,10 +979,10 @@ iscsi_auth_params(struct spdk_iscsi_conn *conn,
conn->authenticated = true; conn->authenticated = true;
/* mutual CHAP? */ /* mutual CHAP? */
identifier = spdk_iscsi_param_get_val(params, "CHAP_I"); identifier = iscsi_param_get_val(params, "CHAP_I");
if (identifier != NULL) { if (identifier != NULL) {
conn->auth.chap_mid[0] = (uint8_t) strtol(identifier, NULL, 10); conn->auth.chap_mid[0] = (uint8_t) strtol(identifier, NULL, 10);
challenge = spdk_iscsi_param_get_val(params, "CHAP_C"); challenge = iscsi_param_get_val(params, "CHAP_C");
if (challenge == NULL) { if (challenge == NULL) {
SPDK_ERRLOG("CHAP sequence error\n"); SPDK_ERRLOG("CHAP sequence error\n");
goto error_return; goto error_return;
@ -1104,9 +1104,9 @@ iscsi_conn_params_update(struct spdk_iscsi_conn *conn)
uint32_t recv_buf_size; uint32_t recv_buf_size;
/* update internal variables */ /* update internal variables */
rc = spdk_iscsi_copy_param2var(conn); rc = iscsi_copy_param2var(conn);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("spdk_iscsi_copy_param2var() failed\n"); SPDK_ERRLOG("iscsi_copy_param2var() failed\n");
if (conn->state < ISCSI_CONN_STATE_EXITING) { if (conn->state < ISCSI_CONN_STATE_EXITING) {
conn->state = ISCSI_CONN_STATE_EXITING; conn->state = ISCSI_CONN_STATE_EXITING;
} }
@ -1212,7 +1212,7 @@ iscsi_op_login_response(struct spdk_iscsi_conn *conn,
rsph->flags &= ~ISCSI_LOGIN_CURRENT_STAGE_MASK; rsph->flags &= ~ISCSI_LOGIN_CURRENT_STAGE_MASK;
rsph->flags &= ~ISCSI_LOGIN_NEXT_STAGE_MASK; rsph->flags &= ~ISCSI_LOGIN_NEXT_STAGE_MASK;
} }
spdk_iscsi_param_free(params); iscsi_param_free(params);
spdk_iscsi_conn_write_pdu(conn, rsp_pdu, cb_fn, conn); spdk_iscsi_conn_write_pdu(conn, rsp_pdu, cb_fn, conn);
} }
@ -1342,9 +1342,9 @@ iscsi_op_login_store_incoming_params(struct spdk_iscsi_conn *conn,
reqh = (struct iscsi_bhs_login_req *)&pdu->bhs; reqh = (struct iscsi_bhs_login_req *)&pdu->bhs;
rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs; rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs;
rc = spdk_iscsi_parse_params(params, pdu->data, rc = iscsi_parse_params(params, pdu->data,
pdu->data_segment_len, ISCSI_BHS_LOGIN_GET_CBIT(reqh->flags), pdu->data_segment_len, ISCSI_BHS_LOGIN_GET_CBIT(reqh->flags),
&conn->partial_text_parameter); &conn->partial_text_parameter);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_parse_params() failed\n"); SPDK_ERRLOG("iscsi_parse_params() failed\n");
rsph->status_class = ISCSI_CLASS_INITIATOR_ERROR; rsph->status_class = ISCSI_CLASS_INITIATOR_ERROR;
@ -1373,7 +1373,7 @@ iscsi_op_login_initialize_port(struct spdk_iscsi_conn *conn,
rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs; rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs;
/* Initiator Name and Port */ /* Initiator Name and Port */
val = spdk_iscsi_param_get_val(params, "InitiatorName"); val = iscsi_param_get_val(params, "InitiatorName");
if (val == NULL) { if (val == NULL) {
SPDK_ERRLOG("InitiatorName is empty\n"); SPDK_ERRLOG("InitiatorName is empty\n");
/* Missing parameter */ /* Missing parameter */
@ -1408,7 +1408,7 @@ iscsi_op_login_session_type(struct spdk_iscsi_conn *conn,
struct iscsi_bhs_login_rsp *rsph; struct iscsi_bhs_login_rsp *rsph;
rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs; rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs;
session_type_str = spdk_iscsi_param_get_val(params, "SessionType"); session_type_str = iscsi_param_get_val(params, "SessionType");
if (session_type_str == NULL) { if (session_type_str == NULL) {
if (rsph->tsih != 0) { if (rsph->tsih != 0) {
*session_type = SESSION_TYPE_NORMAL; *session_type = SESSION_TYPE_NORMAL;
@ -1538,26 +1538,26 @@ iscsi_op_login_update_param(struct spdk_iscsi_conn *conn,
struct iscsi_param *new_param, *orig_param; struct iscsi_param *new_param, *orig_param;
int index; int index;
orig_param = spdk_iscsi_param_find(conn->params, key); orig_param = iscsi_param_find(conn->params, key);
if (orig_param == NULL) { if (orig_param == NULL) {
SPDK_ERRLOG("orig_param %s not found\n", key); SPDK_ERRLOG("orig_param %s not found\n", key);
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER; return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
} }
index = orig_param->state_index; index = orig_param->state_index;
rc = spdk_iscsi_param_del(&conn->params, key); rc = iscsi_param_del(&conn->params, key);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_del(%s) failed\n", key); SPDK_ERRLOG("iscsi_param_del(%s) failed\n", key);
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER; return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
} }
rc = spdk_iscsi_param_add(&conn->params, key, value, list, ISPT_LIST); rc = iscsi_param_add(&conn->params, key, value, list, ISPT_LIST);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_add() failed\n"); SPDK_ERRLOG("iscsi_param_add() failed\n");
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER; return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
} }
new_param = spdk_iscsi_param_find(conn->params, key); new_param = iscsi_param_find(conn->params, key);
if (new_param == NULL) { if (new_param == NULL) {
SPDK_ERRLOG("spdk_iscsi_param_find() failed\n"); SPDK_ERRLOG("iscsi_param_find() failed\n");
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER; return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
} }
new_param->state_index = index; new_param->state_index = index;
@ -1661,7 +1661,7 @@ iscsi_op_login_session_normal(struct spdk_iscsi_conn *conn,
int rc = 0; int rc = 0;
rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs; rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs;
target_name = spdk_iscsi_param_get_val(params, "TargetName"); target_name = iscsi_param_get_val(params, "TargetName");
if (target_name == NULL) { if (target_name == NULL) {
SPDK_ERRLOG("TargetName is empty\n"); SPDK_ERRLOG("TargetName is empty\n");
@ -1821,7 +1821,7 @@ iscsi_op_login_set_target_info(struct spdk_iscsi_conn *conn,
snprintf(buf, sizeof buf, "%s", ""); snprintf(buf, sizeof buf, "%s", "");
} }
pthread_mutex_unlock(&target->mutex); pthread_mutex_unlock(&target->mutex);
rc = spdk_iscsi_param_set(conn->sess->params, "TargetAlias", buf); rc = iscsi_param_set(conn->sess->params, "TargetAlias", buf);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n"); SPDK_ERRLOG("iscsi_param_set() failed\n");
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER; return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
@ -1829,13 +1829,13 @@ iscsi_op_login_set_target_info(struct spdk_iscsi_conn *conn,
} }
snprintf(buf, sizeof buf, "%s:%s,%d", conn->portal_host, conn->portal_port, snprintf(buf, sizeof buf, "%s:%s,%d", conn->portal_host, conn->portal_port,
conn->pg_tag); conn->pg_tag);
rc = spdk_iscsi_param_set(conn->sess->params, "TargetAddress", buf); rc = iscsi_param_set(conn->sess->params, "TargetAddress", buf);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n"); SPDK_ERRLOG("iscsi_param_set() failed\n");
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER; return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
} }
snprintf(buf, sizeof buf, "%d", conn->pg_tag); snprintf(buf, sizeof buf, "%d", conn->pg_tag);
rc = spdk_iscsi_param_set(conn->sess->params, "TargetPortalGroupTag", buf); rc = iscsi_param_set(conn->sess->params, "TargetPortalGroupTag", buf);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n"); SPDK_ERRLOG("iscsi_param_set() failed\n");
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER; return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
@ -1843,7 +1843,7 @@ iscsi_op_login_set_target_info(struct spdk_iscsi_conn *conn,
/* write in response */ /* write in response */
if (target != NULL) { if (target != NULL) {
val = spdk_iscsi_param_get_val(conn->sess->params, "TargetAlias"); val = iscsi_param_get_val(conn->sess->params, "TargetAlias");
if (val != NULL && strlen(val) != 0) { if (val != NULL && strlen(val) != 0) {
rsp_pdu->data_segment_len = iscsi_append_param(conn, rsp_pdu->data_segment_len = iscsi_append_param(conn,
"TargetAlias", "TargetAlias",
@ -1937,9 +1937,9 @@ iscsi_op_login_phase_none(struct spdk_iscsi_conn *conn,
/* limit conns on discovery session */ /* limit conns on discovery session */
if (session_type == SESSION_TYPE_DISCOVERY) { if (session_type == SESSION_TYPE_DISCOVERY) {
conn->sess->MaxConnections = 1; conn->sess->MaxConnections = 1;
rc = spdk_iscsi_param_set_int(conn->sess->params, rc = iscsi_param_set_int(conn->sess->params,
"MaxConnections", "MaxConnections",
conn->sess->MaxConnections); conn->sess->MaxConnections);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n"); SPDK_ERRLOG("iscsi_param_set_int() failed\n");
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER; return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
@ -1968,7 +1968,7 @@ iscsi_op_login_rsp_handle_csg_bit(struct spdk_iscsi_conn *conn,
switch (ISCSI_BHS_LOGIN_GET_CSG(rsph->flags)) { switch (ISCSI_BHS_LOGIN_GET_CSG(rsph->flags)) {
case ISCSI_SECURITY_NEGOTIATION_PHASE: case ISCSI_SECURITY_NEGOTIATION_PHASE:
/* SecurityNegotiation */ /* SecurityNegotiation */
auth_method = spdk_iscsi_param_get_val(conn->params, "AuthMethod"); auth_method = iscsi_param_get_val(conn->params, "AuthMethod");
if (auth_method == NULL) { if (auth_method == NULL) {
SPDK_ERRLOG("AuthMethod is empty\n"); SPDK_ERRLOG("AuthMethod is empty\n");
/* Missing parameter */ /* Missing parameter */
@ -2066,9 +2066,9 @@ iscsi_op_login_notify_session_info(struct spdk_iscsi_conn *conn,
conn->target->name, conn->target->num, conn->target->name, conn->target->num,
conn->portal_host, conn->portal_port, conn->pg_tag, conn->portal_host, conn->portal_port, conn->pg_tag,
conn->sess->isid, conn->sess->tsih, conn->cid, conn->sess->isid, conn->sess->tsih, conn->cid,
(spdk_iscsi_param_eq_val(conn->params, "HeaderDigest", "CRC32C") (iscsi_param_eq_val(conn->params, "HeaderDigest", "CRC32C")
? "on" : "off"), ? "on" : "off"),
(spdk_iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C") (iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
? "on" : "off")); ? "on" : "off"));
} else if (conn->sess->session_type == SESSION_TYPE_DISCOVERY) { } else if (conn->sess->session_type == SESSION_TYPE_DISCOVERY) {
/* discovery session */ /* discovery session */
@ -2078,9 +2078,9 @@ iscsi_op_login_notify_session_info(struct spdk_iscsi_conn *conn,
conn->initiator_name, conn->initiator_addr, conn->initiator_name, conn->initiator_addr,
conn->portal_host, conn->portal_port, conn->pg_tag, conn->portal_host, conn->portal_port, conn->pg_tag,
conn->sess->isid, conn->sess->tsih, conn->cid, conn->sess->isid, conn->sess->tsih, conn->cid,
(spdk_iscsi_param_eq_val(conn->params, "HeaderDigest", "CRC32C") (iscsi_param_eq_val(conn->params, "HeaderDigest", "CRC32C")
? "on" : "off"), ? "on" : "off"),
(spdk_iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C") (iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
? "on" : "off")); ? "on" : "off"));
} else { } else {
SPDK_ERRLOG("unknown session type\n"); SPDK_ERRLOG("unknown session type\n");
@ -2158,12 +2158,12 @@ iscsi_op_login_rsp_handle(struct spdk_iscsi_conn *conn,
rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs; rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs;
/* negotiate parameters */ /* negotiate parameters */
rc = spdk_iscsi_negotiate_params(conn, params, rsp_pdu->data, rc = iscsi_negotiate_params(conn, params, rsp_pdu->data,
rsp_pdu->data_buf_len, rsp_pdu->data_buf_len,
rsp_pdu->data_segment_len); rsp_pdu->data_segment_len);
if (rc < 0) { if (rc < 0) {
/* /*
* spdk_iscsi_negotiate_params just returns -1 on failure, * iscsi_negotiate_params just returns -1 on failure,
* so translate this into meaningful response codes and * so translate this into meaningful response codes and
* return values. * return values.
*/ */
@ -2364,36 +2364,36 @@ iscsi_pdu_payload_op_text(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *p
task_tag = from_be32(&reqh->itt); task_tag = from_be32(&reqh->itt);
/* store incoming parameters */ /* store incoming parameters */
rc = spdk_iscsi_parse_params(&params, pdu->data, pdu->data_segment_len, rc = iscsi_parse_params(&params, pdu->data, pdu->data_segment_len,
C_bit, &conn->partial_text_parameter); C_bit, &conn->partial_text_parameter);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_parse_params() failed\n"); SPDK_ERRLOG("iscsi_parse_params() failed\n");
spdk_iscsi_param_free(params); iscsi_param_free(params);
return -1; return -1;
} }
data = calloc(1, alloc_len); data = calloc(1, alloc_len);
if (!data) { if (!data) {
SPDK_ERRLOG("calloc() failed for data segment\n"); SPDK_ERRLOG("calloc() failed for data segment\n");
spdk_iscsi_param_free(params); iscsi_param_free(params);
return -ENOMEM; return -ENOMEM;
} }
/* negotiate parameters */ /* negotiate parameters */
data_len = spdk_iscsi_negotiate_params(conn, &params, data_len = iscsi_negotiate_params(conn, &params,
data, alloc_len, data_len); data, alloc_len, data_len);
if (data_len < 0) { if (data_len < 0) {
SPDK_ERRLOG("spdk_iscsi_negotiate_params() failed\n"); SPDK_ERRLOG("iscsi_negotiate_params() failed\n");
spdk_iscsi_param_free(params); iscsi_param_free(params);
free(data); free(data);
return -1; return -1;
} }
/* sendtargets is special case */ /* sendtargets is special case */
val = spdk_iscsi_param_get_val(params, "SendTargets"); val = iscsi_param_get_val(params, "SendTargets");
if (val != NULL) { if (val != NULL) {
if (spdk_iscsi_param_eq_val(conn->sess->params, if (iscsi_param_eq_val(conn->sess->params,
"SessionType", "Discovery")) { "SessionType", "Discovery")) {
if (strcasecmp(val, "") == 0) { if (strcasecmp(val, "") == 0) {
val = "ALL"; val = "ALL";
} }
@ -2423,14 +2423,14 @@ iscsi_pdu_payload_op_text(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *p
} }
} }
} else { } else {
if (spdk_iscsi_param_eq_val(conn->sess->params, "SessionType", "Discovery")) { if (iscsi_param_eq_val(conn->sess->params, "SessionType", "Discovery")) {
spdk_iscsi_param_free(params); iscsi_param_free(params);
free(data); free(data);
return SPDK_ISCSI_CONNECTION_FATAL; return SPDK_ISCSI_CONNECTION_FATAL;
} }
} }
spdk_iscsi_param_free(params); iscsi_param_free(params);
SPDK_LOGDUMP(SPDK_LOG_ISCSI, "Negotiated Params", data, data_len); SPDK_LOGDUMP(SPDK_LOG_ISCSI, "Negotiated Params", data, data_len);
/* response PDU */ /* response PDU */
@ -2490,7 +2490,7 @@ static void iscsi_conn_logout_pdu_complete(void *arg)
" (%s:%s,%d)\n", " (%s:%s,%d)\n",
conn->initiator_name, conn->initiator_addr, conn->initiator_name, conn->initiator_addr,
conn->portal_host, conn->portal_port, conn->pg_tag); conn->portal_host, conn->portal_port, conn->pg_tag);
} else if (spdk_iscsi_param_eq_val(conn->sess->params, "SessionType", "Normal")) { } else if (iscsi_param_eq_val(conn->sess->params, "SessionType", "Normal")) {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Logout from %s (%s) on %s tgt_node%d" SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "Logout from %s (%s) on %s tgt_node%d"
" (%s:%s,%d), ISID=%"PRIx64", TSIH=%u," " (%s:%s,%d), ISID=%"PRIx64", TSIH=%u,"
" CID=%u, HeaderDigest=%s, DataDigest=%s\n", " CID=%u, HeaderDigest=%s, DataDigest=%s\n",
@ -2498,9 +2498,9 @@ static void iscsi_conn_logout_pdu_complete(void *arg)
conn->target->name, conn->target->num, conn->target->name, conn->target->num,
conn->portal_host, conn->portal_port, conn->pg_tag, conn->portal_host, conn->portal_port, conn->pg_tag,
conn->sess->isid, conn->sess->tsih, conn->cid, conn->sess->isid, conn->sess->tsih, conn->cid,
(spdk_iscsi_param_eq_val(conn->params, "HeaderDigest", "CRC32C") (iscsi_param_eq_val(conn->params, "HeaderDigest", "CRC32C")
? "on" : "off"), ? "on" : "off"),
(spdk_iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C") (iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
? "on" : "off")); ? "on" : "off"));
} else { } else {
/* discovery session */ /* discovery session */
@ -2510,9 +2510,9 @@ static void iscsi_conn_logout_pdu_complete(void *arg)
conn->initiator_name, conn->initiator_addr, conn->initiator_name, conn->initiator_addr,
conn->portal_host, conn->portal_port, conn->pg_tag, conn->portal_host, conn->portal_port, conn->pg_tag,
conn->sess->isid, conn->sess->tsih, conn->cid, conn->sess->isid, conn->sess->tsih, conn->cid,
(spdk_iscsi_param_eq_val(conn->params, "HeaderDigest", "CRC32C") (iscsi_param_eq_val(conn->params, "HeaderDigest", "CRC32C")
? "on" : "off"), ? "on" : "off"),
(spdk_iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C") (iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
? "on" : "off")); ? "on" : "off"));
} }
} }

112
lib/iscsi/param.c
View File

@ -52,7 +52,7 @@ static const char *non_simple_value_params[] = {
}; };
void void
spdk_iscsi_param_free(struct iscsi_param *params) iscsi_param_free(struct iscsi_param *params)
{ {
struct iscsi_param *param, *next_param; struct iscsi_param *param, *next_param;
@ -84,7 +84,7 @@ iscsi_find_key_in_array(const char *key, const char *array[])
} }
struct iscsi_param * struct iscsi_param *
spdk_iscsi_param_find(struct iscsi_param *params, const char *key) iscsi_param_find(struct iscsi_param *params, const char *key)
{ {
struct iscsi_param *param; struct iscsi_param *param;
@ -101,7 +101,7 @@ spdk_iscsi_param_find(struct iscsi_param *params, const char *key)
} }
int int
spdk_iscsi_param_del(struct iscsi_param **params, const char *key) iscsi_param_del(struct iscsi_param **params, const char *key)
{ {
struct iscsi_param *param, *prev_param = NULL; struct iscsi_param *param, *prev_param = NULL;
@ -118,7 +118,7 @@ spdk_iscsi_param_del(struct iscsi_param **params, const char *key)
*params = param->next; *params = param->next;
} }
param->next = NULL; param->next = NULL;
spdk_iscsi_param_free(param); iscsi_param_free(param);
return 0; return 0;
} }
prev_param = param; prev_param = param;
@ -127,8 +127,8 @@ spdk_iscsi_param_del(struct iscsi_param **params, const char *key)
} }
int int
spdk_iscsi_param_add(struct iscsi_param **params, const char *key, iscsi_param_add(struct iscsi_param **params, const char *key,
const char *val, const char *list, int type) const char *val, const char *list, int type)
{ {
struct iscsi_param *param, *last_param; struct iscsi_param *param, *last_param;
@ -138,9 +138,9 @@ spdk_iscsi_param_add(struct iscsi_param **params, const char *key,
return -1; return -1;
} }
param = spdk_iscsi_param_find(*params, key); param = iscsi_param_find(*params, key);
if (param != NULL) { if (param != NULL) {
spdk_iscsi_param_del(params, key); iscsi_param_del(params, key);
} }
param = calloc(1, sizeof(*param)); param = calloc(1, sizeof(*param));
@ -169,13 +169,13 @@ spdk_iscsi_param_add(struct iscsi_param **params, const char *key,
} }
int int
spdk_iscsi_param_set(struct iscsi_param *params, const char *key, iscsi_param_set(struct iscsi_param *params, const char *key,
const char *val) const char *val)
{ {
struct iscsi_param *param; struct iscsi_param *param;
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set %s=%s\n", key, val); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set %s=%s\n", key, val);
param = spdk_iscsi_param_find(params, key); param = iscsi_param_find(params, key);
if (param == NULL) { if (param == NULL) {
SPDK_ERRLOG("no key %s\n", key); SPDK_ERRLOG("no key %s\n", key);
return -1; return -1;
@ -189,13 +189,13 @@ spdk_iscsi_param_set(struct iscsi_param *params, const char *key,
} }
int int
spdk_iscsi_param_set_int(struct iscsi_param *params, const char *key, uint32_t val) iscsi_param_set_int(struct iscsi_param *params, const char *key, uint32_t val)
{ {
char buf[MAX_TMPBUF]; char buf[MAX_TMPBUF];
struct iscsi_param *param; struct iscsi_param *param;
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set %s=%d\n", key, val); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set %s=%d\n", key, val);
param = spdk_iscsi_param_find(params, key); param = iscsi_param_find(params, key);
if (param == NULL) { if (param == NULL) {
SPDK_ERRLOG("no key %s\n", key); SPDK_ERRLOG("no key %s\n", key);
return -1; return -1;
@ -253,7 +253,7 @@ iscsi_parse_param(struct iscsi_param **params, const uint8_t *data, uint32_t dat
memcpy(key_copy, data, key_len); memcpy(key_copy, data, key_len);
key_copy[key_len] = '\0'; key_copy[key_len] = '\0';
/* check whether this key is duplicated */ /* check whether this key is duplicated */
if (NULL != spdk_iscsi_param_find(*params, key_copy)) { if (NULL != iscsi_param_find(*params, key_copy)) {
SPDK_ERRLOG("Duplicated Key %s\n", key_copy); SPDK_ERRLOG("Duplicated Key %s\n", key_copy);
free(key_copy); free(key_copy);
return -1; return -1;
@ -287,7 +287,7 @@ iscsi_parse_param(struct iscsi_param **params, const uint8_t *data, uint32_t dat
memcpy(val_copy, key_end + 1, val_len); memcpy(val_copy, key_end + 1, val_len);
rc = spdk_iscsi_param_add(params, key_copy, val_copy, NULL, 0); rc = iscsi_param_add(params, key_copy, val_copy, NULL, 0);
free(val_copy); free(val_copy);
free(key_copy); free(key_copy);
if (rc < 0) { if (rc < 0) {
@ -308,8 +308,8 @@ iscsi_parse_param(struct iscsi_param **params, const uint8_t *data, uint32_t dat
* \param len length of data in bytes * \param len length of data in bytes
*/ */
int int
spdk_iscsi_parse_params(struct iscsi_param **params, const uint8_t *data, iscsi_parse_params(struct iscsi_param **params, const uint8_t *data,
int len, bool cbit_enabled, char **partial_parameter) int len, bool cbit_enabled, char **partial_parameter)
{ {
int rc, offset = 0; int rc, offset = 0;
char *p; char *p;
@ -381,11 +381,11 @@ spdk_iscsi_parse_params(struct iscsi_param **params, const uint8_t *data,
} }
char * char *
spdk_iscsi_param_get_val(struct iscsi_param *params, const char *key) iscsi_param_get_val(struct iscsi_param *params, const char *key)
{ {
struct iscsi_param *param; struct iscsi_param *param;
param = spdk_iscsi_param_find(params, key); param = iscsi_param_find(params, key);
if (param == NULL) { if (param == NULL) {
return NULL; return NULL;
} }
@ -393,12 +393,12 @@ spdk_iscsi_param_get_val(struct iscsi_param *params, const char *key)
} }
int int
spdk_iscsi_param_eq_val(struct iscsi_param *params, const char *key, iscsi_param_eq_val(struct iscsi_param *params, const char *key,
const char *val) const char *val)
{ {
struct iscsi_param *param; struct iscsi_param *param;
param = spdk_iscsi_param_find(params, key); param = iscsi_param_find(params, key);
if (param == NULL) { if (param == NULL) {
return 0; return 0;
} }
@ -467,17 +467,17 @@ iscsi_params_init_internal(struct iscsi_param **params,
struct iscsi_param *param; struct iscsi_param *param;
for (i = 0; table[i].key != NULL; i++) { for (i = 0; table[i].key != NULL; i++) {
rc = spdk_iscsi_param_add(params, table[i].key, table[i].val, rc = iscsi_param_add(params, table[i].key, table[i].val,
table[i].list, table[i].type); table[i].list, table[i].type);
if (rc < 0) { if (rc < 0) {
SPDK_ERRLOG("iscsi_param_add() failed\n"); SPDK_ERRLOG("iscsi_param_add() failed\n");
return -1; return -1;
} }
param = spdk_iscsi_param_find(*params, table[i].key); param = iscsi_param_find(*params, table[i].key);
if (param != NULL) { if (param != NULL) {
param->state_index = i; param->state_index = i;
} else { } else {
SPDK_ERRLOG("spdk_iscsi_param_find() failed\n"); SPDK_ERRLOG("iscsi_param_find() failed\n");
return -1; return -1;
} }
} }
@ -486,13 +486,13 @@ iscsi_params_init_internal(struct iscsi_param **params,
} }
int int
spdk_iscsi_conn_params_init(struct iscsi_param **params) iscsi_conn_params_init(struct iscsi_param **params)
{ {
return 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) iscsi_sess_params_init(struct iscsi_param **params)
{ {
return iscsi_params_init_internal(params, &sess_param_table[0]); return iscsi_params_init_internal(params, &sess_param_table[0]);
} }
@ -588,15 +588,15 @@ iscsi_special_param_construction(struct spdk_iscsi_conn *conn,
return -1; return -1;
} }
param_first = spdk_iscsi_param_find(conn->sess->params, param_first = iscsi_param_find(conn->sess->params,
"FirstBurstLength"); "FirstBurstLength");
if (param_first != NULL) { if (param_first != NULL) {
FirstBurstLength = (uint32_t)strtol(param_first->val, NULL, 10); FirstBurstLength = (uint32_t)strtol(param_first->val, NULL, 10);
} else { } else {
FirstBurstLength = SPDK_ISCSI_FIRST_BURST_LENGTH; FirstBurstLength = SPDK_ISCSI_FIRST_BURST_LENGTH;
} }
param_max = spdk_iscsi_param_find(conn->sess->params, param_max = iscsi_param_find(conn->sess->params,
"MaxBurstLength"); "MaxBurstLength");
if (param_max != NULL) { if (param_max != NULL) {
MaxBurstLength = (uint32_t)strtol(param_max->val, NULL, 10); MaxBurstLength = (uint32_t)strtol(param_max->val, NULL, 10);
} else { } else {
@ -860,10 +860,10 @@ iscsi_negotiate_param_init(struct spdk_iscsi_conn *conn,
{ {
int index; int index;
*cur_param_p = spdk_iscsi_param_find(*params_dst_p, param->key); *cur_param_p = iscsi_param_find(*params_dst_p, param->key);
if (*cur_param_p == NULL) { if (*cur_param_p == NULL) {
*params_dst_p = conn->sess->params; *params_dst_p = conn->sess->params;
*cur_param_p = spdk_iscsi_param_find(*params_dst_p, param->key); *cur_param_p = iscsi_param_find(*params_dst_p, param->key);
if (*cur_param_p == NULL) { if (*cur_param_p == NULL) {
if ((strncasecmp(param->key, "X-", 2) == 0) || if ((strncasecmp(param->key, "X-", 2) == 0) ||
(strncasecmp(param->key, "X#", 2) == 0)) { (strncasecmp(param->key, "X#", 2) == 0)) {
@ -898,9 +898,9 @@ iscsi_negotiate_param_init(struct spdk_iscsi_conn *conn,
} }
int int
spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn, iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
struct iscsi_param **params, uint8_t *data, int alloc_len, struct iscsi_param **params, uint8_t *data, int alloc_len,
int data_len) int data_len)
{ {
struct iscsi_param *param; struct iscsi_param *param;
struct iscsi_param *cur_param; struct iscsi_param *cur_param;
@ -936,9 +936,9 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
/* discovery? */ /* discovery? */
discovery = 0; discovery = 0;
cur_param = spdk_iscsi_param_find(*params, "SessionType"); cur_param = iscsi_param_find(*params, "SessionType");
if (cur_param == NULL) { if (cur_param == NULL) {
cur_param = spdk_iscsi_param_find(conn->sess->params, "SessionType"); cur_param = iscsi_param_find(conn->sess->params, "SessionType");
if (cur_param == NULL) { if (cur_param == NULL) {
/* no session type */ /* no session type */
} else { } else {
@ -977,9 +977,9 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
/* To adjust the location of FirstBurstLength location and put it to /* To adjust the location of FirstBurstLength location and put it to
* the end, then we can always firstly determine the MaxBurstLength * the end, then we can always firstly determine the MaxBurstLength
*/ */
param = spdk_iscsi_param_find(*params, "MaxBurstLength"); param = iscsi_param_find(*params, "MaxBurstLength");
if (param != NULL) { if (param != NULL) {
param = spdk_iscsi_param_find(*params, "FirstBurstLength"); param = iscsi_param_find(*params, "FirstBurstLength");
/* check the existence of FirstBurstLength */ /* check the existence of FirstBurstLength */
if (param != NULL) { if (param != NULL) {
@ -987,8 +987,8 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
if (param->next != NULL) { if (param->next != NULL) {
snprintf(in_val, ISCSI_TEXT_MAX_VAL_LEN + 1, "%s", param->val); snprintf(in_val, ISCSI_TEXT_MAX_VAL_LEN + 1, "%s", param->val);
type = param->type; type = param->type;
spdk_iscsi_param_add(params, "FirstBurstLength", iscsi_param_add(params, "FirstBurstLength",
in_val, NULL, type); in_val, NULL, type);
} }
} }
} }
@ -1049,8 +1049,8 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
if (strcasecmp(param->key, "FirstBurstLength") == 0) { if (strcasecmp(param->key, "FirstBurstLength") == 0) {
FirstBurstLength = (uint32_t)strtol(param->val, NULL, FirstBurstLength = (uint32_t)strtol(param->val, NULL,
10); 10);
new_val = spdk_iscsi_param_get_val(conn->sess->params, new_val = iscsi_param_get_val(conn->sess->params,
"MaxBurstLength"); "MaxBurstLength");
if (new_val != NULL) { if (new_val != NULL) {
MaxBurstLength = (uint32_t) strtol(new_val, NULL, MaxBurstLength = (uint32_t) strtol(new_val, NULL,
10); 10);
@ -1083,7 +1083,7 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
* existed key in the connection's parameters * existed key in the connection's parameters
*/ */
if (add_param_value == 0) { if (add_param_value == 0) {
spdk_iscsi_param_set(params_dst, param->key, new_val); iscsi_param_set(params_dst, param->key, new_val);
} }
total = iscsi_construct_data_from_param(param, total = iscsi_construct_data_from_param(param,
new_val, new_val,
@ -1118,11 +1118,11 @@ final_return:
} }
int int
spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn) iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
{ {
const char *val; const char *val;
val = spdk_iscsi_param_get_val(conn->params, "MaxRecvDataSegmentLength"); val = iscsi_param_get_val(conn->params, "MaxRecvDataSegmentLength");
if (val == NULL) { if (val == NULL) {
SPDK_ERRLOG("Getval MaxRecvDataSegmentLength failed\n"); SPDK_ERRLOG("Getval MaxRecvDataSegmentLength failed\n");
return -1; return -1;
@ -1134,7 +1134,7 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
conn->MaxRecvDataSegmentLength = SPDK_BDEV_LARGE_BUF_MAX_SIZE; conn->MaxRecvDataSegmentLength = SPDK_BDEV_LARGE_BUF_MAX_SIZE;
} }
val = spdk_iscsi_param_get_val(conn->params, "HeaderDigest"); val = iscsi_param_get_val(conn->params, "HeaderDigest");
if (val == NULL) { if (val == NULL) {
SPDK_ERRLOG("Getval HeaderDigest failed\n"); SPDK_ERRLOG("Getval HeaderDigest failed\n");
return -1; return -1;
@ -1146,7 +1146,7 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set HeaderDigest=0\n"); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set HeaderDigest=0\n");
conn->header_digest = 0; conn->header_digest = 0;
} }
val = spdk_iscsi_param_get_val(conn->params, "DataDigest"); val = iscsi_param_get_val(conn->params, "DataDigest");
if (val == NULL) { if (val == NULL) {
SPDK_ERRLOG("Getval DataDigest failed\n"); SPDK_ERRLOG("Getval DataDigest failed\n");
return -1; return -1;
@ -1159,35 +1159,35 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
conn->data_digest = 0; conn->data_digest = 0;
} }
val = spdk_iscsi_param_get_val(conn->sess->params, "MaxConnections"); val = iscsi_param_get_val(conn->sess->params, "MaxConnections");
if (val == NULL) { if (val == NULL) {
SPDK_ERRLOG("Getval MaxConnections failed\n"); SPDK_ERRLOG("Getval MaxConnections failed\n");
return -1; return -1;
} }
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxConnections=%s\n", val); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxConnections=%s\n", val);
conn->sess->MaxConnections = (uint32_t) strtol(val, NULL, 10); conn->sess->MaxConnections = (uint32_t) strtol(val, NULL, 10);
val = spdk_iscsi_param_get_val(conn->sess->params, "MaxOutstandingR2T"); val = iscsi_param_get_val(conn->sess->params, "MaxOutstandingR2T");
if (val == NULL) { if (val == NULL) {
SPDK_ERRLOG("Getval MaxOutstandingR2T failed\n"); SPDK_ERRLOG("Getval MaxOutstandingR2T failed\n");
return -1; return -1;
} }
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxOutstandingR2T=%s\n", val); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxOutstandingR2T=%s\n", val);
conn->sess->MaxOutstandingR2T = (uint32_t) strtol(val, NULL, 10); conn->sess->MaxOutstandingR2T = (uint32_t) strtol(val, NULL, 10);
val = spdk_iscsi_param_get_val(conn->sess->params, "FirstBurstLength"); val = iscsi_param_get_val(conn->sess->params, "FirstBurstLength");
if (val == NULL) { if (val == NULL) {
SPDK_ERRLOG("Getval FirstBurstLength failed\n"); SPDK_ERRLOG("Getval FirstBurstLength failed\n");
return -1; return -1;
} }
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy FirstBurstLength=%s\n", val); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy FirstBurstLength=%s\n", val);
conn->sess->FirstBurstLength = (uint32_t) strtol(val, NULL, 10); conn->sess->FirstBurstLength = (uint32_t) strtol(val, NULL, 10);
val = spdk_iscsi_param_get_val(conn->sess->params, "MaxBurstLength"); val = iscsi_param_get_val(conn->sess->params, "MaxBurstLength");
if (val == NULL) { if (val == NULL) {
SPDK_ERRLOG("Getval MaxBurstLength failed\n"); SPDK_ERRLOG("Getval MaxBurstLength failed\n");
return -1; return -1;
} }
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxBurstLength=%s\n", val); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxBurstLength=%s\n", val);
conn->sess->MaxBurstLength = (uint32_t) strtol(val, NULL, 10); conn->sess->MaxBurstLength = (uint32_t) strtol(val, NULL, 10);
val = spdk_iscsi_param_get_val(conn->sess->params, "InitialR2T"); val = iscsi_param_get_val(conn->sess->params, "InitialR2T");
if (val == NULL) { if (val == NULL) {
SPDK_ERRLOG("Getval InitialR2T failed\n"); SPDK_ERRLOG("Getval InitialR2T failed\n");
return -1; return -1;
@ -1199,7 +1199,7 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set InitialR2T=0\n"); SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set InitialR2T=0\n");
conn->sess->InitialR2T = false; conn->sess->InitialR2T = false;
} }
val = spdk_iscsi_param_get_val(conn->sess->params, "ImmediateData"); val = iscsi_param_get_val(conn->sess->params, "ImmediateData");
if (val == NULL) { if (val == NULL) {
SPDK_ERRLOG("Getval ImmediateData failed\n"); SPDK_ERRLOG("Getval ImmediateData failed\n");
return -1; return -1;

38
lib/iscsi/param.h
View File

@ -61,34 +61,34 @@ struct iscsi_param {
}; };
void void
spdk_iscsi_param_free(struct iscsi_param *params); iscsi_param_free(struct iscsi_param *params);
struct iscsi_param * struct iscsi_param *
spdk_iscsi_param_find(struct iscsi_param *params, const char *key); iscsi_param_find(struct iscsi_param *params, const char *key);
int int
spdk_iscsi_param_del(struct iscsi_param **params, const char *key); iscsi_param_del(struct iscsi_param **params, const char *key);
int int
spdk_iscsi_param_add(struct iscsi_param **params, const char *key, iscsi_param_add(struct iscsi_param **params, const char *key,
const char *val, const char *list, int type); const char *val, const char *list, int type);
int int
spdk_iscsi_param_set(struct iscsi_param *params, const char *key, iscsi_param_set(struct iscsi_param *params, const char *key,
const char *val); const char *val);
int int
spdk_iscsi_param_set_int(struct iscsi_param *params, const char *key, uint32_t val); iscsi_param_set_int(struct iscsi_param *params, const char *key, uint32_t val);
int int
spdk_iscsi_parse_params(struct iscsi_param **params, const uint8_t *data, iscsi_parse_params(struct iscsi_param **params, const uint8_t *data,
int len, bool cbit_enabled, char **partial_parameter); int len, bool cbit_enabled, char **partial_parameter);
char * char *
spdk_iscsi_param_get_val(struct iscsi_param *params, const char *key); iscsi_param_get_val(struct iscsi_param *params, const char *key);
int int
spdk_iscsi_param_eq_val(struct iscsi_param *params, const char *key, iscsi_param_eq_val(struct iscsi_param *params, const char *key,
const char *val); const char *val);
int spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn, int iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
struct iscsi_param **params_p, uint8_t *data, struct iscsi_param **params_p, uint8_t *data,
int alloc_len, int data_len); int alloc_len, int data_len);
int spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn); int iscsi_copy_param2var(struct spdk_iscsi_conn *conn);
int spdk_iscsi_conn_params_init(struct iscsi_param **params); int iscsi_conn_params_init(struct iscsi_param **params);
int spdk_iscsi_sess_params_init(struct iscsi_param **params); int iscsi_sess_params_init(struct iscsi_param **params);
#endif /* SPDK_ISCSI_PARAM_H */ #endif /* SPDK_ISCSI_PARAM_H */

4
test/unit/lib/iscsi/conn.c/conn_ut.c
View File

@ -185,9 +185,9 @@ DEFINE_STUB_V(spdk_scsi_task_process_abort, (struct spdk_scsi_task *task));
DEFINE_STUB_V(spdk_put_pdu, (struct spdk_iscsi_pdu *pdu)); DEFINE_STUB_V(spdk_put_pdu, (struct spdk_iscsi_pdu *pdu));
DEFINE_STUB_V(spdk_iscsi_param_free, (struct iscsi_param *params)); DEFINE_STUB_V(iscsi_param_free, (struct iscsi_param *params));
DEFINE_STUB(spdk_iscsi_conn_params_init, int, (struct iscsi_param **params), 0); DEFINE_STUB(iscsi_conn_params_init, int, (struct iscsi_param **params), 0);
DEFINE_STUB_V(spdk_clear_all_transfer_task, DEFINE_STUB_V(spdk_clear_all_transfer_task,
(struct spdk_iscsi_conn *conn, struct spdk_scsi_lun *lun, (struct spdk_iscsi_conn *conn, struct spdk_scsi_lun *lun,

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

@ -87,26 +87,26 @@ burst_length_param_negotation(int FirstBurstLength, int MaxBurstLength,
sess.MaxOutstandingR2T = 1; sess.MaxOutstandingR2T = 1;
/* set default params */ /* set default params */
rc = spdk_iscsi_sess_params_init(&sess.params); rc = iscsi_sess_params_init(&sess.params);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_param_set_int(sess.params, "FirstBurstLength", rc = iscsi_param_set_int(sess.params, "FirstBurstLength",
sess.FirstBurstLength); sess.FirstBurstLength);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_param_set_int(sess.params, "MaxBurstLength", rc = iscsi_param_set_int(sess.params, "MaxBurstLength",
sess.MaxBurstLength); sess.MaxBurstLength);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
rc = spdk_iscsi_param_set(sess.params, "InitialR2T", rc = iscsi_param_set(sess.params, "InitialR2T",
sess.InitialR2T ? "Yes" : "No"); sess.InitialR2T ? "Yes" : "No");
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
conn.full_feature = 1; conn.full_feature = 1;
conn.sess = &sess; conn.sess = &sess;
conn.MaxRecvDataSegmentLength = 65536; conn.MaxRecvDataSegmentLength = 65536;
rc = spdk_iscsi_conn_params_init(&conn.params); rc = iscsi_conn_params_init(&conn.params);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
/* construct the data */ /* construct the data */
@ -126,24 +126,24 @@ burst_length_param_negotation(int FirstBurstLength, int MaxBurstLength,
total++; total++;
/* store incoming parameters */ /* store incoming parameters */
rc = spdk_iscsi_parse_params(params_p, data, total, false, NULL); rc = iscsi_parse_params(params_p, data, total, false, NULL);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
/* negotiate parameters */ /* negotiate parameters */
rc = spdk_iscsi_negotiate_params(&conn, params_p, rc = iscsi_negotiate_params(&conn, params_p,
data, 8192, rc); data, 8192, rc);
CU_ASSERT(rc > 0); CU_ASSERT(rc > 0);
rc = spdk_iscsi_copy_param2var(&conn); rc = iscsi_copy_param2var(&conn);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
CU_ASSERT(conn.sess->FirstBurstLength <= SPDK_ISCSI_FIRST_BURST_LENGTH); CU_ASSERT(conn.sess->FirstBurstLength <= SPDK_ISCSI_FIRST_BURST_LENGTH);
CU_ASSERT(conn.sess->FirstBurstLength <= conn.sess->MaxBurstLength); CU_ASSERT(conn.sess->FirstBurstLength <= conn.sess->MaxBurstLength);
CU_ASSERT(conn.sess->MaxBurstLength <= SPDK_ISCSI_MAX_BURST_LENGTH); CU_ASSERT(conn.sess->MaxBurstLength <= SPDK_ISCSI_MAX_BURST_LENGTH);
CU_ASSERT(conn.sess->MaxOutstandingR2T == 1); CU_ASSERT(conn.sess->MaxOutstandingR2T == 1);
spdk_iscsi_param_free(sess.params); iscsi_param_free(sess.params);
spdk_iscsi_param_free(conn.params); iscsi_param_free(conn.params);
spdk_iscsi_param_free(*params_p); iscsi_param_free(*params_p);
} }
static void static void
@ -189,11 +189,11 @@ list_negotiation_test(void)
#define PARSE(strconst, partial_enabled, partial_text) \ #define PARSE(strconst, partial_enabled, partial_text) \
data = strconst; \ data = strconst; \
len = sizeof(strconst) - 1; \ len = sizeof(strconst) - 1; \
rc = spdk_iscsi_parse_params(&params, data, len, partial_enabled, partial_text) rc = iscsi_parse_params(&params, data, len, partial_enabled, partial_text)
#define EXPECT_VAL(key, expected_value) \ #define EXPECT_VAL(key, expected_value) \
{ \ { \
const char *val = spdk_iscsi_param_get_val(params, key); \ const char *val = iscsi_param_get_val(params, key); \
CU_ASSERT(val != NULL); \ CU_ASSERT(val != NULL); \
if (val != NULL) { \ if (val != NULL) { \
CU_ASSERT(strcmp(val, expected_value) == 0); \ CU_ASSERT(strcmp(val, expected_value) == 0); \
@ -201,7 +201,7 @@ list_negotiation_test(void)
} }
#define EXPECT_NULL(key) \ #define EXPECT_NULL(key) \
CU_ASSERT(spdk_iscsi_param_get_val(params, key) == NULL) CU_ASSERT(iscsi_param_get_val(params, key) == NULL)
static void static void
parse_valid_test(void) parse_valid_test(void)
@ -236,7 +236,7 @@ parse_valid_test(void)
memcpy(data, "CHAP_C", 6); memcpy(data, "CHAP_C", 6);
data[6] = '='; data[6] = '=';
data[len - 1] = '\0'; data[len - 1] = '\0';
rc = spdk_iscsi_parse_params(&params, data, len, false, NULL); rc = iscsi_parse_params(&params, data, len, false, NULL);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
free(data); free(data);
@ -277,7 +277,7 @@ parse_valid_test(void)
partial_parameter = NULL; partial_parameter = NULL;
data = "PartialKey="; data = "PartialKey=";
len = 7; len = 7;
rc = spdk_iscsi_parse_params(&params, data, len, true, &partial_parameter); rc = iscsi_parse_params(&params, data, len, true, &partial_parameter);
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
CU_ASSERT_STRING_EQUAL(partial_parameter, "Partial"); CU_ASSERT_STRING_EQUAL(partial_parameter, "Partial");
EXPECT_NULL("PartialKey"); EXPECT_NULL("PartialKey");
@ -286,7 +286,7 @@ parse_valid_test(void)
EXPECT_VAL("PartialKey", "Value"); EXPECT_VAL("PartialKey", "Value");
CU_ASSERT_PTR_NULL(partial_parameter); CU_ASSERT_PTR_NULL(partial_parameter);
spdk_iscsi_param_free(params); iscsi_param_free(params);
} }
static void static void
@ -323,7 +323,7 @@ parse_invalid_test(void)
memcpy(data, "CHAP_C", 6); memcpy(data, "CHAP_C", 6);
data[6] = '='; data[6] = '=';
data[len - 1] = '\0'; data[len - 1] = '\0';
rc = spdk_iscsi_parse_params(&params, data, len, false, NULL); rc = iscsi_parse_params(&params, data, len, false, NULL);
free(data); free(data);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
EXPECT_NULL("CHAP_C"); EXPECT_NULL("CHAP_C");
@ -336,7 +336,7 @@ parse_invalid_test(void)
memset(data, 'A', len); memset(data, 'A', len);
data[1] = '='; data[1] = '=';
data[len - 1] = '\0'; data[len - 1] = '\0';
rc = spdk_iscsi_parse_params(&params, data, len, false, NULL); rc = iscsi_parse_params(&params, data, len, false, NULL);
free(data); free(data);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
EXPECT_NULL("A"); EXPECT_NULL("A");
@ -349,7 +349,7 @@ parse_invalid_test(void)
memset(data, 'A', len); memset(data, 'A', len);
data[64] = '='; data[64] = '=';
data[len - 1] = '\0'; data[len - 1] = '\0';
rc = spdk_iscsi_parse_params(&params, data, len, false, NULL); rc = iscsi_parse_params(&params, data, len, false, NULL);
free(data); free(data);
CU_ASSERT(rc != 0); CU_ASSERT(rc != 0);
EXPECT_NULL("A"); EXPECT_NULL("A");
@ -370,10 +370,10 @@ parse_invalid_test(void)
*/ */
data = "MaxRecvDataSegmentLength=81928"; data = "MaxRecvDataSegmentLength=81928";
len = strlen(data) - 1; len = strlen(data) - 1;
rc = spdk_iscsi_parse_params(&params, data, len, false, NULL); rc = iscsi_parse_params(&params, data, len, false, NULL);
EXPECT_VAL("MaxRecvDataSegmentLength", "8192"); EXPECT_VAL("MaxRecvDataSegmentLength", "8192");
CU_ASSERT(rc == 0); CU_ASSERT(rc == 0);
spdk_iscsi_param_free(params); iscsi_param_free(params);
} }
int int