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