Commit 8f3b4a3a authored by Ziye Yang's avatar Ziye Yang Committed by Jim Harris
Browse files

nvme/tcp: Add a helper function nvme_tcp_pdu_set_data 



This function will be exteneded later for multiple SGL
support.

Change-Id: I1f6962ec03c72e335efaa311a12d3891312fcc53
Signed-off-by: default avatarZiye Yang <ziye.yang@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/449968


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Reviewed-by: default avatarwuzhouhui <wuzhouhui@kingsoft.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
parent 5a1dc444

include/spdk_internal/nvme_tcp.h

+7 −0
Original line number Diff line number Diff line
@@ -396,4 +396,11 @@ nvme_tcp_read_payload_data(struct spdk_sock *sock, struct nvme_tcp_pdu *pdu) 
	return nvme_tcp_readv_data(sock, iov, iovec_cnt);

}



static void

nvme_tcp_pdu_set_data(struct nvme_tcp_pdu *pdu, void *data, uint32_t data_len)

{

	pdu->data = data;

	pdu->data_len = data_len;

}



#endif /* SPDK_INTERNAL_NVME_TCP_H */

lib/nvme/nvme_tcp.c

+10 −16
Original line number Diff line number Diff line
@@ -594,9 +594,10 @@ nvme_tcp_qpair_cmd_send_complete(void *cb_arg) 


static void

nvme_tcp_pdu_set_data_buf(struct nvme_tcp_pdu *pdu,

			  struct nvme_tcp_req *tcp_req)

			  struct nvme_tcp_req *tcp_req,

			  uint32_t data_len)

{

	pdu->data = (void *)((uint64_t)tcp_req->buf + tcp_req->datao);

	nvme_tcp_pdu_set_data(pdu, (void *)((uint64_t)tcp_req->buf + tcp_req->datao), data_len);

}



static int
@@ -649,9 +650,7 @@ nvme_tcp_qpair_capsule_cmd_send(struct nvme_tcp_qpair *tqpair, 
	}



	tcp_req->datao = 0;

	nvme_tcp_pdu_set_data_buf(pdu, tcp_req);

	pdu->data_len = tcp_req->req->payload_size;



	nvme_tcp_pdu_set_data_buf(pdu, tcp_req, tcp_req->req->payload_size);

end:

	capsule_cmd->common.plen = plen;

	return nvme_tcp_qpair_write_pdu(tqpair, pdu, nvme_tcp_qpair_cmd_send_complete, NULL);
@@ -803,16 +802,14 @@ nvme_tcp_qpair_send_h2c_term_req(struct nvme_tcp_qpair *tqpair, struct nvme_tcp_ 
		DSET32(&h2c_term_req->fei, error_offset);

	}



	rsp_pdu->data = (uint8_t *)rsp_pdu->hdr.raw + h2c_term_req_hdr_len;



	copy_len = pdu->hdr.common.hlen;

	if (copy_len > SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE) {

		copy_len = SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE;

	}



	/* Copy the error info into the buffer */

	memcpy((uint8_t *)rsp_pdu->data, pdu->hdr.raw, copy_len);

	rsp_pdu->data_len = copy_len;

	memcpy((uint8_t *)rsp_pdu->hdr.raw + h2c_term_req_hdr_len, pdu->hdr.raw, copy_len);

	nvme_tcp_pdu_set_data(rsp_pdu, (uint8_t *)rsp_pdu->hdr.raw + h2c_term_req_hdr_len, copy_len);



	/* Contain the header len of the wrong received pdu */

	h2c_term_req->common.plen = h2c_term_req->common.hlen + copy_len;
@@ -1144,7 +1141,6 @@ nvme_tcp_c2h_term_req_hdr_handle(struct nvme_tcp_qpair *tqpair, 
	uint32_t error_offset = 0;

	enum spdk_nvme_tcp_term_req_fes fes;





	if (c2h_term_req->fes > SPDK_NVME_TCP_TERM_REQ_FES_INVALID_DATA_UNSUPPORTED_PARAMETER) {

		SPDK_ERRLOG("Fatal Error Stauts(FES) is unknown for c2h_term_req pdu=%p\n", pdu);

		fes = SPDK_NVME_TCP_TERM_REQ_FES_INVALID_HEADER_FIELD;
@@ -1153,8 +1149,8 @@ nvme_tcp_c2h_term_req_hdr_handle(struct nvme_tcp_qpair *tqpair, 
	}



	/* set the data buffer */

	pdu->data = (uint8_t *)pdu->hdr.raw + c2h_term_req->common.hlen;

	pdu->data_len = c2h_term_req->common.plen - c2h_term_req->common.hlen;

	nvme_tcp_pdu_set_data(pdu, (uint8_t *)pdu->hdr.raw + c2h_term_req->common.hlen,

			      c2h_term_req->common.plen - c2h_term_req->common.hlen);

	nvme_tcp_qpair_set_recv_state(tqpair, NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PAYLOAD);

	return;

end:
@@ -1209,8 +1205,7 @@ nvme_tcp_c2h_data_hdr_handle(struct nvme_tcp_qpair *tqpair, struct nvme_tcp_pdu 


	}



	nvme_tcp_pdu_set_data_buf(pdu, tcp_req);

	pdu->data_len = c2h_data->datal;

	nvme_tcp_pdu_set_data_buf(pdu, tcp_req, c2h_data->datal);

	pdu->ctx = tcp_req;



	nvme_tcp_qpair_set_recv_state(tqpair, NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PAYLOAD);
@@ -1243,7 +1238,6 @@ spdk_nvme_tcp_send_h2c_data(struct nvme_tcp_req *tcp_req) 


	rsp_pdu = &tcp_req->send_pdu;

	memset(rsp_pdu, 0, sizeof(*rsp_pdu));

	nvme_tcp_pdu_set_data_buf(rsp_pdu, tcp_req);

	h2c_data = &rsp_pdu->hdr.h2c_data;



	h2c_data->common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_H2C_DATA;
@@ -1253,7 +1247,7 @@ spdk_nvme_tcp_send_h2c_data(struct nvme_tcp_req *tcp_req) 
	h2c_data->datao = tcp_req->datao;



	h2c_data->datal = spdk_min(tcp_req->r2tl_remain, tqpair->maxh2cdata);

	rsp_pdu->data_len = h2c_data->datal;

	nvme_tcp_pdu_set_data_buf(rsp_pdu, tcp_req, h2c_data->datal);

	tcp_req->r2tl_remain -= h2c_data->datal;



	if (tqpair->host_hdgst_enable) {

lib/nvmf/tcp.c

+8 −12
Original line number Diff line number Diff line
@@ -1286,15 +1286,14 @@ spdk_nvmf_tcp_send_c2h_term_req(struct spdk_nvmf_tcp_qpair *tqpair, struct nvme_ 
		DSET32(&c2h_term_req->fei, error_offset);

	}



	rsp_pdu->data = (uint8_t *)rsp_pdu->hdr.raw + c2h_term_req_hdr_len;

	copy_len = pdu->hdr.common.hlen;

	if (copy_len > SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE) {

		copy_len = SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE;

	}



	/* Copy the error info into the buffer */

	memcpy((uint8_t *)rsp_pdu->data, pdu->hdr.raw, copy_len);

	rsp_pdu->data_len = copy_len;

	memcpy((uint8_t *)rsp_pdu->hdr.raw + c2h_term_req_hdr_len, pdu->hdr.raw, copy_len);

	nvme_tcp_pdu_set_data(rsp_pdu, (uint8_t *)rsp_pdu->hdr.raw + c2h_term_req_hdr_len, copy_len);



	/* Contain the header of the wrong received pdu */

	c2h_term_req->common.plen = c2h_term_req->common.hlen + copy_len;
@@ -1417,10 +1416,9 @@ spdk_nvmf_tcp_h2c_data_hdr_handle(struct spdk_nvmf_tcp_transport *ttransport, 
	}



	pdu->ctx = tcp_req;

	pdu->data_len = h2c_data->datal;

	iov_index = pdu->hdr.h2c_data.datao / ttransport->transport.opts.io_unit_size;

	pdu->data = tcp_req->req.iov[iov_index].iov_base + (pdu->hdr.h2c_data.datao %

			ttransport->transport.opts.io_unit_size);

	nvme_tcp_pdu_set_data(pdu, tcp_req->req.iov[iov_index].iov_base + (pdu->hdr.h2c_data.datao %

			      ttransport->transport.opts.io_unit_size), h2c_data->datal);

	spdk_nvmf_tcp_qpair_set_recv_state(tqpair, NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PAYLOAD);

	return;
@@ -1597,8 +1595,8 @@ spdk_nvmf_tcp_h2c_term_req_hdr_handle(struct spdk_nvmf_tcp_qpair *tqpair, 
	}



	/* set the data buffer */

	pdu->data = (uint8_t *)pdu->hdr.raw + h2c_term_req->common.hlen;

	pdu->data_len = h2c_term_req->common.plen - h2c_term_req->common.hlen;

	nvme_tcp_pdu_set_data(pdu, (uint8_t *)pdu->hdr.raw + h2c_term_req->common.hlen,

			      h2c_term_req->common.plen - h2c_term_req->common.hlen);

	spdk_nvmf_tcp_qpair_set_recv_state(tqpair, NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PAYLOAD);

	return;

end:
@@ -2260,8 +2258,7 @@ spdk_nvmf_tcp_send_c2h_data(struct spdk_nvmf_tcp_qpair *tqpair, 


	c2h_data->common.plen = plen;



	rsp_pdu->data = tcp_req->req.iov[iov_index].iov_base + offset;

	rsp_pdu->data_len = c2h_data->datal;

	nvme_tcp_pdu_set_data(rsp_pdu, tcp_req->req.iov[iov_index].iov_base + offset, c2h_data->datal);



	tcp_req->c2h_data_offset += c2h_data->datal;

	if (iov_index == (tcp_req->req.iovcnt - 1) && (tcp_req->c2h_data_offset == tcp_req->req.length)) {
@@ -2366,8 +2363,7 @@ spdk_nvmf_tcp_pdu_set_buf_from_req(struct spdk_nvmf_tcp_qpair *tqpair, 
		SPDK_DEBUGLOG(SPDK_LOG_NVMF_TCP, "Not need to send r2t for tcp_req(%p) on tqpair=%p\n", tcp_req,

			      tqpair);

		/* No need to send r2t, contained in the capsuled data */

		pdu->data = tcp_req->req.data;

		pdu->data_len = tcp_req->req.length;

		nvme_tcp_pdu_set_data(pdu, tcp_req->req.data, tcp_req->req.length);

		spdk_nvmf_tcp_qpair_set_recv_state(tqpair, NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PAYLOAD);

		spdk_nvmf_tcp_req_set_state(tcp_req, TCP_REQUEST_STATE_TRANSFERRING_HOST_TO_CONTROLLER);

	}