Line data Source code
1 : /**
2 : * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3 : * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 : * CANN Open Software License Agreement Version 2.0 (the "License").
5 : * Please refer to the License for details. You may not use this file except in compliance with the License.
6 : * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7 : * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 : * See LICENSE in the root of the software repository for the full text of the License.
9 : */
10 :
11 : #include <stdlib.h>
12 : #include <string.h>
13 : #include <arpa/inet.h>
14 : #include <unistd.h>
15 : #include <errno.h>
16 : #include "user_log.h"
17 : #include "ra_hdc.h"
18 : #include "securec.h"
19 : #include "ra.h"
20 : #include "ra_rs_comm.h"
21 : #include "ra_rs_err.h"
22 : #include "dl_hal_function.h"
23 : #include "ra_rdma_lite.h"
24 : #include "ra_hdc_lite.h"
25 : #include "ra_hdc_rdma_notify.h"
26 : #include "ra_hdc_rdma_verbs.h"
27 : #include "ra_hdc_rdma.h"
28 :
29 16 : STATIC int RaHdcNotifyBaseAddrInit(unsigned int notifyType, unsigned int phyId, unsigned long long **notifyVa)
30 : {
31 16 : unsigned long long moudleId = HCCP;
32 16 : unsigned int notifySize = 0;
33 : unsigned int logicId;
34 : int ret, drvRet;
35 :
36 16 : CHK_PRT_RETURN(notifyType != NOTIFY, hccp_err("[init][base_addr]notify_type[%u] error", notifyType), -EINVAL);
37 16 : ret = DlDrvDeviceGetIndexByPhyId(phyId, &logicId);
38 16 : CHK_PRT_RETURN(ret, hccp_err("[init][base_addr]drvDeviceGetIndexByPhyId failed, ret(%d), phyId(%u)", ret, phyId),
39 : ret);
40 :
41 15 : ret = DlHalNotifyGetInfo(logicId, 0, RA_NOTIFY_TYPE_TOTAL_SIZE, ¬ifySize);
42 15 : CHK_PRT_RETURN(ret, hccp_err("[init][base_addr]halNotifyGetInfo failed, ret(%d), logicId(%u)", ret, logicId), ret);
43 :
44 14 : ret = DlHalMemAlloc((void *)notifyVa, (unsigned long long)notifySize,
45 14 : RA_MEM_TYPE_HBM | (moudleId << MEM_MODULE_ID_BIT));
46 14 : CHK_PRT_RETURN(ret, hccp_err("[init][base_addr]halMemAlloc failed, ret(%d), phyId(%u)", ret, phyId), ret);
47 :
48 13 : hccp_info("notify info: size[%u]", notifySize);
49 13 : ret = RaHdcNotifyCfgSet(phyId, (uintptr_t)*notifyVa, notifySize);
50 13 : if (ret) {
51 4 : hccp_err("[init][base_addr]ra_hdc_notify_cfg_set failed, ret(%d), phyId(%u)", ret, phyId);
52 4 : goto free_mem;
53 : }
54 9 : return 0;
55 :
56 4 : free_mem:
57 4 : drvRet = DlHalMemFree((void *)*notifyVa);
58 4 : if (drvRet) {
59 1 : hccp_err("[init][base_addr]halMemFree failed! ret(%d)", drvRet);
60 : }
61 4 : return ret;
62 : }
63 :
64 10 : static void RaHdcGetQpHdc(struct RaRdmaHandle *rdmaHandle, int flag, int qpMode, unsigned int qpn,
65 : struct RaQpHandle *qpHdc)
66 : {
67 10 : qpHdc->phyId = rdmaHandle->rdevInfo.phyId;
68 10 : qpHdc->rdevIndex = rdmaHandle->rdevIndex;
69 10 : qpHdc->rdmaHandle = rdmaHandle;
70 10 : qpHdc->rdmaOps = rdmaHandle->rdmaOps;
71 10 : qpHdc->qpMode = qpMode;
72 10 : qpHdc->flag = flag;
73 10 : qpHdc->qpn = qpn;
74 10 : }
75 :
76 12 : STATIC int RaHdcCmdQpDestroy(struct RaQpHandle *qpHdc)
77 : {
78 : int ret;
79 12 : union OpQpDestroyData qpDestroyData = {0};
80 :
81 12 : qpDestroyData.txData.qpn = qpHdc->qpn;
82 12 : qpDestroyData.txData.phyId = qpHdc->phyId;
83 12 : qpDestroyData.txData.rdevIndex = qpHdc->rdevIndex;
84 12 : ret = RaHdcProcessMsg(RA_RS_QP_DESTROY, qpHdc->phyId, (char *)&qpDestroyData, sizeof(union OpQpDestroyData));
85 12 : if (ret) {
86 2 : hccp_err("[destroy][ra_hdc_qp]hdc_send_recv_pkt failed ret(%d) phyId(%u)", ret, qpHdc->phyId);
87 : }
88 :
89 12 : return ret;
90 : }
91 :
92 0 : STATIC int RaHdcCmdQpDestroyWithoutCQ(struct RaQpHandle *qpHdc)
93 : {
94 : int ret;
95 0 : union OpQpDestroyData qpDestroyData = {0};
96 :
97 0 : qpDestroyData.txData.qpn = qpHdc->qpn;
98 0 : qpDestroyData.txData.phyId = qpHdc->phyId;
99 0 : qpDestroyData.txData.rdevIndex = qpHdc->rdevIndex;
100 0 : ret = RaHdcProcessMsg(RA_RS_QP_DESTROY_WITHOUT_CQ, qpHdc->phyId, (char *)&qpDestroyData,
101 : sizeof(union OpQpDestroyData));
102 0 : if (ret) {
103 0 : hccp_err("[destroy][ra_hdc_qp]hdc_send_recv_pkt failed ret(%d) phyId(%u)", ret, qpHdc->phyId);
104 : }
105 :
106 0 : return ret;
107 : }
108 :
109 9 : int RaHdcQpCreate(struct RaRdmaHandle *rdmaHandle, int flag, int qpMode, void **qpHandle)
110 : {
111 9 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
112 9 : union OpQpCreateData qpCreateData = {0};
113 9 : struct RaQpHandle *qpHdc = NULL;
114 : struct rdma_lite_qp_cap cap;
115 : int ret;
116 :
117 9 : qpHdc = (struct RaQpHandle *)calloc(1, sizeof(struct RaQpHandle));
118 9 : CHK_PRT_RETURN(qpHdc == NULL, hccp_err("[create][ra_hdc_qp]qp_hdc calloc failed phyId(%u)", phyId), -ENOMEM);
119 :
120 8 : qpCreateData.txData.phyId = phyId;
121 8 : qpCreateData.txData.rdevIndex = rdmaHandle->rdevIndex;
122 8 : qpCreateData.txData.flag = flag;
123 8 : qpCreateData.txData.qpMode = qpMode;
124 8 : qpCreateData.txData.memAlign = rdmaHandle->supportLite;
125 :
126 8 : ret = RaHdcProcessMsg(RA_RS_QP_CREATE, phyId, (char *)&qpCreateData, sizeof(union OpQpCreateData));
127 8 : if (ret) {
128 1 : hccp_err("[create][ra_hdc_qp]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
129 1 : free(qpHdc);
130 1 : qpHdc = NULL;
131 1 : return ret;
132 : }
133 :
134 7 : RaHdcGetQpHdc(rdmaHandle, flag, qpMode, qpCreateData.rxData.qpn, qpHdc);
135 7 : qpHdc->psn = qpCreateData.rxData.psn;
136 7 : qpHdc->gidIdx = qpCreateData.rxData.gidIdx;
137 :
138 7 : cap.max_inline_data = QP_DEFAULT_MAX_CAP_INLINE_DATA;
139 7 : cap.max_send_sge = QP_DEFAULT_MIN_CAP_SEND_SGE;
140 7 : cap.max_recv_sge = QP_DEFAULT_MIN_CAP_RECV_SGE;
141 7 : cap.max_send_wr = RA_QP_32K_DEPTH;
142 7 : cap.max_recv_wr = RA_QP_128_DEPTH;
143 7 : ret = RaHdcLiteQpCreate(rdmaHandle, qpHdc, &cap);
144 7 : if (ret) {
145 0 : (void)RaHdcCmdQpDestroy(qpHdc);
146 0 : hccp_err("[create][ra_hdc_qp]ra_hdc_lite_qp_create failed ret(%d) phyId(%u)", ret, phyId);
147 0 : free(qpHdc);
148 0 : qpHdc = NULL;
149 0 : return ret;
150 : }
151 :
152 7 : qpHdc->sqDepth = cap.max_send_wr;
153 7 : *qpHandle = qpHdc;
154 :
155 7 : return 0;
156 : }
157 :
158 1 : int RaHdcQpCreateWithAttrs(struct RaRdmaHandle *rdmaHandle, struct QpExtAttrs *extAttrs, void **qpHandle)
159 : {
160 1 : int flag = (extAttrs->qpAttr.qp_type == IBV_QPT_RC) ? 0 : 1;
161 1 : union OpQpCreateWithAttrsData opData = {0};
162 1 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
163 1 : struct RaQpHandle *qpHdc = NULL;
164 : struct rdma_lite_qp_cap cap;
165 : int ret;
166 :
167 1 : qpHdc = (struct RaQpHandle *)calloc(1, sizeof(struct RaQpHandle));
168 1 : CHK_PRT_RETURN(qpHdc == NULL, hccp_err("[create][ra_hdc_qp_with_attrs]qp_hdc calloc failed phyId(%u)", phyId),
169 : -ENOMEM);
170 :
171 1 : opData.txData.phyId = phyId;
172 1 : opData.txData.rdevIndex = rdmaHandle->rdevIndex;
173 1 : ret = memcpy_s(&opData.txData.extAttrs, sizeof(struct QpExtAttrs), extAttrs, sizeof(struct QpExtAttrs));
174 1 : if (ret) {
175 0 : hccp_err("[create][ra_hdc_qp_with_attrs]memcpy_s for ext_attrs failed, ret:%d", ret);
176 0 : ret = -ESAFEFUNC;
177 0 : goto out;
178 : }
179 :
180 1 : opData.txData.extAttrs.memAlign = rdmaHandle->supportLite;
181 1 : ret = RaHdcProcessMsg(RA_RS_QP_CREATE_WITH_ATTRS, phyId, (char *)&opData, sizeof(union OpQpCreateWithAttrsData));
182 1 : if (ret) {
183 0 : hccp_err("[create][ra_hdc_qp_with_attrs]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
184 0 : goto out;
185 : }
186 :
187 1 : RaHdcGetQpHdc(rdmaHandle, flag, extAttrs->qpMode, opData.rxData.qpn, qpHdc);
188 1 : qpHdc->psn = opData.rxData.psn;
189 1 : qpHdc->gidIdx = opData.rxData.gidIdx;
190 :
191 1 : cap.max_inline_data = extAttrs->qpAttr.cap.max_inline_data;
192 1 : cap.max_send_sge = extAttrs->qpAttr.cap.max_send_sge;
193 1 : cap.max_recv_sge = extAttrs->qpAttr.cap.max_recv_sge;
194 1 : cap.max_send_wr = extAttrs->qpAttr.cap.max_send_wr;
195 1 : cap.max_recv_wr = extAttrs->qpAttr.cap.max_recv_wr;
196 1 : ret = RaHdcLiteQpCreate(rdmaHandle, qpHdc, &cap);
197 1 : if (ret) {
198 0 : (void)RaHdcCmdQpDestroy(qpHdc);
199 0 : hccp_err("[create][ra_hdc_qp_with_attrs]ra_hdc_lite_qp_create failed ret(%d) phyId(%u)", ret, phyId);
200 0 : goto out;
201 : }
202 :
203 1 : qpHdc->sqSigAll = extAttrs->qpAttr.sq_sig_all;
204 1 : qpHdc->typicalQpAttr.udpSport = extAttrs->udpSport;
205 1 : qpHdc->sqDepth = cap.max_send_wr;
206 1 : *qpHandle = qpHdc;
207 1 : return 0;
208 :
209 0 : out:
210 0 : free(qpHdc);
211 0 : qpHdc = NULL;
212 0 : return ret;
213 : }
214 :
215 0 : int RaHdcQpCreateWithCQWithAttrs(struct RaRdmaHandle *rdmaHandle, struct QpExtAttrs *extAttrs, unsigned int sendCqn,
216 : unsigned int recvCqn, void **qpHandle)
217 : {
218 0 : int flag = (extAttrs->qpAttr.qp_type == IBV_QPT_RC) ? 0 : 1;
219 0 : union OpQpCreateWithCQWithAttrsData opData = {0};
220 0 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
221 0 : struct RaQpHandle *qpHdc = NULL;
222 : struct rdma_lite_qp_cap cap;
223 : int ret;
224 :
225 0 : qpHdc = (struct RaQpHandle *)calloc(1, sizeof(struct RaQpHandle));
226 0 : CHK_PRT_RETURN(qpHdc == NULL, hccp_err("[create][ra_hdc_qp_with_cq_attrs]qp_hdc calloc failed phyId(%u)", phyId),
227 : -ENOMEM);
228 :
229 0 : opData.txData.phyId = phyId;
230 0 : opData.txData.rdevIndex = rdmaHandle->rdevIndex;
231 0 : opData.txData.sendCqn = sendCqn;
232 0 : opData.txData.recvCqn = recvCqn;
233 0 : ret = memcpy_s(&opData.txData.extAttrs, sizeof(struct QpExtAttrs), extAttrs, sizeof(struct QpExtAttrs));
234 0 : if (ret) {
235 0 : hccp_err("[create][ra_hdc_qp_with_cq_attrs]memcpy_s for ext_attrs failed, ret:%d", ret);
236 0 : ret = -ESAFEFUNC;
237 0 : goto out;
238 : }
239 :
240 0 : opData.txData.extAttrs.memAlign = rdmaHandle->supportLite;
241 0 : ret = RaHdcProcessMsg(RA_RS_QP_CREATE_WITH_CQ_WITH_ATTRS, phyId, (char *)&opData,
242 : sizeof(union OpQpCreateWithCQWithAttrsData));
243 0 : if (ret) {
244 0 : hccp_err("[create][ra_hdc_qp_with_cq_attrs]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
245 0 : goto out;
246 : }
247 :
248 0 : RaHdcGetQpHdc(rdmaHandle, flag, extAttrs->qpMode, opData.rxData.qpn, qpHdc);
249 0 : qpHdc->psn = opData.rxData.psn;
250 0 : qpHdc->gidIdx = opData.rxData.gidIdx;
251 :
252 0 : cap.max_inline_data = extAttrs->qpAttr.cap.max_inline_data;
253 0 : cap.max_send_wr = extAttrs->qpAttr.cap.max_send_wr;
254 0 : cap.max_recv_wr = extAttrs->qpAttr.cap.max_recv_wr;
255 0 : cap.max_send_sge = extAttrs->qpAttr.cap.max_send_sge;
256 0 : cap.max_recv_sge = extAttrs->qpAttr.cap.max_recv_sge;
257 0 : ret = RaHdcLiteQpCreateWithCQ(rdmaHandle, qpHdc, &cap, RaHdcLiteFindTypicalCq(rdmaHandle, sendCqn),
258 : RaHdcLiteFindTypicalCq(rdmaHandle, recvCqn), sendCqn, recvCqn);
259 0 : if (ret) {
260 0 : (void)RaHdcCmdQpDestroyWithoutCQ(qpHdc);
261 0 : hccp_err("[create][ra_hdc_qp_with_cq_attrs]ra_hdc_lite_qp_create failed ret(%d) phyId(%u)", ret, phyId);
262 0 : goto out;
263 : }
264 :
265 0 : qpHdc->sqDepth = cap.max_send_wr;
266 0 : qpHdc->typicalQpAttr.udpSport = extAttrs->udpSport;
267 0 : qpHdc->sqSigAll = extAttrs->qpAttr.sq_sig_all;
268 0 : *qpHandle = qpHdc;
269 0 : return 0;
270 :
271 0 : out:
272 0 : free(qpHdc);
273 0 : qpHdc = NULL;
274 0 : return ret;
275 : }
276 :
277 0 : int RaHdcAiQpCreate(struct RaRdmaHandle *rdmaHandle, struct QpExtAttrs *extAttrs, struct AiQpInfo *info,
278 : void **qpHandle)
279 : {
280 : #define AI_QP_DEFAULT_GID_IDX 3U
281 0 : int flag = extAttrs->qpAttr.qp_type == IBV_QPT_RC ? 0 : 1;
282 0 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
283 0 : union OpAiQpCreateData qpCreateData = {0};
284 0 : struct RaQpHandle *qpHdc = NULL;
285 0 : int qpMode = extAttrs->qpMode;
286 : int ret;
287 :
288 0 : qpHdc = (struct RaQpHandle *)calloc(1, sizeof(struct RaQpHandle));
289 0 : CHK_PRT_RETURN(qpHdc == NULL, hccp_err("[create][ra_hdc_ai_qp]qp_hdc calloc failed phyId(%u)", phyId), -ENOMEM);
290 :
291 0 : qpCreateData.txData.phyId = phyId;
292 0 : qpCreateData.txData.rdevIndex = rdmaHandle->rdevIndex;
293 0 : ret = memcpy_s(&qpCreateData.txData.extAttrs, sizeof(struct QpExtAttrs), extAttrs, sizeof(struct QpExtAttrs));
294 0 : if (ret) {
295 0 : hccp_err("[create][ra_hdc_ai_qp]memcpy_s for ext_attrs failed, ret:%d", ret);
296 0 : free(qpHdc);
297 0 : qpHdc = NULL;
298 0 : return -ESAFEFUNC;
299 : }
300 :
301 0 : ret = RaHdcProcessMsg(RA_RS_AI_QP_CREATE, phyId, (char *)&qpCreateData, sizeof(union OpAiQpCreateData));
302 0 : if (ret) {
303 0 : hccp_err("[create][ra_hdc_ai_qp]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
304 0 : free(qpHdc);
305 0 : qpHdc = NULL;
306 0 : return ret;
307 : }
308 :
309 0 : RaHdcGetQpHdc(rdmaHandle, flag, qpMode, qpCreateData.rxData.qpn, qpHdc);
310 0 : qpHdc->psn = qpCreateData.rxData.psn;
311 : // set a default gid_idx due to compatibility issue, rs will refresh it if it is different
312 0 : qpHdc->gidIdx = AI_QP_DEFAULT_GID_IDX;
313 0 : info->aiQpAddr = qpCreateData.rxData.aiQpAddr;
314 0 : info->sqIndex = qpCreateData.rxData.sqIndex;
315 0 : info->dbIndex = qpCreateData.rxData.dbIndex;
316 0 : qpHdc->typicalQpAttr.udpSport = extAttrs->udpSport;
317 0 : *qpHandle = qpHdc;
318 :
319 0 : return 0;
320 : }
321 :
322 1 : int RaHdcAiQpCreateWithAttrs(struct RaRdmaHandle *rdmaHandle, struct QpExtAttrs *extAttrs, struct AiQpInfo *info,
323 : void **qpHandle)
324 : {
325 1 : int flag = extAttrs->qpAttr.qp_type == IBV_QPT_RC ? 0 : 1;
326 1 : union OpAiQpCreateWithAttrsData qpCreateData = {0};
327 1 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
328 1 : struct RaQpHandle *qpHdc = NULL;
329 1 : int qpMode = extAttrs->qpMode;
330 : int ret;
331 :
332 1 : qpHdc = (struct RaQpHandle *)calloc(1, sizeof(struct RaQpHandle));
333 1 : CHK_PRT_RETURN(qpHdc == NULL, hccp_err("[create][ra_hdc_ai_qp]qp_hdc calloc failed phyId(%u)", phyId), -ENOMEM);
334 :
335 1 : qpCreateData.txData.phyId = phyId;
336 1 : qpCreateData.txData.rdevIndex = rdmaHandle->rdevIndex;
337 1 : ret = memcpy_s(&qpCreateData.txData.extAttrs, sizeof(struct QpExtAttrs), extAttrs, sizeof(struct QpExtAttrs));
338 1 : if (ret) {
339 0 : hccp_err("[create][ra_hdc_ai_qp]memcpy_s for ext_attrs failed, ret:%d", ret);
340 0 : free(qpHdc);
341 0 : qpHdc = NULL;
342 0 : return -ESAFEFUNC;
343 : }
344 :
345 1 : ret = RaHdcProcessMsg(RA_RS_AI_QP_CREATE_WITH_ATTRS, phyId, (char *)&qpCreateData,
346 : sizeof(union OpAiQpCreateWithAttrsData));
347 1 : if (ret) {
348 0 : hccp_err("[create][ra_hdc_ai_qp]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
349 0 : free(qpHdc);
350 0 : qpHdc = NULL;
351 0 : return ret;
352 : }
353 :
354 1 : qpHdc->typicalQpAttr.udpSport = extAttrs->udpSport;
355 1 : RaHdcGetQpHdc(rdmaHandle, flag, qpMode, qpCreateData.rxData.qpn, qpHdc);
356 1 : qpHdc->gidIdx = qpCreateData.rxData.gidIdx;
357 1 : qpHdc->psn = qpCreateData.rxData.psn;
358 1 : info->aiQpAddr = qpCreateData.rxData.aiQpAddr;
359 1 : info->sqIndex = qpCreateData.rxData.sqIndex;
360 1 : info->dbIndex = qpCreateData.rxData.dbIndex;
361 1 : info->aiScqAddr = qpCreateData.rxData.aiScqAddr;
362 1 : info->aiRcqAddr = qpCreateData.rxData.aiRcqAddr;
363 1 : (void)memcpy_s(&info->dataPlaneInfo, sizeof(struct AiDataPlaneInfo), &qpCreateData.rxData.dataPlaneInfo,
364 : sizeof(struct AiDataPlaneInfo));
365 1 : *qpHandle = qpHdc;
366 :
367 1 : return 0;
368 : }
369 :
370 1 : int RaHdcTypicalQpCreate(struct RaRdmaHandle *rdmaHandle, int flag, int qpMode, struct TypicalQp *qpInfo,
371 : void **qpHandle)
372 : {
373 1 : union OpTypicalQpCreateData qpCreateData = {0};
374 1 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
375 1 : struct RaQpHandle *qpHdc = NULL;
376 : struct rdma_lite_qp_cap cap;
377 : int ret;
378 :
379 1 : qpHdc = (struct RaQpHandle *)calloc(1, sizeof(struct RaQpHandle));
380 1 : CHK_PRT_RETURN(qpHdc == NULL, hccp_err("[create][ra_hdc_typical_qp]qp_hdc calloc failed phyId(%u)", phyId),
381 : -ENOMEM);
382 :
383 1 : qpCreateData.txData.phyId = phyId;
384 1 : qpCreateData.txData.rdevIndex = rdmaHandle->rdevIndex;
385 1 : qpCreateData.txData.flag = flag;
386 1 : qpCreateData.txData.qpMode = qpMode;
387 1 : qpCreateData.txData.memAlign = rdmaHandle->supportLite;
388 :
389 1 : ret = RaHdcProcessMsg(RA_RS_TYPICAL_QP_CREATE, phyId, (char *)&qpCreateData, sizeof(union OpTypicalQpCreateData));
390 1 : if (ret) {
391 0 : hccp_err("[create][ra_hdc_typical_qp]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
392 0 : free(qpHdc);
393 0 : qpHdc = NULL;
394 0 : return ret;
395 : }
396 :
397 1 : qpInfo->gidIdx = qpCreateData.rxData.gidIdx;
398 1 : qpInfo->psn = qpCreateData.rxData.psn;
399 1 : qpInfo->qpn = qpCreateData.rxData.qpn;
400 1 : (void)memcpy_s(qpInfo->gid, HCCP_GID_RAW_LEN, qpCreateData.rxData.gid.raw, HCCP_GID_RAW_LEN);
401 :
402 1 : RaHdcGetQpHdc(rdmaHandle, flag, qpMode, qpInfo->qpn, qpHdc);
403 1 : qpHdc->psn = qpCreateData.rxData.psn;
404 1 : qpHdc->gidIdx = qpCreateData.rxData.gidIdx;
405 :
406 1 : cap.max_inline_data = QP_DEFAULT_MAX_CAP_INLINE_DATA;
407 1 : cap.max_send_sge = QP_DEFAULT_MIN_CAP_SEND_SGE;
408 1 : cap.max_recv_sge = QP_DEFAULT_MIN_CAP_RECV_SGE;
409 1 : cap.max_send_wr = RA_QP_32K_DEPTH;
410 1 : cap.max_recv_wr = RA_QP_128_DEPTH;
411 1 : ret = RaHdcLiteQpCreate(rdmaHandle, qpHdc, &cap);
412 1 : if (ret) {
413 0 : (void)RaHdcCmdQpDestroy(qpHdc);
414 0 : hccp_err("[create][ra_hdc_typical_qp]ra_hdc_lite_qp_create failed ret(%d) phyId(%u)", ret, phyId);
415 0 : free(qpHdc);
416 0 : qpHdc = NULL;
417 0 : return ret;
418 : }
419 :
420 1 : qpHdc->sqDepth = cap.max_send_wr;
421 1 : *qpHandle = qpHdc;
422 :
423 1 : return 0;
424 : }
425 :
426 0 : int RaHdcTypicalCqCreate(struct RaRdmaHandle *rdmaHandle, unsigned int cqDepth, unsigned int *cqn, void **cqHandle)
427 : {
428 0 : union OpTypicalCqCreateData cqCreateData = {0};
429 0 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
430 0 : struct RaTypicalCqHandle *cqHdc = NULL;
431 : int ret;
432 :
433 0 : cqHdc = (struct RaTypicalCqHandle *)calloc(1, sizeof(struct RaTypicalCqHandle));
434 0 : CHK_PRT_RETURN(cqHdc == NULL, hccp_err("[create][ra_hdc_typical_cq]cq_hdc calloc failed phyId(%u)", phyId),
435 : -ENOMEM);
436 :
437 0 : cqCreateData.txData.phyId = phyId;
438 0 : cqCreateData.txData.rdevIndex = rdmaHandle->rdevIndex;
439 0 : cqCreateData.txData.cqDepth = cqDepth;
440 :
441 0 : ret = RaHdcProcessMsg(RA_RS_TYPICAL_CQ_CREATE, phyId, (char *)&cqCreateData, sizeof(union OpTypicalCqCreateData));
442 0 : if (ret) {
443 0 : hccp_err("[create][ra_hdc_typical_cq]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
444 0 : free(cqHdc);
445 0 : cqHdc = NULL;
446 0 : return ret;
447 : }
448 0 : hccp_info("RaHdcProcessMsg RA_RS_TYPICAL_CQ_CREATE Done");
449 :
450 0 : *cqn = cqCreateData.rxData.cqn;
451 :
452 0 : cqHdc->cqn = *cqn;
453 0 : cqHdc->phyId = phyId;
454 0 : cqHdc->rdevIndex = rdmaHandle->rdevIndex;
455 0 : cqHdc->rdmaHandle = rdmaHandle;
456 0 : cqHdc->rdmaOps = rdmaHandle->rdmaOps;
457 :
458 0 : if (rdmaHandle->supportLite != 0) {
459 0 : struct rdma_lite_cq *liteCq = NULL;
460 0 : ret = RaHdcLiteCqCreate(rdmaHandle, cqDepth, &cqCreateData, &liteCq);
461 0 : if (ret) {
462 0 : union OpTypicalCqDestroyData destroyData = {0};
463 0 : hccp_err("[create][ra_hdc_typical_cq]ra_hdc_lite_cq_create failed ret(%d) phyId(%u)", ret, phyId);
464 0 : destroyData.txData.cqn = cqHdc->cqn;
465 0 : destroyData.txData.phyId = cqHdc->phyId;
466 0 : destroyData.txData.rdevIndex = cqHdc->rdevIndex;
467 0 : (void)RaHdcProcessMsg(RA_RS_TYPICAL_CQ_DESTROY, phyId, (char *)&destroyData,
468 : sizeof(union OpTypicalCqDestroyData));
469 0 : free(cqHdc);
470 0 : cqHdc = NULL;
471 0 : return ret;
472 : }
473 0 : cqHdc->liteCq = liteCq;
474 : }
475 :
476 0 : *cqHandle = cqHdc;
477 :
478 0 : return 0;
479 : }
480 :
481 0 : int RaHdcTypicalCqDestroy(struct RaRdmaHandle *rdmaHandle, unsigned int cqn, void *cqHandle)
482 : {
483 0 : struct RaTypicalCqHandle *cqHdc = (struct RaTypicalCqHandle *)cqHandle;
484 0 : union OpTypicalCqDestroyData destroyData = {0};
485 0 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
486 : int ret;
487 :
488 0 : if (cqHdc == NULL) {
489 0 : hccp_err("[destroy][ra_hdc_typical_cq]cq handle is NULL phyId(%u)", phyId);
490 0 : return -EINVAL;
491 : }
492 :
493 0 : if (cqHdc->liteCq != NULL) {
494 0 : RaHdcLiteRemoveTypicalCq(rdmaHandle, cqHdc->cqn);
495 0 : (void)RaRdmaLiteDestroyCq(cqHdc->liteCq);
496 0 : cqHdc->liteCq = NULL;
497 : }
498 :
499 0 : destroyData.txData.phyId = phyId;
500 0 : destroyData.txData.rdevIndex = rdmaHandle->rdevIndex;
501 0 : destroyData.txData.cqn = cqn;
502 0 : ret = RaHdcProcessMsg(RA_RS_TYPICAL_CQ_DESTROY, phyId, (char *)&destroyData, sizeof(union OpTypicalCqDestroyData));
503 0 : if (ret) {
504 0 : hccp_err("[destroy][ra_hdc_typical_cq]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
505 : }
506 :
507 0 : free(cqHdc);
508 0 : cqHdc = NULL;
509 0 : return ret;
510 : }
511 :
512 12 : int RaHdcQpDestroy(struct RaQpHandle *qpHdc)
513 : {
514 : int ret;
515 :
516 12 : RaHdcLiteQpDestroy(qpHdc);
517 12 : ret = RaHdcCmdQpDestroy(qpHdc);
518 12 : if (ret) {
519 2 : hccp_err("[destroy][ra_hdc_qp]ra_hdc_cmd_qp_destroy failed ret(%d) phyId(%u)", ret, qpHdc->phyId);
520 : }
521 :
522 12 : free(qpHdc);
523 12 : qpHdc = NULL;
524 12 : return ret;
525 : }
526 :
527 0 : int RaHdcQpDestroyWithoutCQ(struct RaQpHandle *qpHdc)
528 : {
529 : int ret;
530 :
531 0 : RaHdcLiteQpDestroyWithoutCQ(qpHdc);
532 0 : ret = RaHdcCmdQpDestroyWithoutCQ(qpHdc);
533 0 : if (ret) {
534 0 : hccp_err("[destroy][ra_hdc_qp]ra_hdc_cmd_qp_destroy_without_cq failed ret(%d) phyId(%u)", ret, qpHdc->phyId);
535 : }
536 :
537 0 : free(qpHdc);
538 0 : qpHdc = NULL;
539 0 : return ret;
540 : }
541 :
542 3 : int RaHdcGetQpStatus(struct RaQpHandle *qpHdc, int *status)
543 : {
544 3 : union OpQpStatusData qpStatusData = {0};
545 3 : union OpQpInfoData qpInfoData = {0};
546 3 : unsigned int interfaceVersion = 0;
547 : int ret;
548 :
549 3 : ret = RaHdcGetInterfaceVersion(qpHdc->phyId, RA_RS_QP_INFO, &interfaceVersion);
550 3 : if (ret != 0) {
551 0 : hccp_warn("[get][ra_hdc_qp_status]get interface version not success ret(%d) phyId(%u)", ret, qpHdc->phyId);
552 0 : interfaceVersion = 0;
553 : }
554 :
555 3 : if (interfaceVersion >= RA_RS_OPCODE_BASE_VERSION) {
556 1 : qpInfoData.txData.qpn = qpHdc->qpn;
557 1 : qpInfoData.txData.phyId = qpHdc->phyId;
558 1 : qpInfoData.txData.rdevIndex = qpHdc->rdevIndex;
559 1 : ret = RaHdcProcessMsg(RA_RS_QP_INFO, qpHdc->phyId, (char *)&qpInfoData, sizeof(union OpQpInfoData));
560 1 : CHK_PRT_RETURN(ret,
561 : hccp_err("[get][ra_hdc_qp_status]ra hdc message process failed ret(%d) phyId(%u)", ret, qpHdc->phyId), ret);
562 1 : *status = qpInfoData.rxData.status;
563 1 : qpHdc->typicalQpAttr.udpSport = qpInfoData.rxData.udpSport;
564 : } else {
565 2 : qpStatusData.txData.qpn = qpHdc->qpn;
566 2 : qpStatusData.txData.phyId = qpHdc->phyId;
567 2 : qpStatusData.txData.rdevIndex = qpHdc->rdevIndex;
568 2 : ret = RaHdcProcessMsg(RA_RS_QP_STATUS, qpHdc->phyId, (char *)&qpStatusData, sizeof(union OpQpStatusData));
569 2 : CHK_PRT_RETURN(ret,
570 : hccp_err("[get][ra_hdc_qp_status]ra hdc message process failed ret(%d) phyId(%u)", ret, qpHdc->phyId), ret);
571 1 : *status = qpStatusData.rxData.status;
572 : }
573 :
574 2 : return RaHdcLiteGetConnectedInfo(qpHdc);
575 : }
576 :
577 1 : int RaHdcTypicalQpModify(struct RaQpHandle *qpHdc, struct TypicalQp *localQpInfo, struct TypicalQp *remoteQpInfo)
578 : {
579 1 : union OpTypicalQpModifyData qpModifyData = {0};
580 1 : unsigned int phyId = qpHdc->phyId;
581 : int ret;
582 :
583 1 : qpModifyData.txData.phyId = phyId;
584 1 : qpModifyData.txData.rdevIndex = qpHdc->rdevIndex;
585 1 : ret = memcpy_s(&(qpModifyData.txData.localQpInfo), sizeof(struct TypicalQp), localQpInfo, sizeof(struct TypicalQp));
586 1 : CHK_PRT_RETURN(ret != 0, hccp_err("[modify]memcpy_s local_qp_info failed, phyId[%u] ret[%d]", phyId, ret),
587 : -ESAFEFUNC);
588 1 : ret = memcpy_s(&(qpModifyData.txData.remoteQpInfo), sizeof(struct TypicalQp), remoteQpInfo,
589 : sizeof(struct TypicalQp));
590 1 : CHK_PRT_RETURN(ret != 0, hccp_err("[modify]memcpy_s remote_qp_info failed, phyId[%u] ret[%d]", phyId, ret),
591 : -ESAFEFUNC);
592 :
593 1 : ret = RaHdcProcessMsg(RA_RS_TYPICAL_QP_MODIFY, phyId, (char *)&qpModifyData, sizeof(union OpTypicalQpModifyData));
594 1 : CHK_PRT_RETURN(ret != 0, hccp_err("[modify][modify_qp]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId),
595 : ret);
596 :
597 1 : qpHdc->typicalQpAttr.udpSport = qpModifyData.rxData.udpSport;
598 1 : qpHdc->typicalQpAttr.pathMtu = qpModifyData.rxData.pathMtu;
599 1 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
600 1 : ret = RaRdmaLiteSetQpSl(qpHdc->liteQp, localQpInfo->sl);
601 1 : CHK_PRT_RETURN(ret != 0,
602 : hccp_err("[modify][modify_qp]ra_rdma_lite_set_qp_sl sl(%u) failed ret(%d) phyId(%u)", localQpInfo->sl, ret,
603 : phyId),
604 : ret);
605 : }
606 1 : return 0;
607 : }
608 :
609 3 : int RaHdcQpConnectAsync(struct RaQpHandle *qpHdc, const void *sockHandle)
610 : {
611 3 : union OpQpConnectData qpConnectData = {0};
612 : int ret;
613 :
614 3 : qpConnectData.txData.qpn = qpHdc->qpn;
615 3 : qpConnectData.txData.fd = (unsigned int)((const struct SocketHdcInfo *)sockHandle)->fd;
616 3 : qpConnectData.txData.phyId = qpHdc->phyId;
617 3 : qpConnectData.txData.rdevIndex = qpHdc->rdevIndex;
618 3 : ret = RaHdcProcessMsg(RA_RS_QP_CONNECT, qpHdc->phyId, (char *)&qpConnectData, sizeof(union OpQpConnectData));
619 3 : CHK_PRT_RETURN(ret,
620 : hccp_err("[connect_async][ra_hdc_qp]ra hdc message process failed ret(%d) phyId(%u)", ret, qpHdc->phyId), ret);
621 :
622 2 : return 0;
623 : }
624 :
625 1 : static void RaHdcSendDataInit(union OpSendWrData *sendWrData, struct RaQpHandle *qpHdc, struct SendWr *wr)
626 : {
627 1 : sendWrData->txData.phyId = qpHdc->phyId;
628 1 : sendWrData->txData.rdevIndex = qpHdc->rdevIndex;
629 1 : sendWrData->txData.qpn = qpHdc->qpn;
630 1 : sendWrData->txData.bufNum = wr->bufNum;
631 1 : sendWrData->txData.dstAddr = wr->dstAddr;
632 1 : sendWrData->txData.op = wr->op;
633 1 : sendWrData->txData.sendFlags = wr->sendFlag;
634 1 : }
635 :
636 1 : int RaHdcSendWr(struct RaQpHandle *qpHdc, struct SendWr *wr, struct SendWrRsp *opRsp)
637 : {
638 1 : union OpSendWrData sendWrData = {0};
639 1 : struct LiteSendWr liteWr = {0};
640 : int ret;
641 :
642 1 : if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
643 0 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
644 0 : liteWr.wr = *wr;
645 0 : return RaHdcLiteSendWr(qpHdc, &liteWr, opRsp, HDC_LITE_DEFAULT_WR_ID);
646 : }
647 : }
648 :
649 1 : RaHdcSendDataInit(&sendWrData, qpHdc, wr);
650 :
651 1 : ret = memcpy_s(sendWrData.txData.memList, (sizeof(struct SgList) * MAX_SGE_NUM), wr->bufList,
652 1 : (sizeof(struct SgList) * wr->bufNum));
653 1 : CHK_PRT_RETURN(ret,
654 : hccp_err("[send][ra_hdc_wr]memcpy_s for mem_list failed, ret(%d), phyId(%u)", ret, qpHdc->phyId), -ESAFEFUNC);
655 :
656 1 : ret = RaHdcProcessMsg(RA_RS_SEND_WR, qpHdc->phyId, (char *)&sendWrData, sizeof(union OpSendWrData));
657 1 : if (ret) {
658 0 : if (ret != -ENOENT) {
659 0 : hccp_err("[send][ra_hdc_wr]ra hdc message process failed ret(%d), phyId(%u)", ret, qpHdc->phyId);
660 : }
661 0 : return ret;
662 : }
663 :
664 1 : if (qpHdc->qpMode == RA_RS_GDR_TMPL_QP_MODE) {
665 0 : opRsp->wqeTmp = sendWrData.rxData.wrRsp.wqeTmp;
666 1 : } else if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_GDR_ASYN_QP_MODE ||
667 1 : qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
668 0 : opRsp->db = sendWrData.rxData.wrRsp.db;
669 : }
670 :
671 1 : return ret;
672 : }
673 :
674 0 : int RaHdcSendWrV2(struct RaQpHandle *qpHdc, struct SendWrV2 *wr, struct SendWrRsp *opRsp)
675 : {
676 0 : struct LiteSendWr liteWr = {0};
677 :
678 0 : if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
679 0 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
680 0 : liteWr.wr.bufList = wr->bufList;
681 0 : liteWr.wr.bufNum = wr->bufNum;
682 0 : liteWr.wr.dstAddr = wr->dstAddr;
683 0 : liteWr.wr.op = wr->op;
684 0 : liteWr.wr.rkey = wr->rkey;
685 0 : liteWr.wr.sendFlag = wr->sendFlag;
686 0 : liteWr.aux = wr->aux;
687 0 : liteWr.ext = wr->ext;
688 0 : return RaHdcLiteTypicalSendWr(qpHdc, &liteWr, opRsp, wr->wrId);
689 : }
690 : }
691 :
692 0 : hccp_warn("qpn:%u qp_mode:%d support_lite:%d not support to send_wr", qpHdc->qpn, qpHdc->qpMode,
693 : qpHdc->supportLite);
694 :
695 0 : return -ENOTSUPP;
696 : }
697 :
698 0 : int RaHdcSendWrVerbs(struct RaQpHandle *qpHdc, struct SendWrVerbs *wr, struct SendWrRsp *opRsp)
699 : {
700 0 : struct LiteSendWr liteWr = {0};
701 :
702 0 : if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
703 0 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
704 0 : liteWr.wr.bufList = wr->sgList;
705 0 : liteWr.wr.bufNum = wr->numSge;
706 0 : liteWr.wr.dstAddr = wr->remoteAddr;
707 0 : liteWr.wr.op = wr->opcode;
708 0 : liteWr.wr.rkey = wr->rkey;
709 0 : liteWr.wr.sendFlag = wr->sendFlags;
710 0 : liteWr.ext.immData = wr->immData;
711 0 : return RaHdcLiteTypicalSendWr(qpHdc, &liteWr, opRsp, wr->wrId);
712 : }
713 : }
714 :
715 0 : hccp_warn("qpn:%u qp_mode:%d support_lite:%d not support to send_wr", qpHdc->qpn, qpHdc->qpMode,
716 : qpHdc->supportLite);
717 :
718 0 : return -ENOTSUPP;
719 : }
720 :
721 0 : int RaHdcRecvWrVerbs(struct RaQpHandle *qpHdc, struct RecvWrVerbs *wr)
722 : {
723 : struct rdma_lite_sge list[RA_SGLIST_MAX];
724 0 : struct rdma_lite_recv_wr liteWr = {
725 : .sg_list = list,
726 0 : .wr_id = wr->wrId,
727 : .num_sge = 0,
728 : .next = NULL,
729 : };
730 0 : struct rdma_lite_recv_wr *badWr = NULL;
731 : int ret;
732 :
733 0 : if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
734 0 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
735 0 : for (int i = 0; i < wr->numSge && i < RA_SGLIST_MAX; i++) {
736 0 : list[i].addr = (uintptr_t)wr->sgList[i].addr;
737 0 : list[i].length = wr->sgList[i].len;
738 0 : list[i].lkey = wr->sgList[i].lkey;
739 0 : liteWr.num_sge++;
740 : }
741 :
742 0 : ret = RaRdmaLitePostRecv(qpHdc->liteQp, &liteWr, &badWr);
743 0 : if (ret) {
744 0 : if (ret == -ENOMEM) {
745 0 : hccp_warn("[recv][ra_hdc_wr]ra hdc post recv unsuccessful, ret(%d) phyId(%u)", ret, qpHdc->phyId);
746 0 : return 0;
747 : } else {
748 0 : hccp_err("[recv][ra_hdc_wr]ra hdc post recv failed ret(%d) phyId(%u)", ret, qpHdc->phyId);
749 : }
750 0 : return ret;
751 : }
752 :
753 0 : qpHdc->recvWrNum++;
754 0 : return 0;
755 : }
756 : }
757 :
758 0 : hccp_warn("qpn:%u qp_mode:%d support_lite:%d not support to recv_wr_verbs", qpHdc->qpn, qpHdc->qpMode,
759 : qpHdc->supportLite);
760 :
761 0 : return -ENOTSUPP;
762 : }
763 :
764 1 : int RaHdcTypicalSendWr(struct RaQpHandle *qpHdc, struct SendWr *wr, struct SendWrRsp *opRsp)
765 : {
766 1 : struct LiteSendWr liteWr = {0};
767 :
768 1 : if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
769 1 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
770 1 : liteWr.wr = *wr;
771 1 : return RaHdcLiteTypicalSendWr(qpHdc, &liteWr, opRsp, HDC_LITE_DEFAULT_WR_ID);
772 : }
773 : }
774 :
775 0 : hccp_warn("qpn:%u qp_mode:%d support_lite:%d not support to send_wr", qpHdc->qpn, qpHdc->qpMode,
776 : qpHdc->supportLite);
777 :
778 0 : return -ENOTSUPP;
779 : }
780 :
781 1 : int RaHdcMrDereg(struct RaQpHandle *qpHdc, struct MrInfoT *info)
782 : {
783 1 : union OpMrDeregData mrDeregData = {0};
784 1 : mrDeregData.txData.rdevIndex = qpHdc->rdevIndex;
785 1 : mrDeregData.txData.phyId = qpHdc->phyId;
786 1 : mrDeregData.txData.qpn = qpHdc->qpn;
787 1 : mrDeregData.txData.addr = info->addr;
788 : int ret;
789 :
790 1 : ret = RaHdcProcessMsg(RA_RS_MR_DEREG, qpHdc->phyId, (char *)&mrDeregData, sizeof(union OpMrDeregData));
791 1 : CHK_PRT_RETURN(ret,
792 : hccp_err("[dereg][ra_hdc_mr]ra hdc message process failed ret(%d) phyId(%u)", ret, qpHdc->phyId), ret);
793 :
794 1 : return 0;
795 : }
796 :
797 1 : int RaHdcMrReg(struct RaQpHandle *qpHdc, struct MrInfoT *info)
798 : {
799 1 : union OpMrRegData mrRegData = {0};
800 : int ret;
801 :
802 1 : mrRegData.txData.phyId = qpHdc->phyId;
803 1 : mrRegData.txData.rdevIndex = qpHdc->rdevIndex;
804 1 : mrRegData.txData.qpn = qpHdc->qpn;
805 1 : mrRegData.txData.mrRegAttr.addr = info->addr;
806 1 : mrRegData.txData.mrRegAttr.len = info->size;
807 1 : mrRegData.txData.mrRegAttr.access = info->access;
808 :
809 1 : ret = RaHdcProcessMsg(RA_RS_MR_REG, qpHdc->phyId, (char *)&mrRegData, sizeof(union OpMrRegData));
810 1 : CHK_PRT_RETURN(ret, hccp_err("[reg][ra_hdc_mr]ra hdc message process failed ret(%d) phyId(%u)", ret, qpHdc->phyId),
811 : ret);
812 :
813 1 : info->lkey = mrRegData.rxData.lkey;
814 1 : info->rkey = mrRegData.rxData.rkey;
815 :
816 1 : return 0;
817 : }
818 :
819 1 : int RaHdcTypicalMrReg(struct RaRdmaHandle *rdmaHandle, struct MrInfoT *info, void **mrHandle)
820 : {
821 1 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
822 1 : union OpTypicalMrRegData mrRegData = {0};
823 1 : unsigned int opcode = RA_RS_TYPICAL_MR_REG_V1;
824 1 : struct RaMrHandle *mrHdc = NULL;
825 1 : unsigned int interfaceVersion = 0;
826 : int ret;
827 :
828 1 : mrHdc = (struct RaMrHandle *)calloc(1, sizeof(struct RaMrHandle));
829 1 : CHK_PRT_RETURN(mrHdc == NULL, hccp_err("[reg][ra_hdc_typical_mr]mr_hdc calloc failed phyId(%u)", phyId), -ENOMEM);
830 :
831 1 : mrRegData.txData.phyId = phyId;
832 1 : mrRegData.txData.rdevIndex = rdmaHandle->rdevIndex;
833 1 : mrRegData.txData.mrRegAttr.addr = info->addr;
834 1 : mrRegData.txData.mrRegAttr.len = info->size;
835 1 : mrRegData.txData.mrRegAttr.access = info->access;
836 :
837 1 : ret = RaHdcGetInterfaceVersion(phyId, RA_RS_TYPICAL_MR_REG, &interfaceVersion);
838 1 : if (ret == 0 && interfaceVersion >= RA_RS_OPCODE_BASE_VERSION) {
839 0 : opcode = RA_RS_TYPICAL_MR_REG;
840 : }
841 1 : ret = RaHdcProcessMsg(opcode, phyId, (char *)&mrRegData, sizeof(union OpTypicalMrRegData));
842 1 : if (ret) {
843 0 : hccp_err("[reg][ra_hdc_typical_mr]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
844 0 : free(mrHdc);
845 0 : return ret;
846 : }
847 :
848 1 : info->lkey = mrRegData.rxData.lkey;
849 1 : info->rkey = mrRegData.rxData.rkey;
850 1 : if (opcode == RA_RS_TYPICAL_MR_REG_V1) {
851 1 : mrHdc->addr = (unsigned long long)(uintptr_t)info->addr;
852 : } else {
853 0 : mrHdc->addr = mrRegData.rxData.addr;
854 : }
855 1 : *mrHandle = mrHdc;
856 1 : return 0;
857 : }
858 :
859 1 : int RaHdcRemapMr(struct RaRdmaHandle *rdmaHandle, struct MemRemapInfo info[], unsigned int num)
860 : {
861 1 : union OpRemapMrData opData = {0};
862 : int ret;
863 :
864 1 : ret = memcpy_s(opData.txData.memList, REMAP_MR_MAX_NUM * sizeof(struct MemRemapInfo), info,
865 : num * sizeof(struct MemRemapInfo));
866 1 : CHK_PRT_RETURN(ret != 0, hccp_err("[remap][ra_hdc_mr]memcpy_s mem_list failed, ret:%d", ret), -ESAFEFUNC);
867 1 : opData.txData.memNum = num;
868 1 : opData.txData.rdevIndex = rdmaHandle->rdevIndex;
869 1 : opData.txData.phyId = rdmaHandle->rdevInfo.phyId;
870 :
871 1 : ret = RaHdcProcessMsg(RA_RS_REMAP_MR, opData.txData.phyId, (char *)&opData, sizeof(union OpRemapMrData));
872 1 : CHK_PRT_RETURN(ret,
873 : hccp_err("[remap][ra_hdc_mr]ra hdc message process failed ret(%d) phyId(%u)", ret, rdmaHandle->rdevInfo.phyId),
874 : ret);
875 :
876 1 : return 0;
877 : }
878 :
879 1 : int RaHdcTypicalMrDereg(struct RaRdmaHandle *rdmaHandle, void *mrHandle)
880 : {
881 1 : union OpTypicalMrDeregData mrDeregData = {0};
882 : int ret;
883 :
884 1 : mrDeregData.txData.phyId = rdmaHandle->rdevInfo.phyId;
885 1 : mrDeregData.txData.rdevIndex = rdmaHandle->rdevIndex;
886 1 : mrDeregData.txData.addr = ((struct RaMrHandle *)mrHandle)->addr;
887 :
888 1 : ret = RaHdcProcessMsg(RA_RS_TYPICAL_MR_DEREG, rdmaHandle->rdevInfo.phyId, (char *)&mrDeregData,
889 : sizeof(union OpTypicalMrDeregData));
890 1 : CHK_PRT_RETURN(ret,
891 : hccp_err("[dereg][ra_hdc_typical_mr]ra hdc message process failed ret(%d) phyId(%u)", ret,
892 : rdmaHandle->rdevInfo.phyId),
893 : ret);
894 :
895 1 : free(mrHandle);
896 1 : mrHandle = NULL;
897 1 : return 0;
898 : }
899 :
900 0 : STATIC void RaHdcSendWrlistInit(union OpSendWrlistData *sendWrlist, struct RaQpHandle *qpHdc, unsigned int completeCnt,
901 : struct WrlistSendCompleteNum wrlistNum)
902 : {
903 0 : sendWrlist->txData.phyId = qpHdc->phyId;
904 0 : sendWrlist->txData.rdevIndex = qpHdc->rdevIndex;
905 0 : sendWrlist->txData.qpn = qpHdc->qpn;
906 0 : sendWrlist->txData.sendNum = (wrlistNum.sendNum - completeCnt) >= MAX_WR_NUM ? MAX_WR_NUM
907 0 : : wrlistNum.sendNum - completeCnt;
908 0 : }
909 :
910 6 : STATIC void RaHdcSendWrlistExtInit(union OpSendWrlistDataExt *sendWrlist, struct RaQpHandle *qpHdc,
911 : unsigned int completeCnt, struct WrlistSendCompleteNum wrlistNum)
912 : {
913 6 : sendWrlist->txData.phyId = qpHdc->phyId;
914 6 : sendWrlist->txData.rdevIndex = qpHdc->rdevIndex;
915 6 : sendWrlist->txData.qpn = qpHdc->qpn;
916 6 : sendWrlist->txData.sendNum = (wrlistNum.sendNum - completeCnt) >= MAX_WR_NUM ? MAX_WR_NUM
917 6 : : wrlistNum.sendNum - completeCnt;
918 6 : }
919 :
920 0 : STATIC int RaHdcSendWrlistV1(struct RaQpHandle *qpHdc, struct SendWrlistData wr[], struct SendWrRsp opRsp[],
921 : struct WrlistSendCompleteNum wrlistNum)
922 : {
923 0 : int ret = 0;
924 : unsigned int i, j;
925 0 : unsigned int completeCnt = 0;
926 0 : unsigned int currentSendNum = 0;
927 0 : union OpSendWrlistData *sendWrlist = NULL;
928 :
929 0 : sendWrlist = calloc(1, sizeof(union OpSendWrlistData));
930 0 : CHK_PRT_RETURN(sendWrlist == NULL, hccp_err("[send][ra_hdc_wrlist]send_wrlist calloc failed"), -ENOMEM);
931 0 : while (completeCnt < wrlistNum.sendNum) {
932 0 : RaHdcSendWrlistInit(sendWrlist, qpHdc, completeCnt, wrlistNum);
933 0 : ret = memcpy_s(sendWrlist->txData.wrlist, (sizeof(struct SendWrlistData) * MAX_WR_NUM_V1), &wr[completeCnt],
934 0 : (sizeof(struct SendWrlistData) * sendWrlist->txData.sendNum));
935 0 : if (ret) {
936 0 : hccp_err("[send][ra_hdc_wrlist]memcpy_s for wrlist failed, ret(%d).", ret);
937 0 : ret = -ESAFEFUNC;
938 0 : goto err_send_wrlist;
939 : }
940 0 : currentSendNum = sendWrlist->txData.sendNum;
941 0 : ret = RaHdcProcessMsg(RA_RS_SEND_WRLIST, qpHdc->phyId, (char *)sendWrlist, sizeof(union OpSendWrlistData));
942 :
943 0 : if (sendWrlist->rxData.completeNum > currentSendNum) {
944 0 : hccp_err("[send][ra_hdc_wrlist]complete_num[%u] is larger than send_num[%u], ret(%d).",
945 : sendWrlist->rxData.completeNum, currentSendNum, ret);
946 0 : ret = -EINVAL;
947 0 : goto err_send_wrlist;
948 : }
949 :
950 0 : for (i = 0; i < sendWrlist->rxData.completeNum; i++) {
951 0 : j = i + completeCnt;
952 0 : if (qpHdc->qpMode == RA_RS_GDR_TMPL_QP_MODE) {
953 0 : opRsp[j].wqeTmp = sendWrlist->rxData.wrRsp[i].wqeTmp;
954 0 : } else if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_GDR_ASYN_QP_MODE ||
955 0 : qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
956 0 : opRsp[j].db = sendWrlist->rxData.wrRsp[i].db;
957 : }
958 : }
959 0 : completeCnt = completeCnt + sendWrlist->rxData.completeNum;
960 0 : if (ret) {
961 0 : if (ret != -ENOENT) {
962 0 : hccp_err("[send][ra_hdc_wrlist]ra hdc message process failed ret(%d), phyId(%u)", ret, qpHdc->phyId);
963 : }
964 0 : goto err_send_wrlist;
965 : }
966 : }
967 :
968 0 : err_send_wrlist:
969 0 : free(sendWrlist);
970 0 : sendWrlist = NULL;
971 0 : *(wrlistNum.completeNum) = completeCnt;
972 0 : return ret;
973 : }
974 :
975 5 : STATIC int RaHdcSendWrlistExtV1(struct RaQpHandle *qpHdc, struct SendWrlistDataExt wr[], struct SendWrRsp opRsp[],
976 : struct WrlistSendCompleteNum wrlistNum)
977 : {
978 5 : int ret = 0;
979 : unsigned int i, j;
980 5 : unsigned int completeCnt = 0;
981 5 : unsigned int currentSendNum = 0;
982 5 : union OpSendWrlistDataExt *sendWrlist = NULL;
983 :
984 5 : sendWrlist = calloc(1, sizeof(union OpSendWrlistDataExt));
985 5 : CHK_PRT_RETURN(sendWrlist == NULL, hccp_err("[send][ra_hdc_wrlist_ext]send_wrlist calloc failed"), -ENOMEM);
986 7 : while (completeCnt < wrlistNum.sendNum) {
987 5 : RaHdcSendWrlistExtInit(sendWrlist, qpHdc, completeCnt, wrlistNum);
988 5 : ret = memcpy_s(sendWrlist->txData.wrlist, (sizeof(struct SendWrlistDataExt) * MAX_WR_NUM_V1), &wr[completeCnt],
989 5 : (sizeof(struct SendWrlistDataExt) * sendWrlist->txData.sendNum));
990 5 : if (ret) {
991 1 : hccp_err("[send][ra_hdc_wrlist_ext]memcpy_s for wrlist failed, ret(%d).", ret);
992 1 : ret = -ESAFEFUNC;
993 1 : goto err_send_wrlist;
994 : }
995 4 : currentSendNum = sendWrlist->txData.sendNum;
996 4 : ret = RaHdcProcessMsg(RA_RS_SEND_WRLIST_EXT, qpHdc->phyId, (char *)sendWrlist,
997 : sizeof(union OpSendWrlistDataExt));
998 :
999 4 : if (sendWrlist->rxData.completeNum > currentSendNum) {
1000 2 : hccp_err("[send][ra_hdc_wrlist_ext]complete_num[%u] is larger than send_num[%u], ret(%d).",
1001 : sendWrlist->rxData.completeNum, currentSendNum, ret);
1002 2 : ret = -EINVAL;
1003 2 : goto err_send_wrlist;
1004 : }
1005 :
1006 4 : for (i = 0; i < sendWrlist->rxData.completeNum; i++) {
1007 2 : j = i + completeCnt;
1008 2 : if (qpHdc->qpMode == RA_RS_GDR_TMPL_QP_MODE) {
1009 0 : opRsp[j].wqeTmp = sendWrlist->rxData.wrRsp[i].wqeTmp;
1010 2 : } else if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_GDR_ASYN_QP_MODE ||
1011 2 : qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
1012 0 : opRsp[j].db = sendWrlist->rxData.wrRsp[i].db;
1013 : }
1014 : }
1015 2 : completeCnt = completeCnt + sendWrlist->rxData.completeNum;
1016 2 : if (ret) {
1017 0 : if (ret != -ENOENT) {
1018 0 : hccp_err("[send][ra_hdc_wrlist_ext]ra hdc message process failed ret(%d), phyId(%u)", ret,
1019 : qpHdc->phyId);
1020 : }
1021 0 : goto err_send_wrlist;
1022 : }
1023 : }
1024 :
1025 2 : err_send_wrlist:
1026 5 : free(sendWrlist);
1027 5 : sendWrlist = NULL;
1028 5 : *(wrlistNum.completeNum) = completeCnt;
1029 5 : return ret;
1030 : }
1031 :
1032 0 : STATIC void RaHdcSendWrlistInitV2(union OpSendWrlistDataV2 *sendWrlist, struct RaQpHandle *qpHdc,
1033 : unsigned int completeCnt, struct WrlistSendCompleteNum wrlistNum)
1034 : {
1035 0 : sendWrlist->txData.phyId = qpHdc->phyId;
1036 0 : sendWrlist->txData.rdevIndex = qpHdc->rdevIndex;
1037 0 : sendWrlist->txData.qpn = qpHdc->qpn;
1038 0 : sendWrlist->txData.sendNum = (wrlistNum.sendNum - completeCnt) >= MAX_WR_NUM ? MAX_WR_NUM
1039 0 : : wrlistNum.sendNum - completeCnt;
1040 0 : }
1041 :
1042 1 : STATIC void RaHdcSendWrlistExtInitV2(union OpSendWrlistDataExtV2 *sendWrlist, struct RaQpHandle *qpHdc,
1043 : unsigned int completeCnt, struct WrlistSendCompleteNum wrlistNum)
1044 : {
1045 1 : sendWrlist->txData.phyId = qpHdc->phyId;
1046 1 : sendWrlist->txData.rdevIndex = qpHdc->rdevIndex;
1047 1 : sendWrlist->txData.qpn = qpHdc->qpn;
1048 1 : sendWrlist->txData.sendNum = (wrlistNum.sendNum - completeCnt) >= MAX_WR_NUM ? MAX_WR_NUM
1049 1 : : wrlistNum.sendNum - completeCnt;
1050 1 : }
1051 :
1052 0 : STATIC int RaHdcSendWrlistV2(struct RaQpHandle *qpHdc, struct SendWrlistData wr[], struct SendWrRsp opRsp[],
1053 : struct WrlistSendCompleteNum wrlistNum)
1054 : {
1055 0 : int ret = 0;
1056 : unsigned int i, j;
1057 0 : unsigned int completeCnt = 0;
1058 0 : unsigned int currentSendNum = 0;
1059 0 : union OpSendWrlistDataV2 *sendWrlist = NULL;
1060 :
1061 0 : sendWrlist = calloc(1, sizeof(union OpSendWrlistDataV2));
1062 0 : CHK_PRT_RETURN(sendWrlist == NULL, hccp_err("[send][ra_hdc_wrlist_v2]send_wrlist calloc failed"), -ENOMEM);
1063 0 : while (completeCnt < wrlistNum.sendNum) {
1064 0 : RaHdcSendWrlistInitV2(sendWrlist, qpHdc, completeCnt, wrlistNum);
1065 0 : ret = memcpy_s(sendWrlist->txData.wrlist, (sizeof(struct SendWrlistData) * MAX_WR_NUM), &wr[completeCnt],
1066 0 : (sizeof(struct SendWrlistData) * sendWrlist->txData.sendNum));
1067 0 : if (ret) {
1068 0 : hccp_err("[send][ra_hdc_wrlist_v2]memcpy_s for wrlist failed, ret(%d).", ret);
1069 0 : ret = -ESAFEFUNC;
1070 0 : goto err_send_wrlist;
1071 : }
1072 0 : currentSendNum = sendWrlist->txData.sendNum;
1073 0 : ret = RaHdcProcessMsg(RA_RS_SEND_WRLIST_V2, qpHdc->phyId, (char *)sendWrlist, sizeof(union OpSendWrlistDataV2));
1074 :
1075 0 : if (sendWrlist->rxData.completeNum > currentSendNum) {
1076 0 : hccp_err("[send][ra_hdc_wrlist_v2]complete_num[%u] is larger than send_num[%u], ret(%d).",
1077 : sendWrlist->rxData.completeNum, currentSendNum, ret);
1078 0 : ret = -EINVAL;
1079 0 : goto err_send_wrlist;
1080 : }
1081 :
1082 0 : for (i = 0; i < sendWrlist->rxData.completeNum; i++) {
1083 0 : j = i + completeCnt;
1084 0 : if (qpHdc->qpMode == RA_RS_GDR_TMPL_QP_MODE) {
1085 0 : opRsp[j].wqeTmp = sendWrlist->rxData.wrRsp[i].wqeTmp;
1086 0 : } else if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_GDR_ASYN_QP_MODE ||
1087 0 : qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
1088 0 : opRsp[j].db = sendWrlist->rxData.wrRsp[i].db;
1089 : }
1090 : }
1091 0 : completeCnt = completeCnt + sendWrlist->rxData.completeNum;
1092 0 : if (ret) {
1093 0 : if (ret != -ENOENT) {
1094 0 : hccp_err("[send][ra_hdc_wrlist_v2]ra hdc message process failed ret(%d), phyId(%u)", ret, qpHdc->phyId);
1095 : }
1096 0 : goto err_send_wrlist;
1097 : }
1098 : }
1099 :
1100 0 : err_send_wrlist:
1101 0 : free(sendWrlist);
1102 0 : sendWrlist = NULL;
1103 0 : *(wrlistNum.completeNum) = completeCnt;
1104 0 : return ret;
1105 : }
1106 :
1107 0 : STATIC int RaHdcSendWrlistExtV2(struct RaQpHandle *qpHdc, struct SendWrlistDataExt wr[], struct SendWrRsp opRsp[],
1108 : struct WrlistSendCompleteNum wrlistNum)
1109 : {
1110 0 : int ret = 0;
1111 : unsigned int i, j;
1112 0 : unsigned int completeCnt = 0;
1113 0 : unsigned int currentSendNum = 0;
1114 0 : union OpSendWrlistDataExtV2 *sendWrlist = NULL;
1115 :
1116 0 : sendWrlist = calloc(1, sizeof(union OpSendWrlistDataExtV2));
1117 0 : CHK_PRT_RETURN(sendWrlist == NULL, hccp_err("[send][ra_hdc_wrlist_ext_v2]send_wrlist calloc failed"), -ENOMEM);
1118 0 : while (completeCnt < wrlistNum.sendNum) {
1119 0 : RaHdcSendWrlistExtInitV2(sendWrlist, qpHdc, completeCnt, wrlistNum);
1120 0 : ret = memcpy_s(sendWrlist->txData.wrlist, (sizeof(struct SendWrlistDataExt) * MAX_WR_NUM), &wr[completeCnt],
1121 0 : (sizeof(struct SendWrlistDataExt) * sendWrlist->txData.sendNum));
1122 0 : if (ret) {
1123 0 : hccp_err("[send][ra_hdc_wrlist_ext_v2]memcpy_s for wrlist failed, ret(%d).", ret);
1124 0 : ret = -ESAFEFUNC;
1125 0 : goto err_send_wrlist;
1126 : }
1127 0 : currentSendNum = sendWrlist->txData.sendNum;
1128 0 : ret = RaHdcProcessMsg(RA_RS_SEND_WRLIST_EXT_V2, qpHdc->phyId, (char *)sendWrlist,
1129 : sizeof(union OpSendWrlistDataExtV2));
1130 :
1131 0 : if (sendWrlist->rxData.completeNum > currentSendNum) {
1132 0 : hccp_err("[send][ra_hdc_wrlist_ext_v2]complete_num[%u] is larger than send_num[%u], ret(%d).",
1133 : sendWrlist->rxData.completeNum, currentSendNum, ret);
1134 0 : ret = -EINVAL;
1135 0 : goto err_send_wrlist;
1136 : }
1137 :
1138 0 : for (i = 0; i < sendWrlist->rxData.completeNum; i++) {
1139 0 : j = i + completeCnt;
1140 0 : if (qpHdc->qpMode == RA_RS_GDR_TMPL_QP_MODE) {
1141 0 : opRsp[j].wqeTmp = sendWrlist->rxData.wrRsp[i].wqeTmp;
1142 0 : } else if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_GDR_ASYN_QP_MODE ||
1143 0 : qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
1144 0 : opRsp[j].db = sendWrlist->rxData.wrRsp[i].db;
1145 : }
1146 : }
1147 0 : completeCnt = completeCnt + sendWrlist->rxData.completeNum;
1148 0 : if (ret) {
1149 0 : if (ret != -ENOENT) {
1150 0 : hccp_err("[send][ra_hdc_wrlist_ext_v2]ra hdc message process failed ret(%d), phyId(%u)", ret,
1151 : qpHdc->phyId);
1152 : }
1153 0 : goto err_send_wrlist;
1154 : }
1155 : }
1156 :
1157 0 : err_send_wrlist:
1158 0 : free(sendWrlist);
1159 0 : sendWrlist = NULL;
1160 0 : *(wrlistNum.completeNum) = completeCnt;
1161 0 : return ret;
1162 : }
1163 :
1164 0 : int RaHdcSendWrlist(struct RaQpHandle *qpHdc, struct SendWrlistData wr[], struct SendWrRsp opRsp[],
1165 : struct WrlistSendCompleteNum wrlistNum)
1166 : {
1167 : int ret;
1168 0 : unsigned int interfaceVersion = 0;
1169 :
1170 0 : if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
1171 0 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
1172 0 : return RaHdcLiteSendWrlist(qpHdc, wr, opRsp, wrlistNum);
1173 : }
1174 : }
1175 :
1176 0 : ret = RaHdcGetInterfaceVersion(qpHdc->phyId, RA_RS_SEND_WRLIST_V2, &interfaceVersion);
1177 0 : if (ret != 0 || interfaceVersion != RA_RS_SEND_WRLIST_V2_VERSION) {
1178 0 : return RaHdcSendWrlistV1(qpHdc, wr, opRsp, wrlistNum);
1179 : }
1180 :
1181 0 : return RaHdcSendWrlistV2(qpHdc, wr, opRsp, wrlistNum);
1182 : }
1183 :
1184 5 : int RaHdcSendWrlistExt(struct RaQpHandle *qpHdc, struct SendWrlistDataExt wr[], struct SendWrRsp opRsp[],
1185 : struct WrlistSendCompleteNum wrlistNum)
1186 : {
1187 : int ret;
1188 5 : unsigned int interfaceVersion = 0;
1189 :
1190 5 : if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
1191 0 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
1192 0 : return RaHdcLiteSendWrlistExt(qpHdc, wr, opRsp, wrlistNum);
1193 : }
1194 : }
1195 :
1196 5 : ret = RaHdcGetInterfaceVersion(qpHdc->phyId, RA_RS_SEND_WRLIST_EXT_V2, &interfaceVersion);
1197 5 : if (ret != 0 || interfaceVersion != RA_RS_SEND_WRLIST_EXT_V2_VERSION) {
1198 5 : return RaHdcSendWrlistExtV1(qpHdc, wr, opRsp, wrlistNum);
1199 : }
1200 :
1201 0 : return RaHdcSendWrlistExtV2(qpHdc, wr, opRsp, wrlistNum);
1202 : }
1203 :
1204 1 : STATIC void RaHdcSendWrlistNormalInit(union OpSendNormalWrlistData *sendWrlist, struct RaQpHandle *qpHdc,
1205 : unsigned int completeCnt, struct WrlistSendCompleteNum wrlistNum)
1206 : {
1207 1 : (void)memset_s(sendWrlist, sizeof(union OpSendNormalWrlistData), 0, sizeof(union OpSendNormalWrlistData));
1208 1 : sendWrlist->txData.phyId = qpHdc->phyId;
1209 1 : sendWrlist->txData.rdevIndex = qpHdc->rdevIndex;
1210 1 : sendWrlist->txData.qpn = qpHdc->qpn;
1211 1 : sendWrlist->txData.sendNum = ((wrlistNum.sendNum - completeCnt) >= MAX_WR_NUM) ? MAX_WR_NUM
1212 1 : : wrlistNum.sendNum - completeCnt;
1213 1 : }
1214 :
1215 1 : STATIC int RaHdcSendWrlistNormal(struct RaQpHandle *qpHdc, struct WrInfo wr[], struct SendWrRsp opRsp[],
1216 : struct WrlistSendCompleteNum wrlistNum)
1217 : {
1218 1 : union OpSendNormalWrlistData *sendWrlist = NULL;
1219 1 : unsigned int currentSendNum = 0;
1220 1 : unsigned int completeCnt = 0;
1221 : unsigned int i;
1222 1 : int ret = 0;
1223 :
1224 1 : sendWrlist = calloc(1, sizeof(union OpSendNormalWrlistData));
1225 1 : CHK_PRT_RETURN(sendWrlist == NULL, hccp_err("[send][send_wrlist]send_wrlist calloc failed"), -ENOMEM);
1226 :
1227 2 : while (completeCnt < wrlistNum.sendNum) {
1228 1 : RaHdcSendWrlistNormalInit(sendWrlist, qpHdc, completeCnt, wrlistNum);
1229 1 : ret = memcpy_s(sendWrlist->txData.wrlist, (sizeof(struct WrInfo) * MAX_WR_NUM), &wr[completeCnt],
1230 1 : (sizeof(struct WrInfo) * sendWrlist->txData.sendNum));
1231 1 : if (ret != 0) {
1232 0 : hccp_err("[send][send_wrlist]memcpy_s for wrlist failed, ret(%d)", ret);
1233 0 : ret = -ESAFEFUNC;
1234 0 : goto err_send_wrlist;
1235 : }
1236 1 : currentSendNum = sendWrlist->txData.sendNum;
1237 1 : ret = RaHdcProcessMsg(RA_RS_SEND_NORMAL_WRLIST, qpHdc->phyId, (char *)sendWrlist,
1238 : sizeof(union OpSendNormalWrlistData));
1239 :
1240 1 : if (sendWrlist->rxData.completeNum > currentSendNum) {
1241 0 : hccp_err("[send][send_wrlist]complete_num[%u] is larger than send_num[%u], ret(%d)",
1242 : sendWrlist->rxData.completeNum, currentSendNum, ret);
1243 0 : ret = -EINVAL;
1244 0 : goto err_send_wrlist;
1245 : }
1246 :
1247 2 : for (i = 0; i < sendWrlist->rxData.completeNum; i++) {
1248 1 : if (qpHdc->qpMode == RA_RS_GDR_TMPL_QP_MODE) {
1249 0 : opRsp[completeCnt + i].wqeTmp = sendWrlist->rxData.wrRsp[i].wqeTmp;
1250 1 : } else if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_GDR_ASYN_QP_MODE ||
1251 1 : qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
1252 0 : opRsp[completeCnt + i].db = sendWrlist->rxData.wrRsp[i].db;
1253 : }
1254 : }
1255 1 : completeCnt += sendWrlist->rxData.completeNum;
1256 : // send wrlist success, continue to send
1257 1 : if (ret == 0) {
1258 1 : continue;
1259 : }
1260 0 : if (ret != -ENOENT && ret != -ENOMEM) {
1261 0 : hccp_err("[send][send_wrlist]ra hdc message process failed ret(%d), phyId(%u)", ret, qpHdc->phyId);
1262 : }
1263 0 : goto err_send_wrlist;
1264 : }
1265 :
1266 1 : err_send_wrlist:
1267 1 : free(sendWrlist);
1268 1 : sendWrlist = NULL;
1269 1 : *(wrlistNum.completeNum) = completeCnt;
1270 1 : return ret;
1271 : }
1272 :
1273 2 : int RaHdcSendNormalWrlist(struct RaQpHandle *qpHdc, struct WrInfo wr[], struct SendWrRsp opRsp[],
1274 : struct WrlistSendCompleteNum wrlistNum)
1275 : {
1276 2 : if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
1277 1 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
1278 1 : return RaHdcLiteSendNormalWrlist(qpHdc, wr, opRsp, wrlistNum);
1279 : }
1280 : }
1281 :
1282 1 : return RaHdcSendWrlistNormal(qpHdc, wr, opRsp, wrlistNum);
1283 : }
1284 :
1285 2 : int RaHdcGetNotifyBaseAddr(struct RaRdmaHandle *rdmaHandle, unsigned long long *va, unsigned long long *size)
1286 : {
1287 : int ret;
1288 2 : union OpGetNotifyBaData getNotifyBaData = {0};
1289 2 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
1290 :
1291 2 : getNotifyBaData.txData.phyId = phyId;
1292 2 : getNotifyBaData.txData.rdevIndex = rdmaHandle->rdevIndex;
1293 :
1294 2 : ret = RaHdcProcessMsg(RA_RS_GET_NOTIFY_BA, phyId, (char *)&getNotifyBaData, sizeof(union OpGetNotifyBaData));
1295 2 : CHK_PRT_RETURN(ret,
1296 : hccp_err("[get][ra_hdc_notify_base_addr]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId), ret);
1297 :
1298 2 : *va = getNotifyBaData.rxData.va;
1299 2 : *size = getNotifyBaData.rxData.size;
1300 2 : return 0;
1301 : }
1302 :
1303 2 : int RaHdcGetNotifyMrInfo(struct RaRdmaHandle *rdmaHandle, struct MrInfoT *info)
1304 : {
1305 2 : union OpGetNotifyBaData getNotifyBaData = {0};
1306 2 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
1307 2 : unsigned int interfaceVersion = 0;
1308 : int ret;
1309 :
1310 : // check opcode version, reuse RA_RS_GET_NOTIFY_BA
1311 2 : ret = RaHdcGetInterfaceVersion(phyId, RA_RS_GET_NOTIFY_BA, &interfaceVersion);
1312 2 : if (ret != 0 || interfaceVersion == RA_RS_GET_NOTIFY_BA_VERSION) {
1313 0 : hccp_err("[get][ra_hdc_notify_mr_info]interface_version(%u) not support, ret(%d)", interfaceVersion, ret);
1314 0 : return -ENOTSUPP;
1315 : }
1316 :
1317 2 : getNotifyBaData.txData.phyId = phyId;
1318 2 : getNotifyBaData.txData.rdevIndex = rdmaHandle->rdevIndex;
1319 :
1320 2 : ret = RaHdcProcessMsg(RA_RS_GET_NOTIFY_BA, phyId, (char *)&getNotifyBaData, sizeof(union OpGetNotifyBaData));
1321 2 : CHK_PRT_RETURN(ret,
1322 : hccp_err("[get][ra_hdc_notify_mr_info]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId), ret);
1323 :
1324 2 : info->addr = (void *)(uintptr_t)getNotifyBaData.rxData.va;
1325 2 : info->size = getNotifyBaData.rxData.size;
1326 2 : info->access = getNotifyBaData.rxData.access;
1327 2 : info->lkey = getNotifyBaData.rxData.lkey;
1328 2 : return 0;
1329 : }
1330 :
1331 2 : int RaHdcRecvWrlist(struct RaQpHandle *qpHdc, struct RecvWrlistData *wr, unsigned int recvNum,
1332 : unsigned int *completeNum)
1333 : {
1334 2 : if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
1335 1 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
1336 1 : return RaHdcLiteRecvWrlist(qpHdc, wr, recvNum, completeNum);
1337 : }
1338 : }
1339 :
1340 1 : hccp_warn("qpn:%u qp_mode:%d support_lite:%d not support to recv_wrlist", qpHdc->qpn, qpHdc->qpMode,
1341 : qpHdc->supportLite);
1342 :
1343 1 : return -ENOTSUPP;
1344 : }
1345 :
1346 2 : int RaHdcPollCq(struct RaQpHandle *qpHdc, bool isSendCq, unsigned int numEntries, void *wc)
1347 : {
1348 2 : struct rdma_lite_wc_v2 *liteWc = (struct rdma_lite_wc_v2 *)wc;
1349 :
1350 2 : if (qpHdc->qpMode == RA_RS_OP_QP_MODE || qpHdc->qpMode == RA_RS_OP_QP_MODE_EXT) {
1351 1 : if (qpHdc->supportLite != LITE_NOT_SUPPORT) {
1352 1 : return RaHdcLitePollCq(qpHdc, isSendCq, numEntries, liteWc);
1353 : }
1354 : }
1355 :
1356 1 : hccp_warn("qpn:%u qp_mode:%d support_lite:%d not support to poll_cq", qpHdc->qpn, qpHdc->qpMode,
1357 : qpHdc->supportLite);
1358 :
1359 1 : return -ENOTSUPP;
1360 : }
1361 :
1362 0 : int RaHdcPollTypicalCq(struct RaTypicalCqHandle *cqHdc, unsigned int numEntries, void *wc)
1363 : {
1364 0 : struct rdma_lite_wc_v2 *liteWc = (struct rdma_lite_wc_v2 *)wc;
1365 0 : struct rdma_lite_cq *liteCq = RaHdcLiteFindTypicalCq(cqHdc->rdmaHandle, cqHdc->cqn);
1366 0 : if (liteCq == NULL) {
1367 0 : hccp_warn("cqn:%u liteCq not found in table", cqHdc->cqn);
1368 0 : return -ENOTSUPP;
1369 : }
1370 0 : int ret = RaRdmaLitePollCqV2(liteCq, (int)numEntries, liteWc);
1371 0 : if (ret < 0) {
1372 0 : hccp_err("ra_rdma_lite_poll_cq_v2 failed, ret %d", ret);
1373 0 : return ret;
1374 : }
1375 0 : return ret;
1376 : }
1377 :
1378 12 : int RaHdcNotifyCfgSet(unsigned int phyId, unsigned long long va, unsigned long long size)
1379 : {
1380 12 : union OpNotifyCfgSetData setNotifyBaData = {0};
1381 : int ret;
1382 :
1383 12 : setNotifyBaData.txData.phyId = phyId;
1384 12 : setNotifyBaData.txData.va = va;
1385 12 : setNotifyBaData.txData.size = size;
1386 :
1387 12 : ret = RaHdcProcessMsg(RA_RS_NOTIFY_CFG_SET, phyId, (char *)&setNotifyBaData, sizeof(union OpNotifyCfgSetData));
1388 12 : CHK_PRT_RETURN(ret,
1389 : hccp_err("[set][ra_hdc_notify_cfg]ra hdc message process failed ret(%d), phyId(%u)", ret, phyId), ret);
1390 :
1391 9 : return 0;
1392 : }
1393 :
1394 6 : int RaHdcNotifyCfgGet(unsigned int phyId, unsigned long long *va, unsigned long long *size)
1395 : {
1396 6 : union OpNotifyCfgGetData getNotifyBaData = {0};
1397 : int ret;
1398 :
1399 6 : getNotifyBaData.txData.phyId = phyId;
1400 :
1401 6 : ret = RaHdcProcessMsg(RA_RS_NOTIFY_CFG_GET, phyId, (char *)&getNotifyBaData, sizeof(union OpNotifyCfgGetData));
1402 6 : CHK_PRT_RETURN(ret,
1403 : hccp_err("[get][ra_hdc_notify_cfg]ra hdc message process failed ret(%d), phyId(%u)", ret, phyId), ret);
1404 6 : *va = getNotifyBaData.rxData.va;
1405 6 : *size = getNotifyBaData.rxData.size;
1406 6 : return 0;
1407 : }
1408 :
1409 0 : STATIC int RaHdcRdevInitWithBackup(struct RaRdmaHandle *rdmaHandle, unsigned int *rdevIndex)
1410 : {
1411 0 : union OpRdevInitWithBackupData rdevInitData = {0};
1412 0 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
1413 0 : unsigned int interfaceVersion = 0;
1414 : int ret;
1415 :
1416 0 : ret = RaHdcGetInterfaceVersion(phyId, RA_RS_RDEV_INIT_WITH_BACKUP, &interfaceVersion);
1417 : // check opcode version, not support to init rdev with backup info
1418 0 : if (ret != 0 || interfaceVersion < RA_RS_OPCODE_BASE_VERSION) {
1419 0 : hccp_warn("[init][ra_hdc_rdev]get opcode[%d] not support, ret[%d] != 0 or interfaceVersion[%u] is 0",
1420 : RA_RS_RDEV_INIT_WITH_BACKUP, ret, interfaceVersion);
1421 0 : return -ENOTSUPP;
1422 : }
1423 :
1424 0 : (void)memcpy_s(&(rdevInitData.txData.rdevInfo), sizeof(struct rdev), &rdmaHandle->rdevInfo, sizeof(struct rdev));
1425 0 : (void)memcpy_s(&(rdevInitData.txData.backupRdevInfo), sizeof(struct rdev), &rdmaHandle->backupInfo.rdevInfo,
1426 : sizeof(struct rdev));
1427 0 : ret = RaHdcProcessMsg(RA_RS_RDEV_INIT_WITH_BACKUP, phyId, (char *)&rdevInitData,
1428 : sizeof(union OpRdevInitWithBackupData));
1429 0 : if (ret) {
1430 0 : hccp_err("[init][ra_hdc_rdev]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
1431 0 : return ret;
1432 : }
1433 :
1434 0 : *rdevIndex = rdevInitData.rxData.rdevIndex;
1435 0 : return 0;
1436 : }
1437 :
1438 17 : int RaHdcRdevInit(struct RaRdmaHandle *rdmaHandle, unsigned int notifyType, struct rdev rdevInfo,
1439 : unsigned int *rdevIndex)
1440 : {
1441 17 : union OpRdevInitData rdevInitData = {0};
1442 17 : unsigned long long *notifyVa = NULL;
1443 : int ret, drvRet;
1444 :
1445 17 : ret = RaHdcNotifyBaseAddrInit(notifyType, rdevInfo.phyId, ¬ifyVa);
1446 17 : CHK_PRT_RETURN(ret,
1447 : hccp_err("[init][ra_hdc_rdev]ra_hdc_notify_base_addr_init failed, ret(%d), phyId(%u)", ret, rdevInfo.phyId),
1448 : ret);
1449 :
1450 : // need to init backup rdev: reg notify & normal mr, prepare for aicpu unfold
1451 14 : if (rdmaHandle->backupInfo.backupFlag) {
1452 0 : ret = RaHdcRdevInitWithBackup(rdmaHandle, rdevIndex);
1453 0 : if (ret) {
1454 0 : goto free_mem;
1455 : }
1456 : } else {
1457 14 : (void)memcpy_s(&(rdevInitData.txData.rdevInfo), sizeof(struct rdev), &rdevInfo, sizeof(struct rdev));
1458 14 : ret = RaHdcProcessMsg(RA_RS_RDEV_INIT, rdevInfo.phyId, (char *)&rdevInitData, sizeof(union OpRdevInitData));
1459 14 : if (ret) {
1460 5 : hccp_err("[init][ra_hdc_rdev]ra hdc message process failed ret(%d) phyId(%u)", ret, rdevInfo.phyId);
1461 5 : goto free_mem;
1462 : }
1463 9 : *rdevIndex = rdevInitData.rxData.rdevIndex;
1464 : }
1465 :
1466 9 : ret = RaHdcLiteInit(rdmaHandle, rdevInfo.phyId, *rdevIndex);
1467 9 : if (ret) {
1468 4 : hccp_err("[init][ra_hdc_rdev]ra_hdc_lite_init failed ret(%d) phyId(%u)", ret, rdevInfo.phyId);
1469 4 : goto free_mem;
1470 : }
1471 :
1472 5 : return 0;
1473 :
1474 9 : free_mem:
1475 9 : drvRet = DlHalMemFree((void *)notifyVa);
1476 9 : if (drvRet) {
1477 1 : hccp_err("[init][ra_hdc_rdev]halMemFree failed! drv_ret(%d)", drvRet);
1478 : }
1479 9 : return ret;
1480 : }
1481 :
1482 2 : int RaHdcRdevGetPortStatus(struct RaRdmaHandle *rdmaHandle, enum PortStatus *status)
1483 : {
1484 2 : union OpRdevGetPortStatusData statusData = {0};
1485 2 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
1486 : int ret;
1487 :
1488 2 : statusData.txData.rdevIndex = rdmaHandle->rdevIndex;
1489 2 : statusData.txData.phyId = phyId;
1490 :
1491 2 : ret = RaHdcProcessMsg(RA_RS_RDEV_GET_PORT_STATUS, phyId, (char *)&statusData,
1492 : sizeof(union OpRdevGetPortStatusData));
1493 2 : CHK_PRT_RETURN(ret != 0,
1494 : hccp_err("[get][ra_hdc_port_status]ra hdc message process failed, ret(%d) phyId(%u)", ret, phyId), ret);
1495 :
1496 1 : *status = statusData.rxData.status;
1497 1 : return 0;
1498 : }
1499 :
1500 0 : int RaHdcRdevRestoreDeinit(struct RaRdmaHandle *rdmaHandle, unsigned int notifyType)
1501 : {
1502 : // lite thread is an inner thread, make sure it will exit
1503 0 : RaHdcLiteDeinit(rdmaHandle);
1504 :
1505 0 : CHK_PRT_RETURN(notifyType != NOTIFY, hccp_err("[deinit][ra_hdc_rdev]notify_type[%u] error", notifyType), -EINVAL);
1506 :
1507 0 : return 0;
1508 : }
1509 :
1510 10 : int RaHdcRdevDeinit(struct RaRdmaHandle *rdmaHandle, unsigned int notifyType)
1511 : {
1512 10 : union OpRdevDeinitData rdevDeinitData = {0};
1513 : unsigned long long va, size;
1514 : int ret;
1515 :
1516 : // lite thread is an inner thread, make sure it will exit
1517 10 : RaHdcLiteDeinit(rdmaHandle);
1518 :
1519 10 : CHK_PRT_RETURN(notifyType != NOTIFY, hccp_err("[deinit][ra_hdc_rdev]notify_type[%u] error", notifyType), -EINVAL);
1520 :
1521 10 : rdevDeinitData.txData.rdevIndex = rdmaHandle->rdevIndex;
1522 10 : rdevDeinitData.txData.phyId = rdmaHandle->rdevInfo.phyId;
1523 :
1524 10 : ret = RaHdcProcessMsg(RA_RS_RDEV_DEINIT, rdmaHandle->rdevInfo.phyId, (char *)&rdevDeinitData,
1525 : sizeof(union OpRdevDeinitData));
1526 10 : CHK_PRT_RETURN(ret, hccp_err("[deinit][ra_hdc_rdev]ra_hdc_notify_cfg_get failed, ret(%d)", ret), ret);
1527 :
1528 8 : ret = RaHdcNotifyCfgGet(rdmaHandle->rdevInfo.phyId, &va, &size);
1529 8 : CHK_PRT_RETURN(ret, hccp_err("[deinit][ra_hdc_rdev]ra_hdc_notify_cfg_get failed, ret(%d)", ret), ret);
1530 :
1531 7 : ret = DlHalMemFree((void *)(uintptr_t)va);
1532 7 : CHK_PRT_RETURN(ret, hccp_err("[deinit][ra_hdc_rdev]halMemFree failed, ret(%d)", ret), ret);
1533 :
1534 6 : return 0;
1535 : }
1536 :
1537 1 : int RaHdcSetTsqpDepth(struct RaRdmaHandle *rdmaHandle, unsigned int tempDepth, unsigned int *qpNum)
1538 : {
1539 1 : union OpSetTsqpDepthData setTsqpDepthData = {0};
1540 1 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
1541 : int ret;
1542 :
1543 1 : setTsqpDepthData.txData.phyId = rdmaHandle->rdevInfo.phyId;
1544 1 : setTsqpDepthData.txData.rdevIndex = rdmaHandle->rdevIndex;
1545 1 : setTsqpDepthData.txData.tempDepth = tempDepth;
1546 :
1547 1 : ret = RaHdcProcessMsg(RA_RS_SET_TSQP_DEPTH, phyId, (char *)&setTsqpDepthData, sizeof(union OpSetTsqpDepthData));
1548 1 : CHK_PRT_RETURN(ret,
1549 : hccp_err("[set][ra_hdc_tsqp_depth]ra hdc message process failed ret(%d), opcode(%d)"
1550 : "phyId(%u)",
1551 : ret, RA_RS_SET_TSQP_DEPTH, phyId),
1552 : ret);
1553 :
1554 1 : *qpNum = setTsqpDepthData.rxData.qpNum;
1555 1 : return 0;
1556 : }
1557 :
1558 1 : int RaHdcGetTsqpDepth(struct RaRdmaHandle *rdmaHandle, unsigned int *tempDepth, unsigned int *qpNum)
1559 : {
1560 1 : union OpGetTsqpDepthData getTsqpDepthData = {0};
1561 1 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
1562 : int ret;
1563 :
1564 1 : getTsqpDepthData.txData.phyId = rdmaHandle->rdevInfo.phyId;
1565 1 : getTsqpDepthData.txData.rdevIndex = rdmaHandle->rdevIndex;
1566 :
1567 1 : ret = RaHdcProcessMsg(RA_RS_GET_TSQP_DEPTH, phyId, (char *)&getTsqpDepthData, sizeof(union OpGetTsqpDepthData));
1568 1 : CHK_PRT_RETURN(ret,
1569 : hccp_err("[get][ra_hdc_tsqp_depth]ra hdc message process failed ret(%d), opcode(%d)"
1570 : "phyId(%u)",
1571 : ret, RA_RS_GET_TSQP_DEPTH, phyId),
1572 : ret);
1573 :
1574 1 : *tempDepth = getTsqpDepthData.rxData.tempDepth;
1575 1 : *qpNum = getTsqpDepthData.rxData.qpNum;
1576 :
1577 1 : return 0;
1578 : }
1579 :
1580 0 : int RaHdcSetQpAttrQos(struct RaQpHandle *qpHdc, struct QosAttr *attr)
1581 : {
1582 0 : union OpSetQpAttrQosData qpAttrQosData = {0};
1583 : int ret;
1584 :
1585 0 : qpAttrQosData.txData.phyId = qpHdc->phyId;
1586 0 : qpAttrQosData.txData.rdevIndex = qpHdc->rdevIndex;
1587 0 : qpAttrQosData.txData.qpn = qpHdc->qpn;
1588 0 : qpAttrQosData.txData.qosAttr.tc = attr->tc;
1589 0 : qpAttrQosData.txData.qosAttr.sl = attr->sl;
1590 :
1591 0 : ret = RaHdcProcessMsg(RA_RS_SET_QP_ATTR_QOS, qpHdc->phyId, (char *)&qpAttrQosData,
1592 : sizeof(union OpSetQpAttrQosData));
1593 0 : CHK_PRT_RETURN(ret,
1594 : hccp_err("[set][ra_hdc_qp_attr_qos]ra hdc message process failed ret(%d) phyId(%u)", ret, qpHdc->phyId), ret);
1595 :
1596 0 : return 0;
1597 : }
1598 :
1599 0 : int RaHdcSetQpAttrTimeout(struct RaQpHandle *qpHdc, unsigned int *timeout)
1600 : {
1601 0 : union OpSetQpAttrTimeoutData qpAttrTimeoutData = {0};
1602 : int ret;
1603 :
1604 0 : qpAttrTimeoutData.txData.phyId = qpHdc->phyId;
1605 0 : qpAttrTimeoutData.txData.rdevIndex = qpHdc->rdevIndex;
1606 0 : qpAttrTimeoutData.txData.qpn = qpHdc->qpn;
1607 0 : qpAttrTimeoutData.txData.timeout = *timeout;
1608 :
1609 0 : ret = RaHdcProcessMsg(RA_RS_SET_QP_ATTR_TIMEOUT, qpHdc->phyId, (char *)&qpAttrTimeoutData,
1610 : sizeof(union OpSetQpAttrTimeoutData));
1611 0 : CHK_PRT_RETURN(ret,
1612 : hccp_err("[set][ra_hdc_qp_attr_timeout]ra hdc message process failed ret(%d) phyId(%u)", ret, qpHdc->phyId),
1613 : ret);
1614 :
1615 0 : return 0;
1616 : }
1617 :
1618 0 : int RaHdcSetQpAttrRetryCnt(struct RaQpHandle *qpHdc, unsigned int *retryCnt)
1619 : {
1620 0 : union OpSetQpAttrRetryCntData qpAttrRetryCntData = {0};
1621 : int ret;
1622 :
1623 0 : qpAttrRetryCntData.txData.phyId = qpHdc->phyId;
1624 0 : qpAttrRetryCntData.txData.rdevIndex = qpHdc->rdevIndex;
1625 0 : qpAttrRetryCntData.txData.qpn = qpHdc->qpn;
1626 0 : qpAttrRetryCntData.txData.retryCnt = *retryCnt;
1627 :
1628 0 : ret = RaHdcProcessMsg(RA_RS_SET_QP_ATTR_RETRY_CNT, qpHdc->phyId, (char *)&qpAttrRetryCntData,
1629 : sizeof(union OpSetQpAttrRetryCntData));
1630 0 : CHK_PRT_RETURN(ret,
1631 : hccp_err("[set][ra_hdc_qp_attr_retry_cnt]ra hdc message process failed ret(%d) phyId(%u)", ret, qpHdc->phyId),
1632 : ret);
1633 :
1634 0 : return 0;
1635 : }
1636 :
1637 0 : STATIC int RaHdcGetCqeErrInfoNum(struct RaRdmaHandle *rdmaHandle, unsigned int *num)
1638 : {
1639 0 : union OpGetCqeErrInfoNumData cqeErrInfoNumData = {0};
1640 0 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
1641 0 : unsigned int interfaceVersion = 0;
1642 : int ret;
1643 :
1644 0 : *num = 0;
1645 : // check opcode version, not support to get cqe err info
1646 0 : ret = RaHdcGetInterfaceVersion(phyId, RA_RS_GET_CQE_ERR_INFO_NUM, &interfaceVersion);
1647 0 : if (ret != 0 || interfaceVersion == 0) {
1648 0 : hccp_warn("[get][cqe_err_info_list]get opcode[%d] not support, ret[%d] != 0 or interfaceVersion[%u] is 0",
1649 : RA_RS_GET_CQE_ERR_INFO_NUM, ret, interfaceVersion);
1650 0 : return 0;
1651 : }
1652 :
1653 0 : cqeErrInfoNumData.txData.phyId = phyId;
1654 0 : cqeErrInfoNumData.txData.rdevIndex = rdmaHandle->rdevIndex;
1655 0 : ret = RaHdcProcessMsg(RA_RS_GET_CQE_ERR_INFO_NUM, phyId, (char *)&cqeErrInfoNumData,
1656 : sizeof(union OpGetCqeErrInfoNumData));
1657 0 : CHK_PRT_RETURN(ret, hccp_err("ra hdc message process failed ret(%d) phyId(%u)", ret, phyId), ret);
1658 :
1659 0 : *num = cqeErrInfoNumData.rxData.num;
1660 0 : return 0;
1661 : }
1662 :
1663 0 : int RaHdcGetCqeErrInfoList(struct RaRdmaHandle *rdmaHandle, struct CqeErrInfo *infoList, unsigned int *num)
1664 : {
1665 0 : union OpGetCqeErrInfoListData cqeErrInfoListData = {0};
1666 0 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
1667 0 : unsigned int liteCqeErrNum = *num;
1668 0 : unsigned int cqeErrInfoNum = 0;
1669 0 : unsigned int hdcCqeErrNum = 0;
1670 0 : int ret = 0;
1671 :
1672 0 : ret = RaHdcLiteGetCqeErrInfoList(rdmaHandle, infoList, &liteCqeErrNum);
1673 0 : CHK_PRT_RETURN(ret != 0,
1674 : hccp_err("[get][cqe_err_info_list]get lite err info list failed, ret(%d) phyId(%u)", ret, phyId), ret);
1675 :
1676 0 : hdcCqeErrNum = *num - liteCqeErrNum;
1677 0 : *num = liteCqeErrNum;
1678 : // lite cqe err info full up info_list
1679 0 : if (hdcCqeErrNum == 0) {
1680 0 : return 0;
1681 : }
1682 :
1683 : // get cqe err info num failed or not support to get cqe err info, skip get cqe err info list
1684 0 : ret = RaHdcGetCqeErrInfoNum(rdmaHandle, &cqeErrInfoNum);
1685 0 : if (ret != 0 || cqeErrInfoNum == 0) {
1686 0 : return ret;
1687 : }
1688 :
1689 0 : cqeErrInfoListData.txData.phyId = phyId;
1690 0 : cqeErrInfoListData.txData.rdevIndex = rdmaHandle->rdevIndex;
1691 0 : cqeErrInfoListData.txData.num = hdcCqeErrNum;
1692 0 : ret = RaHdcProcessMsg(RA_RS_GET_CQE_ERR_INFO_LIST, phyId, (char *)&cqeErrInfoListData,
1693 : sizeof(union OpGetCqeErrInfoListData));
1694 0 : CHK_PRT_RETURN(ret, hccp_err("ra hdc message process failed ret(%d) phyId(%u)", ret, phyId), ret);
1695 :
1696 0 : if (cqeErrInfoListData.rxData.num > hdcCqeErrNum) {
1697 0 : hccp_err("[get][cqe_err_info_list]rx_data.num(%u) is invalid, num(%u), phyId(%u)",
1698 : cqeErrInfoListData.rxData.num, hdcCqeErrNum, phyId);
1699 0 : return -EINVAL;
1700 : }
1701 0 : ret = memcpy_s(&infoList[liteCqeErrNum], sizeof(struct CqeErrInfo) * hdcCqeErrNum,
1702 0 : &cqeErrInfoListData.rxData.infoList, sizeof(struct CqeErrInfo) * cqeErrInfoListData.rxData.num);
1703 0 : if (ret) {
1704 0 : hccp_err("[get][cqe_err_info_list]memcpy_s info_list failed, ret(%d) phyId(%u) num(%u) rxData.num(%u)", ret,
1705 : phyId, hdcCqeErrNum, cqeErrInfoListData.rxData.num);
1706 0 : return ret;
1707 : }
1708 :
1709 0 : *num = liteCqeErrNum + cqeErrInfoListData.rxData.num;
1710 0 : return 0;
1711 : }
1712 :
1713 0 : STATIC int RaHdcLiteCleanCq(struct RaQpHandle *qpHandle, bool isSendCq, unsigned int numEntries)
1714 : {
1715 0 : void *wc = NULL;
1716 : int ret;
1717 :
1718 0 : if (numEntries == 0) {
1719 0 : return 0;
1720 : }
1721 :
1722 0 : wc = calloc(numEntries, sizeof(struct rdma_lite_wc_v2));
1723 0 : if (wc == NULL) {
1724 0 : hccp_err("calloc failed, phyId:%u, qpn:%u", qpHandle->phyId, qpHandle->qpn);
1725 0 : return -ENOMEM;
1726 : }
1727 :
1728 0 : ret = RaHdcLitePollCq(qpHandle, isSendCq, numEntries, wc);
1729 0 : free(wc);
1730 0 : if (ret < 0) {
1731 0 : hccp_err("ra_hdc_lite_poll_cq failed, ret:%d, phyId:%u, qpn:%u", ret, qpHandle->phyId, qpHandle->qpn);
1732 0 : return ret;
1733 : }
1734 :
1735 0 : return 0;
1736 : }
1737 :
1738 0 : STATIC int RaHdcLiteCleanQp(struct RaQpHandle *qpHandle)
1739 : {
1740 0 : unsigned int interfaceVersion = 0;
1741 : int ret;
1742 :
1743 : // check opcode versioin, not support to clean qp
1744 0 : ret = RaHdcGetInterfaceVersion(qpHandle->phyId, RA_RS_QP_BATCH_MODIFY, &interfaceVersion);
1745 0 : if (ret != 0 || interfaceVersion <= RA_RS_OPCODE_BASE_VERSION) {
1746 0 : hccp_warn("RA_RS_QP_BATCH_MODIFY interface_version:%u <= %u, not support to clean qp, phyId:%u, qpn:%u",
1747 : interfaceVersion, RA_RS_OPCODE_BASE_VERSION, qpHandle->phyId, qpHandle->qpn);
1748 0 : return 0;
1749 : }
1750 :
1751 : // lite qp clean
1752 0 : ret = RaRdmaLiteCleanQp(qpHandle->liteQp);
1753 0 : if (ret != 0) {
1754 0 : hccp_err("ra_rdma_lite_clean_qp failed, ret:%d, phyId:%u, qpn:%u", ret, qpHandle->phyId, qpHandle->qpn);
1755 0 : return ret;
1756 : }
1757 :
1758 0 : return 0;
1759 : }
1760 :
1761 2 : STATIC int RaHdcLiteCleanQueue(struct RaQpHandle *qpHandle, int expectStatus)
1762 : {
1763 : int ret;
1764 :
1765 : // not pause status, no need to clean
1766 2 : if (expectStatus != RA_QP_STATUS_PAUSE) {
1767 1 : return 0;
1768 : }
1769 :
1770 : // not lite or not op mode, no need to clean
1771 1 : if ((qpHandle->supportLite == 0) ||
1772 0 : (qpHandle->qpMode != RA_RS_OP_QP_MODE && qpHandle->qpMode != RA_RS_OP_QP_MODE_EXT)) {
1773 1 : return 0;
1774 : }
1775 :
1776 : // poll cq to clean lite send cq
1777 0 : if (qpHandle->sendWrNum > qpHandle->pollCqeNum) {
1778 0 : ret = RaHdcLiteCleanCq(qpHandle, true, qpHandle->sendWrNum - qpHandle->pollCqeNum);
1779 0 : if (ret != 0) {
1780 0 : hccp_err("ra_hdc_lite_clean_cq send_cq failed, ret:%d, phyId:%u, qpn:%u", ret, qpHandle->phyId,
1781 : qpHandle->qpn);
1782 0 : return ret;
1783 : }
1784 : }
1785 :
1786 : // poll cq to clean lite recv cq
1787 0 : if (qpHandle->recvWrNum > qpHandle->pollRecvCqeNum) {
1788 0 : ret = RaHdcLiteCleanCq(qpHandle, false, qpHandle->recvWrNum - qpHandle->pollRecvCqeNum);
1789 0 : if (ret < 0) {
1790 0 : hccp_err("ra_hdc_lite_clean_cq recv_cq failed, ret:%d, phyId:%u, qpn:%u", ret, qpHandle->phyId,
1791 : qpHandle->qpn);
1792 0 : return ret;
1793 : }
1794 : }
1795 :
1796 : // lite qp clean
1797 0 : ret = RaHdcLiteCleanQp(qpHandle);
1798 0 : if (ret != 0) {
1799 0 : hccp_err("ra_hdc_lite_clean_qp failed, ret:%d, phyId:%u, qpn:%u", ret, qpHandle->phyId, qpHandle->qpn);
1800 0 : return ret;
1801 : }
1802 :
1803 0 : return 0;
1804 : }
1805 :
1806 2 : int RaHdcQpBatchModify(struct RaRdmaHandle *rdmaHandle, void *qpHdc[], unsigned int num, int expectStatus)
1807 : {
1808 2 : union OpQpBatchModifyData *qpBatchModifyData = NULL;
1809 2 : unsigned int phyId = rdmaHandle->rdevInfo.phyId;
1810 2 : struct RaQpHandle *qpHandle = NULL;
1811 2 : unsigned int currentSendCnt = 0;
1812 2 : unsigned int completeCnt = 0;
1813 2 : int opQpnCnt = 0;
1814 : unsigned int i;
1815 2 : int ret = 0;
1816 :
1817 2 : qpBatchModifyData = calloc(1, sizeof(union OpQpBatchModifyData));
1818 2 : CHK_PRT_RETURN(qpBatchModifyData == NULL, hccp_err("[send][ra_hdc_qp_batch_modify]qp_batch_modify calloc failed"),
1819 : -ENOMEM);
1820 4 : while (completeCnt < num) {
1821 2 : qpBatchModifyData->txData.phyId = phyId;
1822 2 : qpBatchModifyData->txData.rdevIndex = rdmaHandle->rdevIndex;
1823 2 : qpBatchModifyData->txData.status = expectStatus;
1824 :
1825 2 : currentSendCnt = (num - completeCnt) < RA_MAX_BATCH_QP_MODIFY_NUM ? (num - completeCnt)
1826 : : RA_MAX_BATCH_QP_MODIFY_NUM;
1827 2 : opQpnCnt = 0;
1828 4 : for (i = completeCnt; i < completeCnt + currentSendCnt; i++) {
1829 2 : qpHandle = (struct RaQpHandle *)qpHdc[i];
1830 2 : qpBatchModifyData->txData.qpn[opQpnCnt] = (int)qpHandle->qpn;
1831 2 : opQpnCnt++;
1832 :
1833 : // avoid poll invalid cqe after modify to RESET state, make sure lite cq ci & qp pointer are valid
1834 2 : ret = RaHdcLiteCleanQueue(qpHandle, expectStatus);
1835 2 : if (ret != 0) {
1836 0 : hccp_err("[modify][qp_batch_modify]ra_hdc_lite_clean_queue failed ret(%d) phyId(%u) qpn(%u)", ret,
1837 : phyId, qpHandle->qpn);
1838 0 : goto err_qp_batch_modify;
1839 : }
1840 : }
1841 2 : qpBatchModifyData->txData.qpnNum = opQpnCnt;
1842 :
1843 2 : ret = RaHdcProcessMsg(RA_RS_QP_BATCH_MODIFY, phyId, (char *)qpBatchModifyData,
1844 : sizeof(union OpQpBatchModifyData));
1845 2 : if (ret) {
1846 0 : hccp_err("[modify][qp_batch_modify]ra hdc message process failed ret(%d) phyId(%u)", ret, phyId);
1847 0 : goto err_qp_batch_modify;
1848 : }
1849 2 : completeCnt += (unsigned int)opQpnCnt;
1850 : }
1851 :
1852 2 : err_qp_batch_modify:
1853 2 : free(qpBatchModifyData);
1854 2 : qpBatchModifyData = NULL;
1855 :
1856 2 : return ret;
1857 : }
1858 :
1859 4 : int RaHdcRdmaSetOps(struct RaRdmaHandle *rdmaHandle, struct RaRdmaOps *rdmaOps)
1860 : {
1861 4 : CHK_PRT_RETURN(rdmaHandle == NULL, hccp_err("ra_hdc_rdma_set_ops rdma_handle is NULL"), -EINVAL);
1862 :
1863 4 : rdmaHandle->rdmaOps = rdmaOps;
1864 4 : return 0;
1865 : }
1866 :
1867 0 : int RaHdcRdmaSaveSnapshot(struct RaRdmaHandle *rdmaHandle, enum SaveSnapshotAction action)
1868 : {
1869 0 : int ret = 0;
1870 :
1871 0 : if (rdmaHandle == NULL || rdmaHandle->supportLite == LITE_NOT_SUPPORT || rdmaHandle->disabledLiteThread) {
1872 0 : return 0;
1873 : }
1874 :
1875 0 : RA_PTHREAD_MUTEX_LOCK(&rdmaHandle->rdevMutex);
1876 0 : if (action == SAVE_SNAPSHOT_ACTION_PRE_PROCESSING && rdmaHandle->threadStatus == LITE_THREAD_STATUS_RUNNING) {
1877 0 : rdmaHandle->threadStatus = LITE_THREAD_STATUS_SUSPEND;
1878 0 : } else if (action == SAVE_SNAPSHOT_ACTION_POST_PROCESSING &&
1879 0 : rdmaHandle->threadStatus == LITE_THREAD_STATUS_SUSPEND) {
1880 0 : rdmaHandle->threadStatus = LITE_THREAD_STATUS_RUNNING;
1881 : } else {
1882 0 : hccp_err("duplicate or incorrect order calls are not allowed, threadStatus[%d] action[%d]",
1883 : rdmaHandle->threadStatus, action);
1884 0 : ret = -EPERM;
1885 : }
1886 0 : RA_PTHREAD_MUTEX_UNLOCK(&rdmaHandle->rdevMutex);
1887 :
1888 0 : return ret;
1889 : }
1890 :
1891 0 : int RaHdcRdmaRestoreSnapshot(struct RaRdmaHandle *rdmaHandle, struct RaRdmaOps *rdmaOps)
1892 : {
1893 0 : int ret = 0;
1894 :
1895 0 : if (rdmaHandle == NULL) {
1896 0 : return 0;
1897 : }
1898 0 : ret = RaHdcRdmaSetOps(rdmaHandle, rdmaOps);
1899 0 : CHK_PRT_RETURN(ret != 0, hccp_err("ra_hdc_rdma_set_ops failed, ret[%d]", ret), ret);
1900 :
1901 0 : if (rdmaHandle->supportLite == LITE_NOT_SUPPORT || rdmaHandle->disabledLiteThread) {
1902 0 : return 0;
1903 : }
1904 :
1905 0 : RA_PTHREAD_MUTEX_LOCK(&rdmaHandle->rdevMutex);
1906 0 : if (rdmaHandle->threadStatus != LITE_THREAD_STATUS_SUSPEND) {
1907 0 : hccp_err("incorrect order calls are not allowed, threadStatus[%d]", rdmaHandle->threadStatus);
1908 0 : ret = -EPERM;
1909 0 : goto unlock_mutex;
1910 : }
1911 0 : ret = RaRdmaLiteRestoreSnapshot(rdmaHandle->liteCtx);
1912 0 : if (ret != 0) {
1913 0 : hccp_err("ra_rdma_lite_restore_snapshot failed, ret[%d]", ret);
1914 : }
1915 :
1916 0 : unlock_mutex:
1917 0 : RA_PTHREAD_MUTEX_UNLOCK(&rdmaHandle->rdevMutex);
1918 0 : return ret;
1919 : }
|
