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)/../..)
include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
SO_VER := 2
SO_VER := 3
SO_MINOR := 0
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 */
rc = spdk_iscsi_conn_params_init(&conn->params);
rc = iscsi_conn_params_init(&conn->params);
if (rc < 0) {
SPDK_ERRLOG("iscsi_conn_params_init() failed\n");
goto error_return;
@ -307,7 +307,7 @@ spdk_iscsi_conn_construct(struct spdk_iscsi_portal *portal,
return 0;
error_return:
spdk_iscsi_param_free(conn->params);
iscsi_param_free(conn->params);
free_conn(conn);
return -1;
}
@ -434,7 +434,7 @@ iscsi_conn_free(struct spdk_iscsi_conn *conn)
end:
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "cleanup free conn\n");
spdk_iscsi_param_free(conn->params);
iscsi_param_free(conn->params);
free_conn(conn);
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. */
if (conn->sess == NULL ||
!conn->full_feature ||
!spdk_iscsi_param_eq_val(conn->sess->params, "SessionType", "Normal")) {
!iscsi_param_eq_val(conn->sess->params, "SessionType", "Normal")) {
return;
}
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->target = NULL;
sess->session_type = SESSION_TYPE_INVALID;
spdk_iscsi_param_free(sess->params);
iscsi_param_free(sess->params);
free(sess->conns);
spdk_scsi_port_free(&sess->initiator_port);
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;
/* set default params */
rc = spdk_iscsi_sess_params_init(&sess->params);
rc = iscsi_sess_params_init(&sess->params);
if (rc < 0) {
SPDK_ERRLOG("iscsi_sess_params_init() failed\n");
goto error_return;
}
/* replace with config value */
rc = spdk_iscsi_param_set_int(sess->params, "MaxConnections",
sess->MaxConnections);
rc = iscsi_param_set_int(sess->params, "MaxConnections",
sess->MaxConnections);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return;
}
rc = spdk_iscsi_param_set_int(sess->params, "MaxOutstandingR2T",
sess->MaxOutstandingR2T);
rc = iscsi_param_set_int(sess->params, "MaxOutstandingR2T",
sess->MaxOutstandingR2T);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return;
}
rc = spdk_iscsi_param_set_int(sess->params, "DefaultTime2Wait",
sess->DefaultTime2Wait);
rc = iscsi_param_set_int(sess->params, "DefaultTime2Wait",
sess->DefaultTime2Wait);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return;
}
rc = spdk_iscsi_param_set_int(sess->params, "DefaultTime2Retain",
sess->DefaultTime2Retain);
rc = iscsi_param_set_int(sess->params, "DefaultTime2Retain",
sess->DefaultTime2Retain);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return;
}
rc = spdk_iscsi_param_set_int(sess->params, "FirstBurstLength",
sess->FirstBurstLength);
rc = iscsi_param_set_int(sess->params, "FirstBurstLength",
sess->FirstBurstLength);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return;
}
rc = spdk_iscsi_param_set_int(sess->params, "MaxBurstLength",
sess->MaxBurstLength);
rc = iscsi_param_set_int(sess->params, "MaxBurstLength",
sess->MaxBurstLength);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return;
}
rc = spdk_iscsi_param_set(sess->params, "InitialR2T",
sess->InitialR2T ? "Yes" : "No");
rc = iscsi_param_set(sess->params, "InitialR2T",
sess->InitialR2T ? "Yes" : "No");
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n");
goto error_return;
}
rc = spdk_iscsi_param_set(sess->params, "ImmediateData",
sess->ImmediateData ? "Yes" : "No");
rc = iscsi_param_set(sess->params, "ImmediateData",
sess->ImmediateData ? "Yes" : "No");
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n");
goto error_return;
}
rc = spdk_iscsi_param_set(sess->params, "DataPDUInOrder",
sess->DataPDUInOrder ? "Yes" : "No");
rc = iscsi_param_set(sess->params, "DataPDUInOrder",
sess->DataPDUInOrder ? "Yes" : "No");
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n");
goto error_return;
}
rc = spdk_iscsi_param_set(sess->params, "DataSequenceInOrder",
sess->DataSequenceInOrder ? "Yes" : "No");
rc = iscsi_param_set(sess->params, "DataSequenceInOrder",
sess->DataSequenceInOrder ? "Yes" : "No");
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set() failed\n");
goto error_return;
}
rc = spdk_iscsi_param_set_int(sess->params, "ErrorRecoveryLevel",
sess->ErrorRecoveryLevel);
rc = iscsi_param_set_int(sess->params, "ErrorRecoveryLevel",
sess->ErrorRecoveryLevel);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return;
}
/* realloc buffer */
rc = spdk_iscsi_param_set_int(conn->params, "MaxRecvDataSegmentLength",
conn->MaxRecvDataSegmentLength);
rc = iscsi_param_set_int(conn->params, "MaxRecvDataSegmentLength",
conn->MaxRecvDataSegmentLength);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n");
goto error_return;
@ -796,9 +796,9 @@ iscsi_append_param(struct spdk_iscsi_conn *conn, const char *key,
struct iscsi_param *param;
int rc;
param = spdk_iscsi_param_find(conn->params, key);
param = iscsi_param_find(conn->params, key);
if (param == NULL) {
param = spdk_iscsi_param_find(conn->sess->params, key);
param = iscsi_param_find(conn->sess->params, key);
if (param == NULL) {
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "no key %.64s\n", key);
return data_len;
@ -853,7 +853,7 @@ iscsi_auth_params(struct spdk_iscsi_conn *conn,
}
/* 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) {
SPDK_ERRLOG("CHAP sequence error\n");
goto error_return;
@ -897,7 +897,7 @@ iscsi_auth_params(struct spdk_iscsi_conn *conn,
data, alloc_len, total);
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 tgtmd5[SPDK_MD5DIGEST_LEN];
struct spdk_md5ctx md5ctx;
@ -908,7 +908,7 @@ iscsi_auth_params(struct spdk_iscsi_conn *conn,
goto error_return;
}
response = spdk_iscsi_param_get_val(params, "CHAP_R");
response = iscsi_param_get_val(params, "CHAP_R");
if (response == NULL) {
SPDK_ERRLOG("no response\n");
goto error_return;
@ -979,10 +979,10 @@ iscsi_auth_params(struct spdk_iscsi_conn *conn,
conn->authenticated = true;
/* mutual CHAP? */
identifier = spdk_iscsi_param_get_val(params, "CHAP_I");
identifier = iscsi_param_get_val(params, "CHAP_I");
if (identifier != NULL) {
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) {
SPDK_ERRLOG("CHAP sequence error\n");
goto error_return;
@ -1104,9 +1104,9 @@ iscsi_conn_params_update(struct spdk_iscsi_conn *conn)
uint32_t recv_buf_size;
/* update internal variables */
rc = spdk_iscsi_copy_param2var(conn);
rc = iscsi_copy_param2var(conn);
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) {
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_NEXT_STAGE_MASK;
}
spdk_iscsi_param_free(params);
iscsi_param_free(params);
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;
rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs;
rc = spdk_iscsi_parse_params(params, pdu->data,
pdu->data_segment_len, ISCSI_BHS_LOGIN_GET_CBIT(reqh->flags),
&conn->partial_text_parameter);
rc = iscsi_parse_params(params, pdu->data,
pdu->data_segment_len, ISCSI_BHS_LOGIN_GET_CBIT(reqh->flags),
&conn->partial_text_parameter);
if (rc < 0) {
SPDK_ERRLOG("iscsi_parse_params() failed\n");
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;
/* Initiator Name and Port */
val = spdk_iscsi_param_get_val(params, "InitiatorName");
val = iscsi_param_get_val(params, "InitiatorName");
if (val == NULL) {
SPDK_ERRLOG("InitiatorName is empty\n");
/* Missing parameter */
@ -1408,7 +1408,7 @@ iscsi_op_login_session_type(struct spdk_iscsi_conn *conn,
struct iscsi_bhs_login_rsp *rsph;
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 (rsph->tsih != 0) {
*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;
int index;
orig_param = spdk_iscsi_param_find(conn->params, key);
orig_param = iscsi_param_find(conn->params, key);
if (orig_param == NULL) {
SPDK_ERRLOG("orig_param %s not found\n", key);
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
}
index = orig_param->state_index;
rc = spdk_iscsi_param_del(&conn->params, key);
rc = iscsi_param_del(&conn->params, key);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_del(%s) failed\n", key);
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) {
SPDK_ERRLOG("iscsi_param_add() failed\n");
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) {
SPDK_ERRLOG("spdk_iscsi_param_find() failed\n");
SPDK_ERRLOG("iscsi_param_find() failed\n");
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
}
new_param->state_index = index;
@ -1661,7 +1661,7 @@ iscsi_op_login_session_normal(struct spdk_iscsi_conn *conn,
int rc = 0;
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) {
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", "");
}
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) {
SPDK_ERRLOG("iscsi_param_set() failed\n");
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,
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) {
SPDK_ERRLOG("iscsi_param_set() failed\n");
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
}
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) {
SPDK_ERRLOG("iscsi_param_set() failed\n");
return SPDK_ISCSI_LOGIN_ERROR_PARAMETER;
@ -1843,7 +1843,7 @@ iscsi_op_login_set_target_info(struct spdk_iscsi_conn *conn,
/* write in response */
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) {
rsp_pdu->data_segment_len = iscsi_append_param(conn,
"TargetAlias",
@ -1937,9 +1937,9 @@ iscsi_op_login_phase_none(struct spdk_iscsi_conn *conn,
/* limit conns on discovery session */
if (session_type == SESSION_TYPE_DISCOVERY) {
conn->sess->MaxConnections = 1;
rc = spdk_iscsi_param_set_int(conn->sess->params,
"MaxConnections",
conn->sess->MaxConnections);
rc = iscsi_param_set_int(conn->sess->params,
"MaxConnections",
conn->sess->MaxConnections);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_set_int() failed\n");
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)) {
case ISCSI_SECURITY_NEGOTIATION_PHASE:
/* SecurityNegotiation */
auth_method = spdk_iscsi_param_get_val(conn->params, "AuthMethod");
auth_method = iscsi_param_get_val(conn->params, "AuthMethod");
if (auth_method == NULL) {
SPDK_ERRLOG("AuthMethod is empty\n");
/* Missing parameter */
@ -2066,9 +2066,9 @@ iscsi_op_login_notify_session_info(struct spdk_iscsi_conn *conn,
conn->target->name, conn->target->num,
conn->portal_host, conn->portal_port, conn->pg_tag,
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"),
(spdk_iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
(iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
? "on" : "off"));
} else if (conn->sess->session_type == SESSION_TYPE_DISCOVERY) {
/* discovery session */
@ -2078,9 +2078,9 @@ iscsi_op_login_notify_session_info(struct spdk_iscsi_conn *conn,
conn->initiator_name, conn->initiator_addr,
conn->portal_host, conn->portal_port, conn->pg_tag,
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"),
(spdk_iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
(iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
? "on" : "off"));
} else {
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;
/* negotiate parameters */
rc = spdk_iscsi_negotiate_params(conn, params, rsp_pdu->data,
rsp_pdu->data_buf_len,
rsp_pdu->data_segment_len);
rc = iscsi_negotiate_params(conn, params, rsp_pdu->data,
rsp_pdu->data_buf_len,
rsp_pdu->data_segment_len);
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
* 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);
/* store incoming parameters */
rc = spdk_iscsi_parse_params(&params, pdu->data, pdu->data_segment_len,
C_bit, &conn->partial_text_parameter);
rc = iscsi_parse_params(&params, pdu->data, pdu->data_segment_len,
C_bit, &conn->partial_text_parameter);
if (rc < 0) {
SPDK_ERRLOG("iscsi_parse_params() failed\n");
spdk_iscsi_param_free(params);
iscsi_param_free(params);
return -1;
}
data = calloc(1, alloc_len);
if (!data) {
SPDK_ERRLOG("calloc() failed for data segment\n");
spdk_iscsi_param_free(params);
iscsi_param_free(params);
return -ENOMEM;
}
/* negotiate parameters */
data_len = spdk_iscsi_negotiate_params(conn, &params,
data, alloc_len, data_len);
data_len = iscsi_negotiate_params(conn, &params,
data, alloc_len, data_len);
if (data_len < 0) {
SPDK_ERRLOG("spdk_iscsi_negotiate_params() failed\n");
spdk_iscsi_param_free(params);
SPDK_ERRLOG("iscsi_negotiate_params() failed\n");
iscsi_param_free(params);
free(data);
return -1;
}
/* sendtargets is special case */
val = spdk_iscsi_param_get_val(params, "SendTargets");
val = iscsi_param_get_val(params, "SendTargets");
if (val != NULL) {
if (spdk_iscsi_param_eq_val(conn->sess->params,
"SessionType", "Discovery")) {
if (iscsi_param_eq_val(conn->sess->params,
"SessionType", "Discovery")) {
if (strcasecmp(val, "") == 0) {
val = "ALL";
}
@ -2423,14 +2423,14 @@ iscsi_pdu_payload_op_text(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *p
}
}
} else {
if (spdk_iscsi_param_eq_val(conn->sess->params, "SessionType", "Discovery")) {
spdk_iscsi_param_free(params);
if (iscsi_param_eq_val(conn->sess->params, "SessionType", "Discovery")) {
iscsi_param_free(params);
free(data);
return SPDK_ISCSI_CONNECTION_FATAL;
}
}
spdk_iscsi_param_free(params);
iscsi_param_free(params);
SPDK_LOGDUMP(SPDK_LOG_ISCSI, "Negotiated Params", data, data_len);
/* response PDU */
@ -2490,7 +2490,7 @@ static void iscsi_conn_logout_pdu_complete(void *arg)
" (%s:%s,%d)\n",
conn->initiator_name, conn->initiator_addr,
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"
" (%s:%s,%d), ISID=%"PRIx64", TSIH=%u,"
" 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->portal_host, conn->portal_port, conn->pg_tag,
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"),
(spdk_iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
(iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
? "on" : "off"));
} else {
/* discovery session */
@ -2510,9 +2510,9 @@ static void iscsi_conn_logout_pdu_complete(void *arg)
conn->initiator_name, conn->initiator_addr,
conn->portal_host, conn->portal_port, conn->pg_tag,
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"),
(spdk_iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
(iscsi_param_eq_val(conn->params, "DataDigest", "CRC32C")
? "on" : "off"));
}
}

112
lib/iscsi/param.c
View File

@ -52,7 +52,7 @@ static const char *non_simple_value_params[] = {
};
void
spdk_iscsi_param_free(struct iscsi_param *params)
iscsi_param_free(struct iscsi_param *params)
{
struct iscsi_param *param, *next_param;
@ -84,7 +84,7 @@ iscsi_find_key_in_array(const char *key, const char *array[])
}
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;
@ -101,7 +101,7 @@ spdk_iscsi_param_find(struct iscsi_param *params, const char *key)
}
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;
@ -118,7 +118,7 @@ spdk_iscsi_param_del(struct iscsi_param **params, const char *key)
*params = param->next;
}
param->next = NULL;
spdk_iscsi_param_free(param);
iscsi_param_free(param);
return 0;
}
prev_param = param;
@ -127,8 +127,8 @@ spdk_iscsi_param_del(struct iscsi_param **params, const char *key)
}
int
spdk_iscsi_param_add(struct iscsi_param **params, const char *key,
const char *val, const char *list, int type)
iscsi_param_add(struct iscsi_param **params, const char *key,
const char *val, const char *list, int type)
{
struct iscsi_param *param, *last_param;
@ -138,9 +138,9 @@ spdk_iscsi_param_add(struct iscsi_param **params, const char *key,
return -1;
}
param = spdk_iscsi_param_find(*params, key);
param = iscsi_param_find(*params, key);
if (param != NULL) {
spdk_iscsi_param_del(params, key);
iscsi_param_del(params, key);
}
param = calloc(1, sizeof(*param));
@ -169,13 +169,13 @@ spdk_iscsi_param_add(struct iscsi_param **params, const char *key,
}
int
spdk_iscsi_param_set(struct iscsi_param *params, const char *key,
const char *val)
iscsi_param_set(struct iscsi_param *params, const char *key,
const char *val)
{
struct iscsi_param *param;
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) {
SPDK_ERRLOG("no key %s\n", key);
return -1;
@ -189,13 +189,13 @@ spdk_iscsi_param_set(struct iscsi_param *params, const char *key,
}
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];
struct iscsi_param *param;
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) {
SPDK_ERRLOG("no key %s\n", key);
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);
key_copy[key_len] = '\0';
/* 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);
free(key_copy);
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);
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(key_copy);
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
*/
int
spdk_iscsi_parse_params(struct iscsi_param **params, const uint8_t *data,
int len, bool cbit_enabled, char **partial_parameter)
iscsi_parse_params(struct iscsi_param **params, const uint8_t *data,
int len, bool cbit_enabled, char **partial_parameter)
{
int rc, offset = 0;
char *p;
@ -381,11 +381,11 @@ spdk_iscsi_parse_params(struct iscsi_param **params, const uint8_t *data,
}
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;
param = spdk_iscsi_param_find(params, key);
param = iscsi_param_find(params, key);
if (param == NULL) {
return NULL;
}
@ -393,12 +393,12 @@ spdk_iscsi_param_get_val(struct iscsi_param *params, const char *key)
}
int
spdk_iscsi_param_eq_val(struct iscsi_param *params, const char *key,
const char *val)
iscsi_param_eq_val(struct iscsi_param *params, const char *key,
const char *val)
{
struct iscsi_param *param;
param = spdk_iscsi_param_find(params, key);
param = iscsi_param_find(params, key);
if (param == NULL) {
return 0;
}
@ -467,17 +467,17 @@ iscsi_params_init_internal(struct iscsi_param **params,
struct iscsi_param *param;
for (i = 0; table[i].key != NULL; i++) {
rc = spdk_iscsi_param_add(params, table[i].key, table[i].val,
table[i].list, table[i].type);
rc = iscsi_param_add(params, table[i].key, table[i].val,
table[i].list, table[i].type);
if (rc < 0) {
SPDK_ERRLOG("iscsi_param_add() failed\n");
return -1;
}
param = spdk_iscsi_param_find(*params, table[i].key);
param = iscsi_param_find(*params, table[i].key);
if (param != NULL) {
param->state_index = i;
} else {
SPDK_ERRLOG("spdk_iscsi_param_find() failed\n");
SPDK_ERRLOG("iscsi_param_find() failed\n");
return -1;
}
}
@ -486,13 +486,13 @@ iscsi_params_init_internal(struct iscsi_param **params,
}
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]);
}
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]);
}
@ -588,15 +588,15 @@ iscsi_special_param_construction(struct spdk_iscsi_conn *conn,
return -1;
}
param_first = spdk_iscsi_param_find(conn->sess->params,
"FirstBurstLength");
param_first = iscsi_param_find(conn->sess->params,
"FirstBurstLength");
if (param_first != NULL) {
FirstBurstLength = (uint32_t)strtol(param_first->val, NULL, 10);
} else {
FirstBurstLength = SPDK_ISCSI_FIRST_BURST_LENGTH;
}
param_max = spdk_iscsi_param_find(conn->sess->params,
"MaxBurstLength");
param_max = iscsi_param_find(conn->sess->params,
"MaxBurstLength");
if (param_max != NULL) {
MaxBurstLength = (uint32_t)strtol(param_max->val, NULL, 10);
} else {
@ -860,10 +860,10 @@ iscsi_negotiate_param_init(struct spdk_iscsi_conn *conn,
{
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) {
*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 ((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
spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
struct iscsi_param **params, uint8_t *data, int alloc_len,
int data_len)
iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
struct iscsi_param **params, uint8_t *data, int alloc_len,
int data_len)
{
struct iscsi_param *param;
struct iscsi_param *cur_param;
@ -936,9 +936,9 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
/* discovery? */
discovery = 0;
cur_param = spdk_iscsi_param_find(*params, "SessionType");
cur_param = iscsi_param_find(*params, "SessionType");
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) {
/* no session type */
} 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
* 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) {
param = spdk_iscsi_param_find(*params, "FirstBurstLength");
param = iscsi_param_find(*params, "FirstBurstLength");
/* check the existence of FirstBurstLength */
if (param != NULL) {
@ -987,8 +987,8 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
if (param->next != NULL) {
snprintf(in_val, ISCSI_TEXT_MAX_VAL_LEN + 1, "%s", param->val);
type = param->type;
spdk_iscsi_param_add(params, "FirstBurstLength",
in_val, NULL, type);
iscsi_param_add(params, "FirstBurstLength",
in_val, NULL, type);
}
}
}
@ -1049,8 +1049,8 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
if (strcasecmp(param->key, "FirstBurstLength") == 0) {
FirstBurstLength = (uint32_t)strtol(param->val, NULL,
10);
new_val = spdk_iscsi_param_get_val(conn->sess->params,
"MaxBurstLength");
new_val = iscsi_param_get_val(conn->sess->params,
"MaxBurstLength");
if (new_val != NULL) {
MaxBurstLength = (uint32_t) strtol(new_val, NULL,
10);
@ -1083,7 +1083,7 @@ spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
* existed key in the connection's parameters
*/
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,
new_val,
@ -1118,11 +1118,11 @@ final_return:
}
int
spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
{
const char *val;
val = spdk_iscsi_param_get_val(conn->params, "MaxRecvDataSegmentLength");
val = iscsi_param_get_val(conn->params, "MaxRecvDataSegmentLength");
if (val == NULL) {
SPDK_ERRLOG("Getval MaxRecvDataSegmentLength failed\n");
return -1;
@ -1134,7 +1134,7 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
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) {
SPDK_ERRLOG("Getval HeaderDigest failed\n");
return -1;
@ -1146,7 +1146,7 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set HeaderDigest=0\n");
conn->header_digest = 0;
}
val = spdk_iscsi_param_get_val(conn->params, "DataDigest");
val = iscsi_param_get_val(conn->params, "DataDigest");
if (val == NULL) {
SPDK_ERRLOG("Getval DataDigest failed\n");
return -1;
@ -1159,35 +1159,35 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
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) {
SPDK_ERRLOG("Getval MaxConnections failed\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxConnections=%s\n", val);
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) {
SPDK_ERRLOG("Getval MaxOutstandingR2T failed\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxOutstandingR2T=%s\n", val);
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) {
SPDK_ERRLOG("Getval FirstBurstLength failed\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy FirstBurstLength=%s\n", val);
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) {
SPDK_ERRLOG("Getval MaxBurstLength failed\n");
return -1;
}
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "copy MaxBurstLength=%s\n", val);
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) {
SPDK_ERRLOG("Getval InitialR2T failed\n");
return -1;
@ -1199,7 +1199,7 @@ spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn)
SPDK_DEBUGLOG(SPDK_LOG_ISCSI, "set InitialR2T=0\n");
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) {
SPDK_ERRLOG("Getval ImmediateData failed\n");
return -1;

38
lib/iscsi/param.h
View File

@ -61,34 +61,34 @@ struct iscsi_param {
};
void
spdk_iscsi_param_free(struct iscsi_param *params);
iscsi_param_free(struct iscsi_param *params);
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
spdk_iscsi_param_del(struct iscsi_param **params, const char *key);
iscsi_param_del(struct iscsi_param **params, const char *key);
int
spdk_iscsi_param_add(struct iscsi_param **params, const char *key,
const char *val, const char *list, int type);
iscsi_param_add(struct iscsi_param **params, const char *key,
const char *val, const char *list, int type);
int
spdk_iscsi_param_set(struct iscsi_param *params, const char *key,
const char *val);
iscsi_param_set(struct iscsi_param *params, const char *key,
const char *val);
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
spdk_iscsi_parse_params(struct iscsi_param **params, const uint8_t *data,
int len, bool cbit_enabled, char **partial_parameter);
iscsi_parse_params(struct iscsi_param **params, const uint8_t *data,
int len, bool cbit_enabled, char **partial_parameter);
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
spdk_iscsi_param_eq_val(struct iscsi_param *params, const char *key,
const char *val);
iscsi_param_eq_val(struct iscsi_param *params, const char *key,
const char *val);
int spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
struct iscsi_param **params_p, uint8_t *data,
int alloc_len, int data_len);
int spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn);
int iscsi_negotiate_params(struct spdk_iscsi_conn *conn,
struct iscsi_param **params_p, uint8_t *data,
int alloc_len, int data_len);
int iscsi_copy_param2var(struct spdk_iscsi_conn *conn);
int spdk_iscsi_conn_params_init(struct iscsi_param **params);
int spdk_iscsi_sess_params_init(struct iscsi_param **params);
int iscsi_conn_params_init(struct iscsi_param **params);
int iscsi_sess_params_init(struct iscsi_param **params);
#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_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,
(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;
/* set default params */
rc = spdk_iscsi_sess_params_init(&sess.params);
rc = iscsi_sess_params_init(&sess.params);
CU_ASSERT(rc == 0);
rc = spdk_iscsi_param_set_int(sess.params, "FirstBurstLength",
sess.FirstBurstLength);
rc = iscsi_param_set_int(sess.params, "FirstBurstLength",
sess.FirstBurstLength);
CU_ASSERT(rc == 0);
rc = spdk_iscsi_param_set_int(sess.params, "MaxBurstLength",
sess.MaxBurstLength);
rc = iscsi_param_set_int(sess.params, "MaxBurstLength",
sess.MaxBurstLength);
CU_ASSERT(rc == 0);
rc = spdk_iscsi_param_set(sess.params, "InitialR2T",
sess.InitialR2T ? "Yes" : "No");
rc = iscsi_param_set(sess.params, "InitialR2T",
sess.InitialR2T ? "Yes" : "No");
CU_ASSERT(rc == 0);
conn.full_feature = 1;
conn.sess = &sess;
conn.MaxRecvDataSegmentLength = 65536;
rc = spdk_iscsi_conn_params_init(&conn.params);
rc = iscsi_conn_params_init(&conn.params);
CU_ASSERT(rc == 0);
/* construct the data */
@ -126,24 +126,24 @@ burst_length_param_negotation(int FirstBurstLength, int MaxBurstLength,
total++;
/* 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);
/* negotiate parameters */
rc = spdk_iscsi_negotiate_params(&conn, params_p,
data, 8192, rc);
rc = iscsi_negotiate_params(&conn, params_p,
data, 8192, rc);
CU_ASSERT(rc > 0);
rc = spdk_iscsi_copy_param2var(&conn);
rc = iscsi_copy_param2var(&conn);
CU_ASSERT(rc == 0);
CU_ASSERT(conn.sess->FirstBurstLength <= SPDK_ISCSI_FIRST_BURST_LENGTH);
CU_ASSERT(conn.sess->FirstBurstLength <= conn.sess->MaxBurstLength);
CU_ASSERT(conn.sess->MaxBurstLength <= SPDK_ISCSI_MAX_BURST_LENGTH);
CU_ASSERT(conn.sess->MaxOutstandingR2T == 1);
spdk_iscsi_param_free(sess.params);
spdk_iscsi_param_free(conn.params);
spdk_iscsi_param_free(*params_p);
iscsi_param_free(sess.params);
iscsi_param_free(conn.params);
iscsi_param_free(*params_p);
}
static void
@ -189,11 +189,11 @@ list_negotiation_test(void)
#define PARSE(strconst, partial_enabled, partial_text) \
data = strconst; \
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) \
{ \
const char *val = spdk_iscsi_param_get_val(params, key); \
const char *val = iscsi_param_get_val(params, key); \
CU_ASSERT(val != NULL); \
if (val != NULL) { \
CU_ASSERT(strcmp(val, expected_value) == 0); \
@ -201,7 +201,7 @@ list_negotiation_test(void)
}
#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
parse_valid_test(void)
@ -236,7 +236,7 @@ parse_valid_test(void)
memcpy(data, "CHAP_C", 6);
data[6] = '=';
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);
free(data);
@ -277,7 +277,7 @@ parse_valid_test(void)
partial_parameter = NULL;
data = "PartialKey=";
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_STRING_EQUAL(partial_parameter, "Partial");
EXPECT_NULL("PartialKey");
@ -286,7 +286,7 @@ parse_valid_test(void)
EXPECT_VAL("PartialKey", "Value");
CU_ASSERT_PTR_NULL(partial_parameter);
spdk_iscsi_param_free(params);
iscsi_param_free(params);
}
static void
@ -323,7 +323,7 @@ parse_invalid_test(void)
memcpy(data, "CHAP_C", 6);
data[6] = '=';
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);
CU_ASSERT(rc != 0);
EXPECT_NULL("CHAP_C");
@ -336,7 +336,7 @@ parse_invalid_test(void)
memset(data, 'A', len);
data[1] = '=';
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);
CU_ASSERT(rc != 0);
EXPECT_NULL("A");
@ -349,7 +349,7 @@ parse_invalid_test(void)
memset(data, 'A', len);
data[64] = '=';
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);
CU_ASSERT(rc != 0);
EXPECT_NULL("A");
@ -370,10 +370,10 @@ parse_invalid_test(void)
*/
data = "MaxRecvDataSegmentLength=81928";
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");
CU_ASSERT(rc == 0);
spdk_iscsi_param_free(params);
iscsi_param_free(params);
}
int