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 <unistd.h>
12 : #include <stdlib.h>
13 : #include <sys/types.h>
14 : #include <netinet/in.h>
15 : #include <arpa/inet.h>
16 : #include <dlfcn.h>
17 : #include <urma_opcode.h>
18 : #include <udma_u_ctl.h>
19 : #include "securec.h"
20 : #include "user_log.h"
21 : #include "dl_urma_function.h"
22 : #include "ra_rs_err.h"
23 : #include "ra_rs_ctx.h"
24 : #include "rs_inner.h"
25 : #include "rs_epoll.h"
26 : #include "rs_ctx_inner.h"
27 : #include "rs_ctx.h"
28 : #include "rs_ub_jetty.h"
29 : #include "rs_ub_jfc.h"
30 : #include "rs_ub.h"
31 :
32 0 : int RsUbGetDevEidInfoNum(unsigned int phyId, unsigned int *num)
33 : {
34 0 : urma_eid_info_t *eidList = NULL;
35 0 : urma_device_t **devList = NULL;
36 0 : unsigned int totalNum = 0;
37 0 : unsigned int eidNum = 0;
38 0 : int devNum = 0;
39 0 : int ret = 0;
40 0 : int i = 0;
41 :
42 0 : ret = RsUbApiInit();
43 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_ub_api_init failed, ret:%d", ret), ret);
44 :
45 0 : devList = RsUrmaGetDeviceList(&devNum);
46 0 : if (devList == NULL) {
47 0 : hccp_err("rs_urma_get_device_list failed, errno:%d", errno);
48 0 : ret = -EINVAL;
49 0 : goto ub_api_deinit;
50 : }
51 :
52 0 : for (i = 0; i < devNum; i++) {
53 0 : eidList = RsUrmaGetEidList(devList[i], &eidNum);
54 : // normal case, should continue to get eid_list from the rest of device
55 0 : if (eidList == NULL) {
56 0 : hccp_warn("rs_urma_get_eid_list i=%u unsuccessful, eidList is NULL, errno:%d", i, errno);
57 0 : continue;
58 : }
59 :
60 0 : totalNum += eidNum;
61 0 : RsUrmaFreeEidList(eidList);
62 : }
63 :
64 0 : *num = totalNum;
65 :
66 0 : RsUrmaFreeDeviceList(devList);
67 0 : ub_api_deinit:
68 0 : RsUbApiDeinit();
69 0 : return ret;
70 : }
71 :
72 0 : STATIC int RsUbCreateCtx(urma_device_t *urmaDev, unsigned int eidIndex, urma_context_t **urmaCtx)
73 : {
74 0 : *urmaCtx = RsUrmaCreateContext(urmaDev, eidIndex);
75 0 : CHK_PRT_RETURN(*urmaCtx == NULL, hccp_err("rs_urma_create_context failed! errno:%d, eidIndex:%u",
76 : errno, eidIndex), -ENODEV);
77 :
78 0 : return 0;
79 : }
80 :
81 1 : int RsUbGetUeInfo(urma_context_t *urmaCtx, struct DevBaseAttr *devAttr)
82 : {
83 : #ifdef CUSTOM_INTERFACE
84 1 : struct udma_u_ue_info ueInfo = {0};
85 1 : urma_user_ctl_out_t out = {0};
86 1 : urma_user_ctl_in_t in = {0};
87 : int ret;
88 :
89 1 : in.opcode = UDMA_U_USER_CTL_QUERY_UE_INFO;
90 1 : out.addr = (uint64_t)(uintptr_t)&ueInfo;
91 1 : out.len = sizeof(struct udma_u_ue_info);
92 1 : ret = RsUrmaUserCtl(urmaCtx, &in, &out);
93 1 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_user_ctl query ue info failed! ret:%d errno:%d", ret, errno), -EOPENSRC);
94 :
95 1 : devAttr->ub.dieId = ueInfo.die_id;
96 1 : devAttr->ub.chipId = ueInfo.chip_id;
97 1 : devAttr->ub.funcId = ueInfo.ue_id;
98 1 : hccp_info("func_id:%u, chipId:%u, dieId:%u", devAttr->ub.funcId, devAttr->ub.chipId, devAttr->ub.dieId);
99 : #endif
100 1 : return 0;
101 : }
102 :
103 0 : STATIC int RsUbFillDevEidInfoList(struct HccpDevEidInfo *totalList, unsigned int index, urma_device_t *device,
104 : urma_eid_info_t *eidInfo)
105 : {
106 0 : struct DevBaseAttr devAttr = {0};
107 0 : urma_context_t *urmaCtx = NULL;
108 0 : int ret = 0;
109 :
110 0 : totalList[index].eidIndex = eidInfo->eid_index;
111 0 : totalList[index].type = device->type;
112 :
113 0 : (void)memcpy_s(totalList[index].eid.raw, sizeof(totalList[index].eid.raw), eidInfo->eid.raw,
114 : sizeof(eidInfo->eid.raw));
115 :
116 0 : ret = strcpy_s(totalList[index].name, DEV_EID_INFO_MAX_NAME, device->name);
117 0 : CHK_PRT_RETURN(ret != 0, hccp_err("strcpy device name failed, ret:%d", ret), -ESAFEFUNC);
118 :
119 0 : ret = RsUbCreateCtx(device, eidInfo->eid_index, &urmaCtx);
120 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_ub_create_ctx failed, ret:%d, eidIndex:%u", ret, eidInfo->eid_index), ret);
121 :
122 0 : ret = RsUbGetUeInfo(urmaCtx, &devAttr);
123 0 : if (ret != 0) {
124 0 : hccp_err("rs_ub_get_ue_info failed, ret:%d", ret);
125 0 : goto free_ctx;
126 : }
127 :
128 0 : totalList[index].dieId = devAttr.ub.dieId;
129 0 : totalList[index].chipId = devAttr.ub.chipId;
130 0 : totalList[index].funcId = devAttr.ub.funcId;
131 :
132 0 : free_ctx:
133 0 : (void)RsUrmaDeleteContext(urmaCtx);
134 0 : return ret;
135 : }
136 :
137 0 : STATIC int RsUbFillInfoByEidList(urma_device_t *currDev, unsigned int *index, struct HccpDevEidInfo *totalList,
138 : unsigned int totalNum)
139 : {
140 0 : urma_eid_info_t *eidList = NULL;
141 0 : urma_device_attr_t attr = {0};
142 0 : unsigned int eidNum = 0;
143 : unsigned int j;
144 0 : int ret = 0;
145 :
146 0 : ret = RsUrmaQueryDevice(currDev, &attr);
147 0 : CHK_PRT_RETURN(ret != 0, hccp_err("RsUrmaQueryDevice failed, ret:%d, errno:%d", ret, errno), -EOPENSRC);
148 :
149 0 : eidList = RsUrmaGetEidList(currDev, &eidNum);
150 : // normal case, should continue to get eid_list from the rest of device
151 0 : if (eidList == NULL) {
152 0 : hccp_warn("rs_urma_get_eid_list unsuccessful, eidList is NULL, errno:%d", errno);
153 0 : return 0;
154 : }
155 :
156 0 : for (j = 0; j < eidNum; j++) {
157 0 : if (*index >= totalNum) {
158 0 : hccp_err("index out of range, index:%u, totalNum:%u", *index, totalNum);
159 0 : ret = -EINVAL;
160 0 : goto free_eid_list;
161 : }
162 0 : ret = RsUbFillDevEidInfoList(totalList, *index, currDev, &eidList[j]);
163 0 : if (ret != 0) {
164 0 : hccp_err("rs_ub_fill_dev_eid_info_list failed, index:%u, ret:%d", *index, ret);
165 0 : goto free_eid_list;
166 : }
167 0 : totalList[*index].devFeature = attr.dev_cap.feature.value;
168 0 : *index += 1;
169 : }
170 :
171 0 : free_eid_list:
172 0 : RsUrmaFreeEidList(eidList);
173 0 : return ret;
174 : }
175 :
176 0 : int RsUbGetDevEidInfoList(unsigned int phyId, struct HccpDevEidInfo infoList[], unsigned int startIndex,
177 : unsigned int count)
178 : {
179 0 : struct HccpDevEidInfo *totalList = NULL;
180 0 : urma_device_t **devList = NULL;
181 0 : unsigned int totalNum = 0;
182 0 : unsigned int index = 0;
183 : int devNum, ret, i;
184 :
185 0 : ret = RsUbApiInit();
186 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_ub_api_init failed, ret:%d", ret), ret);
187 :
188 0 : ret = RsUbGetDevEidInfoNum(phyId, &totalNum);
189 0 : if ((ret != 0) || (startIndex > UINT_MAX - count) || (startIndex + count > totalNum)) {
190 0 : hccp_err("rs_ub_get_dev_eid_info_num failed ret:%d data size exceeds the max offset range "
191 : "or start_index:%u + count:%u > total_num:%u", ret, startIndex, count, totalNum);
192 0 : ret = -EINVAL;
193 0 : goto ub_api_deinit;
194 : }
195 :
196 0 : totalList = calloc(totalNum, sizeof(struct HccpDevEidInfo));
197 0 : if (totalList == NULL) {
198 0 : hccp_err("calloc total_list failed, errno:%d", errno);
199 0 : ret = -ENOMEM;
200 0 : goto ub_api_deinit;
201 : }
202 :
203 0 : devList = RsUrmaGetDeviceList(&devNum);
204 0 : if (devList == NULL) {
205 0 : hccp_err("rs_urma_get_device_list failed, errno: %d", errno);
206 0 : ret = -EINVAL;
207 0 : goto free_total_list;
208 : }
209 :
210 0 : for (i = 0; i < devNum; i++) {
211 0 : ret = RsUbFillInfoByEidList(devList[i], &index, totalList, totalNum);
212 0 : if (ret != 0) {
213 0 : goto free_dev_list;
214 : }
215 : }
216 :
217 : // start_index + count <= total_num make sure count is valid
218 0 : (void)memcpy_s(infoList, sizeof(struct HccpDevEidInfo) * count,
219 0 : totalList + startIndex, sizeof(struct HccpDevEidInfo) * count);
220 :
221 0 : free_dev_list:
222 0 : RsUrmaFreeDeviceList(devList);
223 0 : free_total_list:
224 0 : free(totalList);
225 0 : totalList = NULL;
226 0 : ub_api_deinit:
227 0 : RsUbApiDeinit();
228 0 : return ret;
229 : }
230 :
231 2 : int RsUbGetDevCb(struct rs_cb *rscb, unsigned int devIndex, struct RsUbDevCb **devCb)
232 : {
233 2 : struct RsUbDevCb *devCbCurr = NULL;
234 2 : struct RsUbDevCb *devCbNext = NULL;
235 :
236 2 : RS_LIST_GET_HEAD_ENTRY(devCbCurr, devCbNext, &rscb->udevList, list, struct RsUbDevCb);
237 3 : for (; (&devCbCurr->list) != &rscb->udevList;
238 1 : devCbCurr = devCbNext,
239 1 : devCbNext = list_entry(devCbNext->list.next, struct RsUbDevCb, list)) {
240 2 : if (devCbCurr->index == devIndex) {
241 1 : *devCb = devCbCurr;
242 1 : return 0;
243 : }
244 : }
245 :
246 1 : *devCb = NULL;
247 1 : hccp_err("dev_cb for devIndex:0x%x do not available!", devIndex);
248 1 : return -ENODEV;
249 : }
250 :
251 0 : STATIC int RsUbGetDevAttr(struct RsUbDevCb *devCb, struct DevBaseAttr *devAttr, unsigned int *devIndex)
252 : {
253 0 : urma_device_attr_t attr = {0};
254 : int ret;
255 : int i;
256 :
257 0 : ret = RsUrmaQueryDevice(devCb->urmaDev, &attr);
258 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_query_device failed ret:%d", ret), -EOPENSRC);
259 :
260 0 : devAttr->sqMaxDepth = attr.dev_cap.max_jfs_depth;
261 0 : devAttr->rqMaxDepth = attr.dev_cap.max_jfr_depth;
262 0 : devAttr->sqMaxSge = attr.dev_cap.max_jfs_sge;
263 0 : devAttr->rqMaxSge = attr.dev_cap.max_jfr_sge;
264 0 : devAttr->ub.maxJfsInlineLen = attr.dev_cap.max_jfs_inline_len;
265 0 : devAttr->ub.maxJfsRsge = attr.dev_cap.max_jfs_rsge;
266 0 : devAttr->maxReadSize = attr.dev_cap.max_read_size;
267 0 : devAttr->maxWriteSize = attr.dev_cap.max_write_size;
268 0 : devAttr->maxMsgSize = attr.dev_cap.max_msg_size;
269 0 : devAttr->ub.rmTpCap.value = attr.dev_cap.rm_tp_cap.value;
270 0 : devAttr->ub.rcTpCap.value = attr.dev_cap.rc_tp_cap.value;
271 0 : devAttr->ub.umTpCap.value = attr.dev_cap.um_tp_cap.value;
272 0 : devAttr->ub.tpFeat.value = attr.dev_cap.tp_feature.value;
273 0 : for (i = 0; i < MAX_PRIORITY_CNT && i < URMA_MAX_PRIORITY_CNT; i++) {
274 0 : devAttr->ub.priorityInfo[i].SL = attr.dev_cap.priority_info[i].SL;
275 0 : devAttr->ub.priorityInfo[i].tpType.value = attr.dev_cap.priority_info[i].tp_type.value;
276 : }
277 0 : ret = RsUbGetUeInfo(devCb->urmaCtx, devAttr);
278 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_ub_get_ue_info failed ret:%d", ret), -EOPENSRC);
279 :
280 0 : (void)memcpy_s(&devCb->devAttr, sizeof(struct DevBaseAttr), devAttr, sizeof(struct DevBaseAttr));
281 0 : devCb->rscb->devCnt++;
282 0 : *devIndex = RsGenerateDevIndex(devCb->rscb->devCnt, devAttr->ub.dieId, devAttr->ub.funcId);
283 0 : devCb->index = *devIndex;
284 :
285 0 : hccp_info("max_jetty:%u, maxJfsInlineLen:%u, sqMaxDepth:%u, rqMaxDepth:%u, sqMaxSge:%u, rqMaxSge:%u "
286 : "maxReadSize:%u maxWriteSize:%u maxMsgSize:%llu", attr.dev_cap.max_jetty,
287 : devAttr->ub.maxJfsInlineLen, devAttr->sqMaxDepth, devAttr->rqMaxDepth, devAttr->sqMaxSge, devAttr->rqMaxSge,
288 : devAttr->maxReadSize, devAttr->maxWriteSize, devAttr->maxMsgSize);
289 0 : return 0;
290 : }
291 :
292 0 : STATIC int RsUbDevShareJfrInit(struct RsUbDevCb *devCb)
293 : {
294 0 : urma_jfc_cfg_t jfcCfg = {0};
295 0 : urma_jfr_cfg_t jfrCfg = {0};
296 0 : int randNum = 0;
297 : int ret;
298 :
299 0 : jfcCfg.depth = CQ_DEFAULT_MIN_RECV_DEPTH;
300 0 : devCb->shareJfc = RsUrmaCreateJfc(devCb->urmaCtx, &jfcCfg);
301 0 : CHK_PRT_RETURN(devCb->shareJfc == NULL, hccp_err("RsUrmaCreateJfc failed, errno:%d", errno), -ENOMEM);
302 :
303 0 : jfrCfg.depth = CQ_DEFAULT_MIN_RECV_DEPTH;
304 0 : jfrCfg.flag.bs.tag_matching = URMA_NO_TAG_MATCHING;
305 0 : jfrCfg.trans_mode = URMA_TM_RM;
306 0 : jfrCfg.max_sge = QP_DEFAULT_MIN_CAP_RECV_SGE;
307 0 : jfrCfg.min_rnr_timer = URMA_TYPICAL_MIN_RNR_TIMER;
308 0 : jfrCfg.jfc = devCb->shareJfc;
309 0 : ret = RsDrvGetRandomNum(&randNum);
310 0 : if (ret != 0) {
311 0 : hccp_err("RsDrvGetRandomNum failed, ret:%d", ret);
312 0 : goto delete_jfc;
313 : }
314 0 : jfrCfg.token_value.token = (uint32_t)randNum;
315 0 : devCb->shareJfr = RsUrmaCreateJfr(devCb->urmaCtx, &jfrCfg);
316 0 : if (devCb->shareJfr == NULL) {
317 0 : hccp_err("RsUrmaCreateJfr failed, errno:%d", errno);
318 0 : ret = -ENOMEM;
319 0 : goto delete_jfc;
320 : }
321 :
322 0 : return 0;
323 :
324 0 : delete_jfc:
325 0 : RsUrmaDeleteJfc(devCb->shareJfc);
326 0 : devCb->shareJfc = NULL;
327 0 : return ret;
328 : }
329 :
330 0 : STATIC void RsUbDevShareJfrDeinit(struct RsUbDevCb *devCb)
331 : {
332 0 : (void)RsUrmaDeleteJfr(devCb->shareJfr);
333 0 : devCb->shareJfr = NULL;
334 0 : (void)RsUrmaDeleteJfc(devCb->shareJfc);
335 0 : devCb->shareJfc = NULL;
336 0 : }
337 :
338 0 : STATIC int RsUbDevCbInit(struct CtxInitAttr *attr, struct RsUbDevCb *devCb, struct rs_cb *rscb,
339 : unsigned int *devIndex, struct DevBaseAttr *devAttr)
340 : {
341 : int ret;
342 :
343 0 : devCb->rscb = rscb;
344 0 : devCb->phyId = attr->phyId;
345 0 : devCb->eidIndex = attr->ub.eidIndex;
346 0 : devCb->eid = attr->ub.eid;
347 :
348 0 : ret = pthread_mutex_init(&devCb->mutex, NULL);
349 0 : CHK_PRT_RETURN(ret != 0, hccp_err("mutex_init failed ret:%d", ret), -ESYSFUNC);
350 :
351 0 : RS_INIT_LIST_HEAD(&devCb->asyncEventList);
352 0 : RS_INIT_LIST_HEAD(&devCb->jfceList);
353 0 : RS_INIT_LIST_HEAD(&devCb->jfcList);
354 0 : RS_INIT_LIST_HEAD(&devCb->jettyList);
355 0 : RS_INIT_LIST_HEAD(&devCb->rjettyList);
356 0 : RS_INIT_LIST_HEAD(&devCb->tokenIdList);
357 0 : RS_INIT_LIST_HEAD(&devCb->lsegList);
358 0 : RS_INIT_LIST_HEAD(&devCb->rsegList);
359 :
360 0 : ret = RsUbCreateCtx(devCb->urmaDev, attr->ub.eidIndex, &(devCb->urmaCtx));
361 0 : if (ret != 0) {
362 0 : hccp_err("rs_ub_create_ctx failed, ret:%d", ret);
363 0 : goto destroy_mutex;
364 : }
365 :
366 0 : ret = RsUbDevShareJfrInit(devCb);
367 0 : if (ret != 0) {
368 0 : hccp_err("RsUbDevShareJfrInit failed, ret:%d", ret);
369 0 : goto close_dev;
370 : }
371 :
372 0 : ret = RsEpollCtl(devCb->rscb->connCb.epollfd, EPOLL_CTL_ADD, devCb->urmaCtx->async_fd, EPOLLIN | EPOLLRDHUP);
373 0 : if (ret != 0) {
374 0 : hccp_err("rs_epoll_ctl failed, ret:%d fd:%d", ret, devCb->urmaCtx->async_fd);
375 0 : goto free_share_jfr;
376 : }
377 :
378 0 : ret = RsUbGetDevAttr(devCb, devAttr, devIndex);
379 0 : if (ret != 0) {
380 0 : hccp_err("rs_ub_get_dev_attr failed, ret:%d", ret);
381 0 : goto epoll_del;
382 : }
383 :
384 0 : return 0;
385 :
386 0 : epoll_del:
387 0 : (void)RsEpollCtl(devCb->rscb->connCb.epollfd, EPOLL_CTL_DEL, devCb->urmaCtx->async_fd, EPOLLIN | EPOLLRDHUP);
388 0 : free_share_jfr:
389 0 : RsUbDevShareJfrDeinit(devCb);
390 0 : close_dev:
391 0 : (void)RsUrmaDeleteContext(devCb->urmaCtx);
392 0 : destroy_mutex:
393 0 : pthread_mutex_destroy(&devCb->mutex);
394 0 : return ret;
395 : }
396 :
397 1 : int RsUbCtxInit(struct rs_cb *rsCb, struct CtxInitAttr *attr, unsigned int *devIndex,
398 : struct DevBaseAttr *devAttr)
399 : {
400 1 : struct RsUbDevCb *devCb = NULL;
401 : urma_eid_t eid;
402 : int ret;
403 :
404 1 : ret = RsUbApiInit();
405 1 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_ub_api_init failed, ret:%d", ret), ret);
406 :
407 1 : devCb = calloc(1, sizeof(struct RsUbDevCb));
408 1 : if (devCb == NULL) {
409 0 : hccp_err("calloc for dev_cb failed, errno:%d", errno);
410 0 : ret = -ENOMEM;
411 0 : goto ub_api_deinit;
412 : }
413 :
414 1 : (void)memcpy_s(eid.raw, sizeof(eid.raw), attr->ub.eid.raw, sizeof(attr->ub.eid.raw));
415 :
416 1 : devCb->urmaDev = RsUrmaGetDeviceByEid(eid, URMA_TRANSPORT_UB);
417 1 : if (devCb->urmaDev == NULL) {
418 1 : hccp_err("rs_urma_get_device_by_eid failed, urmaDev is NULL, errno:%d eid:%016llx:%016llx", errno,
419 : (unsigned long long)be64toh(eid.in6.subnet_prefix), (unsigned long long)be64toh(eid.in6.interface_id));
420 1 : ret = -EINVAL;
421 1 : goto free_dev_cb;
422 : }
423 :
424 0 : ret = RsSensorNodeRegister(attr->phyId, rsCb);
425 0 : if (ret != 0) {
426 0 : hccp_err("rs_sensor_node_register failed, phyId(%u), ret(%d)", attr->phyId, ret);
427 0 : goto free_dev_cb;
428 : }
429 :
430 0 : ret = RsUbDevCbInit(attr, devCb, rsCb, devIndex, devAttr);
431 0 : if (ret != 0) {
432 0 : RsSensorNodeUnregister(devCb->rscb);
433 0 : hccp_err("rs_ub_dev_cb_init failed ret:%d, eidIndex:%u eid:%016llx:%016llx", ret, attr->ub.eidIndex,
434 : (unsigned long long)be64toh(eid.in6.subnet_prefix), (unsigned long long)be64toh(eid.in6.interface_id));
435 0 : goto free_dev_cb;
436 : }
437 :
438 0 : RS_PTHREAD_MUTEX_LOCK(&rsCb->mutex);
439 0 : RsListAddTail(&devCb->list, &rsCb->udevList);
440 0 : RS_PTHREAD_MUTEX_ULOCK(&rsCb->mutex);
441 :
442 0 : hccp_run_info("[init][rs_ctx]phy_id:%u, eidIndex:%u, devIndex:0x%x init success", attr->phyId,
443 : attr->ub.eidIndex, *devIndex);
444 :
445 0 : return 0;
446 :
447 1 : free_dev_cb:
448 1 : free(devCb);
449 1 : devCb = NULL;
450 1 : ub_api_deinit:
451 1 : RsUbApiDeinit();
452 1 : return ret;
453 : }
454 :
455 2 : int RsUbGetEidByIp(struct RsUbDevCb *devCb, struct IpInfo ip[], union HccpEid eid[], unsigned int *num)
456 : {
457 2 : urma_net_addr_t netAddr = {0};
458 2 : unsigned int ipNum = *num;
459 2 : urma_eid_t urmaEid = {0};
460 : unsigned int i;
461 2 : int ret = 0;
462 :
463 2 : *num = 0;
464 34 : for (i = 0; i < ipNum; i++) {
465 33 : netAddr.sin_family = (sa_family_t)ip[i].family;
466 33 : if (netAddr.sin_family == AF_INET) {
467 32 : netAddr.in4 = ip[i].ip.addr;
468 : } else {
469 1 : netAddr.in6 = ip[i].ip.addr6;
470 : }
471 33 : ret = RsUrmaGetEidByIp(devCb->urmaCtx, &netAddr, &urmaEid);
472 33 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_get_eid_by_ip failed, ret:%d devIndex:0x%x", ret, devCb->index),
473 : -EOPENSRC);
474 32 : (void)memcpy_s(eid[i].raw, sizeof(union HccpEid), urmaEid.raw, sizeof(urma_eid_t));
475 32 : (*num)++;
476 : }
477 :
478 1 : return ret;
479 : }
480 :
481 0 : STATIC int RsUbGetJfcCb(struct RsUbDevCb *devCb, unsigned long long addr, struct RsCtxJfcCb **jfcCb)
482 : {
483 0 : struct RsCtxJfcCb **tempJfcCb = jfcCb;
484 0 : struct RsCtxJfcCb *jfcCbCurr = NULL;
485 0 : struct RsCtxJfcCb *jfcCbNext = NULL;
486 :
487 0 : RS_LIST_GET_HEAD_ENTRY(jfcCbCurr, jfcCbNext, &devCb->jfcList, list, struct RsCtxJfcCb);
488 0 : for (; (&jfcCbCurr->list) != &devCb->jfcList;
489 0 : jfcCbCurr = jfcCbNext,
490 0 : jfcCbNext = list_entry(jfcCbNext->list.next, struct RsCtxJfcCb, list)) {
491 0 : if (jfcCbCurr->jfcAddr == addr) {
492 0 : *tempJfcCb = jfcCbCurr;
493 0 : return 0;
494 : }
495 : }
496 :
497 0 : *tempJfcCb = NULL;
498 0 : hccp_err("jfc_cb for jfc_addr:0x%llx do not available!", addr);
499 :
500 0 : return -ENODEV;
501 : }
502 :
503 0 : STATIC int RsUbFreeJfcCb(struct RsUbDevCb *devCb, struct RsCtxJfcCb *jfcCb)
504 : {
505 0 : urma_jfc_t *urmaJfc = NULL;
506 0 : int ret = 0;
507 :
508 0 : RsListDel(&jfcCb->list);
509 0 : devCb->jfcCnt--;
510 :
511 0 : if (jfcCb->jfcType == JFC_MODE_STARS_POLL || jfcCb->jfcType == JFC_MODE_CCU_POLL ||
512 0 : jfcCb->jfcType == JFC_MODE_USER_CTL_NORMAL) {
513 0 : (void)RsUbDeleteJfcExt(devCb, jfcCb);
514 0 : hccp_info("[deinit][rs_jfc]destroy success, dev jfcCnt:%u", devCb->jfcCnt);
515 0 : } else if (jfcCb->jfcType == JFC_MODE_NORMAL) {
516 0 : urmaJfc = (urma_jfc_t *)(uintptr_t)jfcCb->jfcAddr;
517 0 : (void)RsUrmaDeleteJfc(urmaJfc);
518 0 : hccp_info("[deinit][rs_jfc]destroy success, dev jfcCnt:%u", devCb->jfcCnt);
519 : } else {
520 0 : hccp_err("jfc_type:%d is invalid, not support!", jfcCb->jfcType);
521 0 : ret = -EINVAL;
522 : }
523 :
524 0 : free(jfcCb);
525 0 : jfcCb = NULL;
526 0 : return ret;
527 : }
528 :
529 1 : int RsUbCtxJfcDestroy(struct RsUbDevCb *devCb, unsigned long long addr)
530 : {
531 1 : struct RsCtxJfcCb *jfcCb = NULL;
532 : int ret;
533 :
534 1 : hccp_info("[deinit][rs_jfc]destroy addr:0x%llx", addr);
535 :
536 1 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
537 1 : ret = RsUbGetJfcCb(devCb, addr, &jfcCb);
538 1 : if (ret != 0) {
539 1 : hccp_err("get jfc_cb failed, ret:%d, jfc addr:0x%llx", ret, addr);
540 1 : goto out;
541 : }
542 :
543 0 : ret = RsUbFreeJfcCb(devCb, jfcCb);
544 1 : out:
545 1 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
546 1 : return ret;
547 : }
548 :
549 0 : STATIC void RsUbFreeJfcCbList(struct RsUbDevCb *devCb, struct RsListHead *jfcList)
550 : {
551 0 : struct RsCtxJfcCb *jfcCurr = NULL;
552 0 : struct RsCtxJfcCb *jfcNext = NULL;
553 : int ret;
554 :
555 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
556 0 : if (!RsListEmpty(jfcList)) {
557 0 : hccp_warn("jfc list do not empty!");
558 0 : RS_LIST_GET_HEAD_ENTRY(jfcCurr, jfcNext, jfcList, list, struct RsCtxJfcCb);
559 0 : for (; (&jfcCurr->list) != jfcList;
560 0 : jfcCurr = jfcNext, jfcNext = list_entry(jfcNext->list.next, struct RsCtxJfcCb, list)) {
561 0 : ret = RsUbFreeJfcCb(devCb, jfcCurr);
562 0 : if (ret != 0) {
563 0 : hccp_err("rs_ub_free_jfc_cb failed, ret:%d", ret);
564 : }
565 : }
566 : }
567 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
568 0 : }
569 :
570 0 : STATIC int RsUbFreeSegCb(struct RsUbDevCb *devCb, struct RsSegCb *segCb)
571 : {
572 : int ret;
573 :
574 0 : ret = RsUrmaUnregisterSeg(segCb->segment);
575 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_unregister_seg failed ret:%d", ret), -EOPENSRC);
576 :
577 0 : RsListDel(&segCb->list);
578 0 : devCb->lsegCnt--;
579 0 : free(segCb);
580 0 : segCb = NULL;
581 :
582 0 : return 0;
583 : }
584 :
585 0 : STATIC void RsUbFreeSegCbList(struct RsUbDevCb *devCb, struct RsListHead *lsegList,
586 : struct RsListHead *rsegList)
587 : {
588 0 : struct RsSegCb *segCurr = NULL;
589 0 : struct RsSegCb *segNext = NULL;
590 : int ret;
591 :
592 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
593 0 : if (!RsListEmpty(lsegList)) {
594 0 : hccp_warn("lseg list do not empty!");
595 0 : RS_LIST_GET_HEAD_ENTRY(segCurr, segNext, lsegList, list, struct RsSegCb);
596 0 : for (; (&segCurr->list) != lsegList;
597 0 : segCurr = segNext, segNext = list_entry(segNext->list.next, struct RsSegCb, list)) {
598 0 : ret = RsUbFreeSegCb(devCb, segCurr);
599 0 : if (ret != 0) {
600 0 : hccp_err("rs_ub_free_seg_cb failed, ret:%d", ret);
601 : }
602 : }
603 : }
604 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
605 :
606 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
607 0 : if (!RsListEmpty(rsegList)) {
608 0 : hccp_warn("rseg list do not empty!");
609 0 : RS_LIST_GET_HEAD_ENTRY(segCurr, segNext, rsegList, list, struct RsSegCb);
610 0 : for (; (&segCurr->list) != rsegList;
611 0 : segCurr = segNext, segNext = list_entry(segNext->list.next, struct RsSegCb, list)) {
612 0 : (void)RsUrmaUnimportSeg(segCurr->segment);
613 0 : RsListDel(&segCurr->list);
614 0 : free(segCurr);
615 0 : segCurr = NULL;
616 : }
617 : }
618 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
619 0 : }
620 :
621 0 : STATIC void RsUbCtxFreeJettyCb(struct RsCtxJettyCb *jettyCb)
622 : {
623 0 : struct RsCtxJettyCb *tmpJettyCb = jettyCb;
624 :
625 : #ifdef CUSTOM_INTERFACE
626 0 : if (jettyCb->qpShareInfoAddr != NULL) {
627 0 : (void)DlHalBuffFree((void *)(uintptr_t)jettyCb->qpShareInfoAddr);
628 0 : jettyCb->qpShareInfoAddr = NULL;
629 : }
630 : #endif
631 :
632 0 : pthread_mutex_destroy(&tmpJettyCb->crErrInfo.mutex);
633 0 : pthread_mutex_destroy(&tmpJettyCb->mutex);
634 0 : free(tmpJettyCb);
635 0 : tmpJettyCb = NULL;
636 0 : }
637 :
638 0 : STATIC void RsUbCtxDrvJettyDelete(struct RsCtxJettyCb *jettyCb)
639 : {
640 0 : if (jettyCb->jettyMode == JETTY_MODE_URMA_NORMAL) {
641 0 : (void)RsUrmaDeleteJetty(jettyCb->jetty);
642 : } else {
643 0 : RsUbCtxExtJettyDelete(jettyCb);
644 : }
645 :
646 : // ccu jetty unreg db addr
647 0 : if (jettyCb->jettyMode == JETTY_MODE_CCU || jettyCb->jettyMode == JETTY_MODE_CCU_TA_CACHE) {
648 0 : (void)RsUbCtxLmemUnreg(jettyCb->devCb, jettyCb->dbSegHandle);
649 : }
650 0 : }
651 :
652 0 : STATIC int RsUbFreeRemJettyCb(struct RsUbDevCb *devCb, struct RsCtxRemJettyCb *rjettyCb)
653 : {
654 0 : unsigned int remJettyId = rjettyCb->tjetty->id.id;
655 0 : unsigned int devIndex = devCb->index;
656 : int ret;
657 :
658 0 : RsListDel(&rjettyCb->list);
659 0 : devCb->rjettyCnt--;
660 :
661 0 : ret = RsUrmaUnimportJetty(rjettyCb->tjetty);
662 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_unimport_jetty failed, ret:%d, devIndex:0x%x, remJettyId %u",
663 : ret, devIndex, remJettyId), -EOPENSRC);
664 :
665 0 : free(rjettyCb);
666 0 : rjettyCb = NULL;
667 :
668 0 : return 0;
669 : }
670 :
671 0 : STATIC void RsUbUnbindJettyCbList(struct RsUbDevCb *devCb, struct RsListHead *jettyList)
672 : {
673 0 : struct RsCtxJettyCb *jettyCurr = NULL;
674 0 : struct RsCtxJettyCb *jettyNext = NULL;
675 : int ret;
676 :
677 0 : if (!RsListEmpty(jettyList)) {
678 0 : hccp_warn("jetty list do not empty! start to unbind");
679 0 : RS_LIST_GET_HEAD_ENTRY(jettyCurr, jettyNext, jettyList, list, struct RsCtxJettyCb);
680 0 : for (; (&jettyCurr->list) != jettyList;
681 0 : jettyCurr = jettyNext, jettyNext = list_entry(jettyNext->list.next, struct RsCtxJettyCb, list)) {
682 : // no need to unbind
683 0 : if (jettyCurr->state != RS_JETTY_STATE_BIND) {
684 0 : continue;
685 : }
686 0 : hccp_info("jetty_id[%u] will be unbind", jettyCurr->jetty->jetty_id.id);
687 0 : ret = RsUrmaUnbindJetty(jettyCurr->jetty);
688 0 : if (ret != 0) {
689 0 : hccp_err("rs_urma_unbind_jetty failed, ret:%d errno:%d devIndex:0x%x jetty_id:%u",
690 : ret, errno, devCb->index, jettyCurr->jetty->jetty_id.id);
691 : }
692 0 : jettyCurr->state = RS_JETTY_STATE_CREATED;
693 : }
694 : }
695 0 : }
696 :
697 0 : STATIC void RsUbUnimportJettyCbList(struct RsUbDevCb *devCb, struct RsListHead *rjettyList)
698 : {
699 0 : struct RsCtxRemJettyCb *remJettyCurr = NULL;
700 0 : struct RsCtxRemJettyCb *remJettyNext = NULL;
701 : int ret;
702 :
703 0 : if (!RsListEmpty(rjettyList)) {
704 0 : hccp_warn("rjetty list do not empty! start to unimport");
705 0 : RS_LIST_GET_HEAD_ENTRY(remJettyCurr, remJettyNext, rjettyList, list, struct RsCtxRemJettyCb);
706 0 : for (; (&remJettyCurr->list) != rjettyList;
707 0 : remJettyCurr = remJettyNext, remJettyNext = list_entry(remJettyNext->list.next,
708 : struct RsCtxRemJettyCb, list)) {
709 : // no need to unimport
710 0 : if (remJettyCurr->state != RS_JETTY_STATE_IMPORTED) {
711 0 : continue;
712 : }
713 0 : hccp_info("rjetty_id[%u] will be destroyed", remJettyCurr->tjetty->id.id);
714 0 : ret = RsUbFreeRemJettyCb(devCb, remJettyCurr);
715 0 : if (ret != 0) {
716 0 : hccp_err("rs_ub_ctx_jetty_unimport failed, ret:%d", ret);
717 : }
718 : }
719 : }
720 0 : }
721 :
722 7 : STATIC int RsUbCallocJettyBatchInfo(struct JettyDestroyBatchInfo *batchInfo, unsigned int num)
723 : {
724 7 : batchInfo->jettyCbArr = calloc(num, sizeof(struct RsCtxJettyCb *));
725 7 : CHK_PRT_RETURN(batchInfo->jettyCbArr == NULL, hccp_err("calloc jetty_cb_arr failed"), -ENOMEM);
726 7 : batchInfo->jettyArr = calloc(num, sizeof(urma_jetty_t *));
727 7 : CHK_PRT_RETURN(batchInfo->jettyArr == NULL, hccp_err("calloc jetty_arr failed"), -ENOMEM);
728 :
729 7 : return 0;
730 : }
731 :
732 8 : STATIC void RsUbFreeJettyBatchInfo(struct JettyDestroyBatchInfo *batchInfo)
733 : {
734 8 : if (batchInfo->jettyCbArr != NULL) {
735 7 : free(batchInfo->jettyCbArr);
736 7 : batchInfo->jettyCbArr = NULL;
737 : }
738 8 : if (batchInfo->jettyArr != NULL) {
739 7 : free(batchInfo->jettyArr);
740 7 : batchInfo->jettyArr = NULL;
741 : }
742 8 : }
743 :
744 0 : STATIC void RsUbFreeJettyCbBatch(struct JettyDestroyBatchInfo *batchInfo, unsigned int *num,
745 : urma_jetty_t *badJetty, urma_jfr_t *badJfr)
746 : {
747 0 : unsigned int jettyDestroyNum = *num;
748 : unsigned int i;
749 :
750 0 : for (i = 0; i < *num; ++i) {
751 : // ccu jetty unreg db addr
752 0 : if (batchInfo->jettyCbArr[i]->jettyMode == JETTY_MODE_CCU ||
753 0 : batchInfo->jettyCbArr[i]->jettyMode == JETTY_MODE_CCU_TA_CACHE) {
754 0 : (void)RsUbCtxLmemUnreg(batchInfo->jettyCbArr[i]->devCb, batchInfo->jettyCbArr[i]->dbSegHandle);
755 : }
756 0 : RsUbCtxFreeJettyCb(batchInfo->jettyCbArr[i]);
757 :
758 0 : if (batchInfo->jettyArr[i] == badJetty) {
759 0 : jettyDestroyNum = i;
760 : }
761 : }
762 0 : *num = jettyDestroyNum;
763 0 : }
764 :
765 2 : STATIC int RsUbDestroyJettyCbBatch(struct JettyDestroyBatchInfo *batchInfo, unsigned int *num)
766 : {
767 2 : urma_jetty_t *badJetty = NULL;
768 2 : urma_jfr_t *badJfr = NULL;
769 2 : int jettyDestroyRet = 0;
770 :
771 2 : RsUbVaMunmapBatch(batchInfo->jettyCbArr, *num);
772 2 : jettyDestroyRet = RsUrmaDeleteJettyBatch(batchInfo->jettyArr, (int)*num, &badJetty);
773 2 : if (jettyDestroyRet != 0) {
774 1 : hccp_err("rs_urma_delete_jetty_batch failed, jettyDestroyRet:%d, num:%u", jettyDestroyRet, *num);
775 : }
776 :
777 2 : RsUbFreeJettyIdBatch(batchInfo->jettyCbArr, *num);
778 2 : RsUbFreeJettyCbBatch(batchInfo, num, badJetty, badJfr);
779 2 : return jettyDestroyRet;
780 : }
781 :
782 0 : STATIC void RsUbDestroyJettyCbList(struct RsUbDevCb *devCb, struct RsListHead *jettyList)
783 : {
784 0 : struct JettyDestroyBatchInfo batchInfo = {0};
785 0 : struct RsCtxJettyCb *jettyCurr = NULL;
786 0 : struct RsCtxJettyCb *jettyNext = NULL;
787 0 : unsigned int num = 0, i = 0;
788 : int ret;
789 :
790 0 : if (RsListEmpty(jettyList)) {
791 0 : return;
792 : }
793 :
794 0 : hccp_warn("jetty list is not empty! start to delete");
795 0 : ret = RsUbCallocJettyBatchInfo(&batchInfo, devCb->jettyCnt);
796 0 : if (ret != 0) {
797 0 : hccp_err("rs_ub_calloc_jetty_batch_info failed, ret:%d", ret);
798 0 : goto free_batch_info;
799 : }
800 :
801 0 : RS_LIST_GET_HEAD_ENTRY(jettyCurr, jettyNext, jettyList, list, struct RsCtxJettyCb);
802 0 : for (; (&jettyCurr->list) != jettyList;
803 0 : jettyCurr = jettyNext, jettyNext = list_entry(jettyNext->list.next, struct RsCtxJettyCb, list)) {
804 : // no need to destroy
805 0 : if (jettyCurr->state != RS_JETTY_STATE_CREATED) {
806 0 : continue;
807 : }
808 0 : hccp_info("jetty_id[%u] will be destroyed", jettyCurr->jetty->jetty_id.id);
809 0 : batchInfo.jettyCbArr[i] = jettyCurr;
810 0 : batchInfo.jettyArr[i] = jettyCurr->jetty;
811 :
812 0 : RsListDel(&jettyCurr->list);
813 0 : devCb->jettyCnt--;
814 0 : i++;
815 : }
816 :
817 0 : num = i;
818 0 : if (num != 0) {
819 0 : ret = RsUbDestroyJettyCbBatch(&batchInfo, &num);
820 0 : if (ret != 0) {
821 0 : hccp_err("rs_ub_ctx_jetty_destroy_batch failed, ret:%d, need to be destroyed:%u, actually destroyed:%u",
822 : ret, i, num);
823 : }
824 : }
825 :
826 0 : free_batch_info:
827 0 : RsUbFreeJettyBatchInfo(&batchInfo);
828 : }
829 :
830 0 : void RsUbFreeJettyCbList(struct RsUbDevCb *devCb, struct RsListHead *jettyList,
831 : struct RsListHead *rjettyList)
832 : {
833 : // free jetty step: unbind -> unimport -> delete
834 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
835 0 : RsUbUnbindJettyCbList(devCb, jettyList);
836 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
837 :
838 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
839 0 : RsUbUnimportJettyCbList(devCb, rjettyList);
840 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
841 :
842 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
843 0 : RsUbDestroyJettyCbList(devCb, jettyList);
844 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
845 0 : }
846 :
847 2 : int RsUbCtxChanCreate(struct RsUbDevCb *devCb, union DataPlaneCstmFlag dataPlaneFlag,
848 : unsigned long long *addr, int *fd)
849 : {
850 2 : struct RsCtxJfceCb *jfceCb = NULL;
851 2 : urma_jfce_t *outJfce = NULL;
852 2 : int ret = 0;
853 :
854 2 : jfceCb = calloc(1, sizeof(struct RsCtxJfceCb));
855 2 : CHK_PRT_RETURN(jfceCb == NULL, hccp_err("calloc jfce_cb failed"), -ENOMEM);
856 :
857 2 : jfceCb->devCb = devCb;
858 2 : outJfce = RsUrmaCreateJfce(devCb->urmaCtx);
859 2 : if (outJfce == NULL) {
860 1 : hccp_err("rs_urma_create_jfce failed, errno:%d", errno);
861 1 : ret = -EOPENSRC;
862 1 : goto free_ctx_jfce_cb;
863 : }
864 :
865 1 : jfceCb->jfceAddr = (uint64_t)(uintptr_t)outJfce; // urma_jfce_t *
866 1 : *addr = jfceCb->jfceAddr;
867 :
868 1 : if (dataPlaneFlag.bs.pollCqCstm == 0) {
869 1 : ret = RsEpollCtl(devCb->rscb->connCb.epollfd, EPOLL_CTL_ADD, outJfce->fd, EPOLLIN | EPOLLRDHUP);
870 1 : if (ret != 0) {
871 1 : hccp_err("rs_epoll_ctl failed ret:%d, fd:%d", ret, devCb->rscb->connCb.epollfd);
872 1 : goto delete_jfce;
873 : }
874 : }
875 0 : jfceCb->dataPlaneFlag = dataPlaneFlag;
876 :
877 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
878 0 : RsListAddTail(&jfceCb->list, &devCb->jfceList);
879 0 : jfceCb->devCb->jfceCnt++;
880 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
881 :
882 0 : *fd = outJfce->fd;
883 0 : hccp_info("dev_index:0x%x jfce addr:0x%llx fd:%d", devCb->index, jfceCb->jfceAddr, outJfce->fd);
884 0 : return ret;
885 :
886 1 : delete_jfce:
887 1 : (void)RsUrmaDeleteJfce(outJfce);
888 2 : free_ctx_jfce_cb:
889 2 : free(jfceCb);
890 2 : jfceCb = NULL;
891 2 : return ret;
892 : }
893 :
894 0 : STATIC int RsUbGetJfceCb(struct RsUbDevCb *devCb, unsigned long long addr, struct RsCtxJfceCb **jfceCb)
895 : {
896 0 : struct RsCtxJfceCb **tempJfceCb = jfceCb;
897 0 : struct RsCtxJfceCb *jfceCbCurr = NULL;
898 0 : struct RsCtxJfceCb *jfceCbNext = NULL;
899 :
900 0 : RS_LIST_GET_HEAD_ENTRY(jfceCbCurr, jfceCbNext, &devCb->jfceList, list, struct RsCtxJfceCb);
901 0 : for (; (&jfceCbCurr->list) != (&devCb->jfceList);
902 0 : jfceCbCurr = jfceCbNext,
903 0 : jfceCbNext = list_entry(jfceCbNext->list.next, struct RsCtxJfceCb, list)) {
904 0 : if (jfceCbCurr->jfceAddr == addr) {
905 0 : *tempJfceCb = jfceCbCurr;
906 0 : return 0;
907 : }
908 : }
909 :
910 0 : *tempJfceCb = NULL;
911 0 : hccp_err("jfce_cb for jfce_addr:0x%llx do not available!", addr);
912 :
913 0 : return -ENODEV;
914 : }
915 :
916 0 : int RsUbCtxChanDestroy(struct RsUbDevCb *devCb, unsigned long long addr)
917 : {
918 0 : struct RsCtxJfceCb *jfceCb = NULL;
919 0 : urma_jfce_t *jfce = NULL;
920 : int ret;
921 :
922 0 : hccp_info("[rs_ctx_chan]jfce destroy addr:0x%llx", addr);
923 :
924 0 : ret = RsUbGetJfceCb(devCb, addr, &jfceCb);
925 0 : CHK_PRT_RETURN(ret != 0, hccp_err("get jfce_cb failed, ret:%d, jfce addr:0x%llx", ret, addr), ret);
926 :
927 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
928 0 : RsListDel(&jfceCb->list);
929 0 : jfceCb->devCb->jfceCnt--;
930 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
931 :
932 0 : jfce = (urma_jfce_t *)(uintptr_t)jfceCb->jfceAddr;
933 0 : if (jfceCb->dataPlaneFlag.bs.pollCqCstm == 0) {
934 0 : (void)RsEpollCtl(devCb->rscb->connCb.epollfd, EPOLL_CTL_DEL, jfce->fd, EPOLLIN | EPOLLRDHUP);
935 : }
936 :
937 0 : ret = RsUrmaDeleteJfce(jfce);
938 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_delete_jfce failed, ret:%d errno:%d jfce addr:0x%llx", ret, errno,
939 : jfceCb->jfceAddr), -EOPENSRC);
940 :
941 0 : free(jfceCb);
942 0 : jfceCb = NULL;
943 :
944 0 : hccp_info("rs ctx jfce destroy success, dev jfce num is %u", devCb->jfceCnt);
945 0 : return ret;
946 : }
947 :
948 0 : STATIC int RsUbFreeJfceCb(struct RsUbDevCb *devCb, struct RsCtxJfceCb *jfceCb)
949 : {
950 0 : int ret = 0;
951 :
952 0 : RsListDel(&jfceCb->list);
953 0 : devCb->jfceCnt--;
954 :
955 0 : ret = RsUrmaDeleteJfce((urma_jfce_t *)(uintptr_t)jfceCb->jfceAddr);
956 0 : CHK_PRT_RETURN(ret != 0, hccp_err("[rs_ctx_chan]rs_ub_delete_jfce failed, ret:%d, jfce addr:0x%llx",
957 : ret, jfceCb->jfceAddr), -EOPENSRC);
958 :
959 0 : free(jfceCb);
960 0 : jfceCb = NULL;
961 :
962 0 : return 0;
963 : }
964 :
965 0 : STATIC void RsUbFreeJfceCbList(struct RsUbDevCb *devCb, struct RsListHead *jfceList)
966 : {
967 0 : struct RsCtxJfceCb *jfceCurr = NULL;
968 0 : struct RsCtxJfceCb *jfceNext = NULL;
969 : int ret;
970 :
971 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
972 0 : if (!RsListEmpty(jfceList)) {
973 0 : hccp_warn("jfce list do not empty!");
974 0 : RS_LIST_GET_HEAD_ENTRY(jfceCurr, jfceNext, jfceList, list, struct RsCtxJfceCb);
975 0 : for (; (&jfceCurr->list) != jfceList;
976 0 : jfceCurr = jfceNext, jfceNext = list_entry(jfceNext->list.next, struct RsCtxJfceCb, list)) {
977 0 : ret = RsUbFreeJfceCb(devCb, jfceCurr);
978 0 : if (ret != 0) {
979 0 : hccp_err("rs_ub_free_jfce_cb failed, ret:%d", ret);
980 : }
981 : }
982 : }
983 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
984 0 : }
985 :
986 0 : int RsUbCtxTokenIdAlloc(struct RsUbDevCb *devCb, unsigned long long *addr,
987 : unsigned int *tokenId)
988 : {
989 0 : struct RsTokenIdCb *tokenIdCb = NULL;
990 :
991 0 : tokenIdCb = calloc(1, sizeof(struct RsTokenIdCb));
992 0 : CHK_PRT_RETURN(tokenIdCb == NULL, hccp_err("calloc token_id_cb failed"), -ENOMEM);
993 :
994 0 : tokenIdCb->devCb = devCb;
995 0 : tokenIdCb->tokenId = RsUrmaAllocTokenId(devCb->urmaCtx);
996 0 : if (tokenIdCb->tokenId == NULL) {
997 0 : hccp_err("rs_urma_alloc_token_id failed, errno:%d, devIndex:0x%x", errno, devCb->index);
998 0 : goto free_ctx_token_id_cb;
999 : }
1000 :
1001 0 : *addr = (uint64_t)(uintptr_t)tokenIdCb->tokenId; // urma_token_id_t *
1002 0 : *tokenId = tokenIdCb->tokenId->token_id;
1003 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1004 0 : RsListAddTail(&tokenIdCb->list, &devCb->tokenIdList);
1005 0 : tokenIdCb->devCb->tokenIdCnt++;
1006 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1007 :
1008 0 : hccp_info("alloc success, tokenId addr:0x%llx, devIndex:0x%x", *addr, devCb->index);
1009 0 : return 0;
1010 :
1011 0 : free_ctx_token_id_cb:
1012 0 : free(tokenIdCb);
1013 0 : tokenIdCb = NULL;
1014 0 : return -EOPENSRC;
1015 : }
1016 :
1017 0 : STATIC int RsUbGetTokenIdCb(struct RsUbDevCb *devCb, unsigned long long addr,
1018 : struct RsTokenIdCb **tokenIdCb)
1019 : {
1020 0 : struct RsTokenIdCb **tempTokenIdCb = tokenIdCb;
1021 0 : struct RsTokenIdCb *tokenIdCbCurr = NULL;
1022 0 : struct RsTokenIdCb *tokenIdCbNext = NULL;
1023 :
1024 0 : RS_LIST_GET_HEAD_ENTRY(tokenIdCbCurr, tokenIdCbNext, &devCb->tokenIdList, list, struct RsTokenIdCb);
1025 0 : for (; (&tokenIdCbCurr->list) != (&devCb->tokenIdList);
1026 0 : tokenIdCbCurr = tokenIdCbNext,
1027 0 : tokenIdCbNext = list_entry(tokenIdCbNext->list.next, struct RsTokenIdCb, list)) {
1028 0 : if ((uint64_t)(uintptr_t)tokenIdCbCurr->tokenId == addr) {
1029 0 : *tempTokenIdCb = tokenIdCbCurr;
1030 0 : return 0;
1031 : }
1032 : }
1033 :
1034 0 : *tempTokenIdCb = NULL;
1035 0 : hccp_err("token_id_cb for token_id addr:0x%llx do not available! devIndex:0x%x", addr, devCb->index);
1036 :
1037 0 : return -ENODEV;
1038 : }
1039 :
1040 0 : STATIC int RsUbFreeTokenIdCb(struct RsUbDevCb *devCb, struct RsTokenIdCb *tokenIdCb)
1041 : {
1042 0 : int ret = 0;
1043 :
1044 0 : RsListDel(&tokenIdCb->list);
1045 0 : devCb->tokenIdCnt--;
1046 :
1047 0 : ret = RsUrmaFreeTokenId(tokenIdCb->tokenId);
1048 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_free_token_id failed, ret:%d, devIndex:0x%x, tokenId addr:0x%llx",
1049 : ret, devCb->index, (uint64_t)(uintptr_t)tokenIdCb->tokenId), -EOPENSRC);
1050 :
1051 0 : free(tokenIdCb);
1052 0 : tokenIdCb = NULL;
1053 0 : return 0;
1054 : }
1055 :
1056 0 : int RsUbCtxTokenIdFree(struct RsUbDevCb *devCb, unsigned long long addr)
1057 : {
1058 0 : struct RsTokenIdCb *tokenIdCb = NULL;
1059 : int ret;
1060 :
1061 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1062 0 : ret = RsUbGetTokenIdCb(devCb, addr, &tokenIdCb);
1063 0 : if (ret != 0) {
1064 0 : hccp_err("get token_id_cb failed! ret %d, devIndex:0x%x, tokenId addr:0x%llx", ret, devCb->index, addr);
1065 0 : goto free_lock;
1066 : }
1067 0 : ret = RsUbFreeTokenIdCb(devCb, tokenIdCb);
1068 0 : if (ret != 0) {
1069 0 : hccp_err("free_token_id_cb failed, ret:%d, devIndex:0x%x, tokenId addr:0x%llx", ret, devCb->index, addr);
1070 0 : goto free_lock;
1071 : }
1072 0 : hccp_info("rs token id free success, dev tokenId num is %u, devIndex:0x%x, tokenId addr:0x%llx",
1073 : devCb->tokenIdCnt, devCb->index, addr);
1074 :
1075 0 : free_lock:
1076 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1077 0 : return ret;
1078 : }
1079 :
1080 0 : STATIC void RsUbFreeTokenIdCbList(struct RsUbDevCb *devCb, struct RsListHead *tokenIdList)
1081 : {
1082 0 : struct RsTokenIdCb *tokenIdCurr = NULL;
1083 0 : struct RsTokenIdCb *tokenIdNext = NULL;
1084 :
1085 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1086 0 : if (!RsListEmpty(tokenIdList)) {
1087 0 : hccp_warn("token_id list do not empty!");
1088 0 : RS_LIST_GET_HEAD_ENTRY(tokenIdCurr, tokenIdNext, tokenIdList, list, struct RsTokenIdCb);
1089 0 : for (; (&tokenIdCurr->list) != tokenIdList; tokenIdCurr = tokenIdNext,
1090 0 : tokenIdNext = list_entry(tokenIdNext->list.next, struct RsTokenIdCb, list)) {
1091 0 : (void)RsUbFreeTokenIdCb(devCb, tokenIdCurr);
1092 : }
1093 : }
1094 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1095 0 : return;
1096 : }
1097 :
1098 0 : void RsUbFreeAsyncEventCb(struct RsUbDevCb *devCb, struct RsCtxAsyncEventCb *asyncEventCb)
1099 : {
1100 0 : RsListDel(&asyncEventCb->list);
1101 0 : devCb->asyncEventCnt--;
1102 :
1103 0 : free(asyncEventCb);
1104 0 : asyncEventCb = NULL;
1105 0 : }
1106 :
1107 0 : STATIC void RsUbFreeAsyncEventCbList(struct RsUbDevCb *devCb, struct RsListHead *asyncEventList)
1108 : {
1109 0 : struct RsCtxAsyncEventCb *asyncEventCurr = NULL;
1110 0 : struct RsCtxAsyncEventCb *asyncEventNext = NULL;
1111 :
1112 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1113 0 : (void)RsEpollCtl(devCb->rscb->connCb.epollfd, EPOLL_CTL_DEL, devCb->urmaCtx->async_fd, EPOLLIN | EPOLLRDHUP);
1114 0 : if (!RsListEmpty(asyncEventList)) {
1115 0 : hccp_run_warn("async_event list do not empty!");
1116 0 : RS_LIST_GET_HEAD_ENTRY(asyncEventCurr, asyncEventNext, asyncEventList, list,
1117 : struct RsCtxAsyncEventCb);
1118 0 : for (; (&asyncEventCurr->list) != asyncEventList; asyncEventCurr = asyncEventNext,
1119 0 : asyncEventNext = list_entry(asyncEventNext->list.next, struct RsCtxAsyncEventCb, list)) {
1120 0 : RsUbFreeAsyncEventCb(devCb, asyncEventCurr);
1121 : }
1122 : }
1123 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1124 0 : }
1125 :
1126 0 : int RsUbCtxDeinit(struct RsUbDevCb *devCb)
1127 : {
1128 : int ret;
1129 :
1130 0 : hccp_info("[deinit][rs_ctx]start deinit, phyId:%u, devIndex:0x%x", devCb->phyId, devCb->index);
1131 :
1132 0 : RsUbFreeSegCbList(devCb, &devCb->lsegList, &devCb->rsegList);
1133 0 : RsUbFreeJettyCbList(devCb, &devCb->jettyList, &devCb->rjettyList);
1134 :
1135 : /* Destroy shared JFR and JFC after all jettys are freed */
1136 0 : RsUbDevShareJfrDeinit(devCb);
1137 :
1138 0 : RsUbFreeJfcCbList(devCb, &devCb->jfcList);
1139 0 : RsUbFreeJfceCbList(devCb, &devCb->jfceList);
1140 0 : RsUbFreeTokenIdCbList(devCb, &devCb->tokenIdList);
1141 0 : RsUbFreeAsyncEventCbList(devCb, &devCb->asyncEventList);
1142 :
1143 0 : ret = RsUrmaDeleteContext(devCb->urmaCtx);
1144 0 : if (ret != 0) {
1145 0 : hccp_err("rs_urma_delete_context failed, ret:%d", ret);
1146 : }
1147 :
1148 0 : pthread_mutex_destroy(&devCb->mutex);
1149 :
1150 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->rscb->mutex);
1151 0 : RsListDel(&devCb->list);
1152 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->rscb->mutex);
1153 0 : RsSensorNodeUnregister(devCb->rscb);
1154 :
1155 0 : RsUbApiDeinit();
1156 :
1157 0 : hccp_run_info("[deinit][rs_ctx]deinit success, phyId:%u, devIndex:0x%x", devCb->phyId, devCb->index);
1158 0 : free(devCb);
1159 0 : devCb = NULL;
1160 0 : return ret;
1161 : }
1162 :
1163 0 : STATIC int RsUbQuerySegCb(struct RsUbDevCb *devCb, uint64_t addr, struct RsSegCb **segCb,
1164 : struct RsListHead *segList)
1165 : {
1166 0 : struct RsSegCb *segCurr = NULL;
1167 0 : struct RsSegCb *segNext = NULL;
1168 :
1169 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1170 0 : RS_LIST_GET_HEAD_ENTRY(segCurr, segNext, segList, list, struct RsSegCb);
1171 0 : for (; (&segCurr->list) != segList;
1172 0 : segCurr = segNext, segNext = list_entry(segNext->list.next, struct RsSegCb, list)) {
1173 0 : if ((segCurr->segInfo.addr <= addr) && (addr < segCurr->segInfo.addr + segCurr->segInfo.len)) {
1174 0 : *segCb = segCurr;
1175 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1176 0 : return 0;
1177 : }
1178 : }
1179 :
1180 0 : *segCb = NULL;
1181 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1182 :
1183 0 : hccp_info("cannot find seg_cb for addr@0x%lx", addr);
1184 0 : return -ENODEV;
1185 : }
1186 :
1187 1 : STATIC int RsUbInitSegCb(struct MemRegAttrT *memAttr, struct RsUbDevCb *devCb, struct RsSegCb *segCb)
1188 : {
1189 1 : struct RsTokenIdCb *tokenIdCb = NULL;
1190 1 : urma_seg_cfg_t segCfg = {0};
1191 1 : int ret = 0;
1192 :
1193 1 : segCfg.flag.value = memAttr->ub.flags.value;
1194 1 : segCfg.va = memAttr->mem.addr;
1195 1 : segCfg.len = memAttr->mem.size;
1196 1 : segCfg.token_value = segCb->tokenValue;
1197 1 : segCfg.user_ctx = (uintptr_t)NULL;
1198 1 : segCfg.iova = 0;
1199 :
1200 1 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1201 :
1202 : // token id in cfg is valid, get token id by mem_attr->ub.token_id_addr
1203 1 : if (segCfg.flag.bs.token_id_valid == URMA_TOKEN_ID_VALID) {
1204 0 : ret = RsUbGetTokenIdCb(devCb, memAttr->ub.tokenIdAddr, &tokenIdCb);
1205 0 : if (ret != 0) {
1206 0 : hccp_err("get token_id_cb failed! ret %d, devIndex:0x%x, tokenId addr:0x%llx", ret, devCb->index,
1207 : memAttr->ub.tokenIdAddr);
1208 0 : goto free_lock;
1209 : }
1210 0 : segCfg.token_id = tokenIdCb->tokenId;
1211 : }
1212 :
1213 1 : segCb->segment = RsUrmaRegisterSeg(devCb->urmaCtx, &segCfg);
1214 1 : if (segCb->segment == NULL) {
1215 1 : hccp_err("[init][rs_ctx_lmem]rs_urma_register_seg len[0x%llx] failed, errno:%d", segCfg.len, errno);
1216 1 : ret = -EOPENSRC;
1217 1 : goto free_lock;
1218 : }
1219 :
1220 0 : segCb->segInfo.seg = segCb->segment->seg;
1221 : // resv len as 1 to save addr for later unreg to query
1222 0 : segCb->segInfo.addr = (uint64_t)(uintptr_t)segCb->segment;
1223 0 : segCb->segInfo.len = 1;
1224 0 : RsListAddTail(&segCb->list, &devCb->lsegList);
1225 0 : devCb->lsegCnt++;
1226 :
1227 1 : free_lock:
1228 1 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1229 1 : return ret;
1230 : }
1231 :
1232 0 : STATIC void RsUbDeinitSegCb(struct RsUbDevCb *devCb, struct RsSegCb *segCb)
1233 : {
1234 0 : (void)RsUrmaUnregisterSeg(segCb->segment);
1235 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1236 0 : RsListDel(&segCb->list);
1237 0 : devCb->lsegCnt--;
1238 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1239 0 : }
1240 :
1241 1 : int RsUbCtxLmemReg(struct RsUbDevCb *devCb, struct MemRegAttrT *memAttr, struct MemRegInfoT *memInfo)
1242 : {
1243 1 : struct RsSegCb *lsegCb = NULL;
1244 : int ret;
1245 :
1246 1 : CHK_PRT_RETURN(memAttr->mem.size == 0, hccp_err("[init][rs_ctx_lmem]mem_attr->mem.size is 0"), -EINVAL);
1247 :
1248 1 : hccp_run_info("[init][rs_ctx_lmem]devIndex:0x%x addr:0x%llx, len[0x%llx], access[0x%x]",
1249 : devCb->index, memAttr->mem.addr, memAttr->mem.size, memAttr->ub.flags.bs.access);
1250 :
1251 1 : lsegCb = calloc(1, sizeof(struct RsSegCb));
1252 1 : CHK_PRT_RETURN(lsegCb == NULL, hccp_err("[init][rs_ctx_lmem]calloc lseg_cb failed"), -ENOMEM);
1253 1 : lsegCb->devCb = devCb;
1254 1 : lsegCb->tokenValue.token = memAttr->ub.tokenValue;
1255 :
1256 1 : ret = RsUbInitSegCb(memAttr, devCb, lsegCb);
1257 1 : if (ret != 0) {
1258 1 : hccp_err("[init][rs_ctx_lmem]rs_ub_init_seg_cb failed, ret:%d", ret);
1259 1 : goto init_err;
1260 : }
1261 :
1262 0 : ret = memcpy_s(memInfo->key.value, sizeof(memInfo->key.value), &lsegCb->segInfo.seg, sizeof(urma_seg_t));
1263 0 : if (ret != 0) {
1264 0 : hccp_err("[init][rs_ctx_lmem]memcpy_s for seg failed ret:%d", ret);
1265 0 : ret = -ESAFEFUNC;
1266 0 : goto reg_err;
1267 : }
1268 0 : memInfo->key.size = sizeof(urma_seg_t);
1269 0 : memInfo->ub.tokenId = lsegCb->segment->token_id->token_id;
1270 0 : memInfo->ub.targetSegHandle = (uintptr_t)lsegCb->segment;
1271 :
1272 0 : hccp_info("[init][rs_ctx_lmem]reg succ, devIndex:0x%x addr:0x%llx, len[0x%llx], access[0x%x]",
1273 : devCb->index, memAttr->mem.addr, memAttr->mem.size, memAttr->ub.flags.bs.access);
1274 0 : return 0;
1275 :
1276 0 : reg_err:
1277 0 : RsUbDeinitSegCb(devCb, lsegCb);
1278 1 : init_err:
1279 1 : free(lsegCb);
1280 1 : lsegCb = NULL;
1281 1 : return ret;
1282 : }
1283 :
1284 0 : int RsUbCtxLmemUnreg(struct RsUbDevCb *devCb, unsigned long long addr)
1285 : {
1286 0 : struct RsSegCb *lsegCb = NULL;
1287 : int ret;
1288 :
1289 0 : hccp_info("[deinit][rs_ctx_lmem]devIndex:0x%x addr:0x%llx", devCb->index, addr);
1290 :
1291 0 : ret = RsUbQuerySegCb(devCb, addr, &lsegCb, &devCb->lsegList);
1292 0 : CHK_PRT_RETURN(ret != 0, hccp_err("[deinit][rs_ctx_lmem]rs_ub_query_seg_cb failed ret:%d ", ret), ret);
1293 :
1294 0 : ret = RsUrmaUnregisterSeg(lsegCb->segment);
1295 0 : CHK_PRT_RETURN(ret != 0, hccp_err("[deinit][rs_ctx_lmem]rs_urma_unregister_seg failed ret:%d ", ret), -EOPENSRC);
1296 :
1297 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1298 0 : RsListDel(&lsegCb->list);
1299 0 : devCb->lsegCnt--;
1300 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1301 0 : hccp_run_info("[deinit][rs_ctx_lmem]devIndex:0x%x addr:0x%llx unregister segment success", devCb->index, addr);
1302 0 : free(lsegCb);
1303 0 : lsegCb = NULL;
1304 0 : return 0;
1305 : }
1306 :
1307 1 : int RsUbCtxRmemImport(struct RsUbDevCb *devCb, struct MemImportAttrT *memAttr,
1308 : struct MemImportInfoT *memInfo)
1309 : {
1310 1 : struct RsSegCb *remSegCb = NULL;
1311 1 : urma_import_seg_flag_t flag = {0};
1312 1 : urma_token_t tokenValue = {0};
1313 1 : uint64_t mappingAddr = 0;
1314 : int ret;
1315 :
1316 1 : remSegCb = calloc(1, sizeof(struct RsSegCb));
1317 1 : CHK_PRT_RETURN(remSegCb == NULL, hccp_err("[init][rs_ctx_rmem]calloc rem_seg_cb failed"), -ENOMEM);
1318 :
1319 1 : ret = memcpy_s(&remSegCb->segInfo.seg, sizeof(urma_seg_t), &memAttr->key.value, memAttr->key.size);
1320 1 : if (ret != 0) {
1321 0 : hccp_err("[init][rs_ctx_rmem]memcpy_s failed, ret:%d", ret);
1322 0 : ret = -ESAFEFUNC;
1323 0 : goto free_rem_seg_cb;
1324 : }
1325 :
1326 1 : tokenValue.token = memAttr->ub.tokenValue;
1327 1 : flag.value = memAttr->ub.flags.value;
1328 : // mapping_addr is needed if flag mapping set value
1329 1 : if (memAttr->ub.flags.bs.mapping == 1) {
1330 0 : mappingAddr = memAttr->ub.mappingAddr;
1331 : }
1332 1 : remSegCb->segment = RsUrmaImportSeg(devCb->urmaCtx, &remSegCb->segInfo.seg, &tokenValue, mappingAddr,
1333 : flag);
1334 1 : if (remSegCb->segment == NULL) {
1335 1 : hccp_err("[init][rs_ctx_rmem]rs_urma_import_seg failed, errno:%d", errno);
1336 1 : ret = -EOPENSRC;
1337 1 : goto free_rem_seg_cb;
1338 : }
1339 :
1340 0 : memInfo->ub.targetSegHandle = (uintptr_t)remSegCb->segment;
1341 : // resv len as 1 to save addr for later unimport to query
1342 0 : remSegCb->segInfo.addr = memInfo->ub.targetSegHandle;
1343 0 : remSegCb->segInfo.len = 1;
1344 :
1345 0 : hccp_run_info("[init][rs_ctx_rmem]devIndex:0x%x import addr:0x%llx", devCb->index, remSegCb->segInfo.addr);
1346 :
1347 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1348 0 : RsListAddTail(&remSegCb->list, &devCb->rsegList);
1349 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1350 :
1351 0 : return 0;
1352 :
1353 1 : free_rem_seg_cb:
1354 1 : free(remSegCb);
1355 1 : remSegCb = NULL;
1356 1 : return ret;
1357 : }
1358 :
1359 0 : int RsUbCtxRmemUnimport(struct RsUbDevCb *devCb, unsigned long long addr)
1360 : {
1361 0 : struct RsSegCb *remSegCb = NULL;
1362 : int ret;
1363 :
1364 0 : hccp_run_info("[deinit][rs_ctx_rmem]devIndex:0x%x unimport addr:0x%llx", devCb->index, addr);
1365 :
1366 0 : ret = RsUbQuerySegCb(devCb, addr, &remSegCb, &devCb->rsegList);
1367 0 : CHK_PRT_RETURN(ret != 0, hccp_warn("[deinit][rs_ctx_rmem]can not find rem seg cb for addr:0x%llx", addr), 0);
1368 :
1369 0 : RsUrmaUnimportSeg(remSegCb->segment);
1370 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1371 0 : RsListDel(&remSegCb->list);
1372 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1373 :
1374 0 : free(remSegCb);
1375 0 : remSegCb = NULL;
1376 0 : return 0;
1377 : }
1378 :
1379 0 : STATIC int RsUbCtxJfcCreateNormal(struct RsUbDevCb *devCb, urma_jfc_cfg_t *jfcCfg, urma_jfc_t **outJfc)
1380 : {
1381 0 : uint64_t jfceAddr = (uint64_t)(uintptr_t)jfcCfg->jfce;
1382 0 : struct RsCtxJfceCb *jfceCb = NULL;
1383 0 : int ret = 0;
1384 :
1385 0 : if (jfcCfg->jfce != NULL) {
1386 0 : ret = RsUbGetJfceCb(devCb, jfceAddr, &jfceCb);
1387 0 : CHK_PRT_RETURN(ret != 0, hccp_err("get jfce_cb failed, ret:%d, jfce addr:0x%llx", ret, jfceAddr), ret);
1388 : }
1389 :
1390 0 : *outJfc = RsUrmaCreateJfc(devCb->urmaCtx, jfcCfg);
1391 0 : CHK_PRT_RETURN(*outJfc == NULL, hccp_err("rs_urma_create_jfc failed, errno:%d", errno), -EOPENSRC);
1392 :
1393 0 : ret = RsUrmaRearmJfc(*outJfc, false);
1394 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_rearm_jfc failed, ret:%d errno:%d", ret, errno), -EOPENSRC);
1395 :
1396 0 : return ret;
1397 : }
1398 :
1399 0 : STATIC void RsUbFillJfcInfo(struct RsCtxJfcCb *jfcCb, struct CtxCqInfo *info)
1400 : {
1401 0 : info->addr = jfcCb->jfcAddr;
1402 0 : info->ub.id = jfcCb->jfcId;
1403 0 : info->ub.cqeSize = WQE_BB_SIZE;
1404 0 : info->ub.bufAddr = jfcCb->bufAddr;
1405 0 : info->ub.swdbAddr = jfcCb->swdbAddr;
1406 0 : }
1407 :
1408 1 : int RsUbCtxJfcCreate(struct RsUbDevCb *devCb, struct CtxCqAttr *attr, struct CtxCqInfo *info)
1409 : {
1410 1 : struct RsCtxJfcCb *jfcCb = NULL;
1411 1 : urma_jfc_cfg_t jfcCfg = {0};
1412 1 : urma_jfc_t *outJfc = NULL;
1413 1 : int ret = 0;
1414 :
1415 1 : jfcCb = (struct RsCtxJfcCb *)calloc(1, sizeof(struct RsCtxJfcCb));
1416 1 : CHK_PRT_RETURN(jfcCb == NULL, hccp_err("calloc jfc_cb failed"), -ENOMEM);
1417 :
1418 1 : jfcCb->devCb = devCb;
1419 1 : jfcCb->jfcType = attr->ub.mode;
1420 1 : jfcCb->depth = attr->depth;
1421 1 : jfcCb->ccuExCfg.valid = attr->ub.ccuExCfg.valid;
1422 1 : jfcCb->ccuExCfg.cqeFlag = attr->ub.ccuExCfg.cqeFlag;
1423 1 : jfcCfg.depth = attr->depth;
1424 1 : jfcCfg.flag.value = attr->ub.flag.value;
1425 1 : jfcCfg.user_ctx = attr->ub.userCtx;
1426 1 : jfcCfg.ceqn = attr->ub.ceqn;
1427 1 : jfcCfg.jfce = attr->chanAddr == 0 ? NULL : (urma_jfce_t *)(uintptr_t)attr->chanAddr;
1428 1 : if (attr->ub.mode == JFC_MODE_STARS_POLL || attr->ub.mode == JFC_MODE_CCU_POLL ||
1429 0 : attr->ub.mode == JFC_MODE_USER_CTL_NORMAL) {
1430 1 : ret = RsUbCtxJfcCreateExt(jfcCb, &jfcCfg, &outJfc);
1431 1 : if (ret != 0) {
1432 1 : hccp_err("rs_ub_ctx_jfc_create_ext jfc_mode:%d failed, ret:%d", attr->ub.mode, ret);
1433 1 : goto jfc_cb_init_err;
1434 : }
1435 0 : } else if (attr->ub.mode == JFC_MODE_NORMAL) {
1436 0 : jfcCfg.jfce = (attr->chanAddr == 0) ? NULL : (urma_jfce_t *)(uintptr_t)attr->chanAddr;
1437 0 : ret = RsUbCtxJfcCreateNormal(devCb, &jfcCfg, &outJfc);
1438 0 : if (ret != 0) {
1439 0 : hccp_err("rs_ub_ctx_jfc_create_normal failed, jfcMode:%d ret:%d", attr->ub.mode, ret);
1440 0 : goto jfc_cb_init_err;
1441 : }
1442 : } else {
1443 0 : hccp_err("jfc_type %d is invalid, not support!", attr->ub.mode);
1444 0 : ret = -EINVAL;
1445 0 : goto jfc_cb_init_err;
1446 : }
1447 0 : jfcCb->jfcAddr = (uint64_t)(uintptr_t)outJfc; // urma_jfc_t *
1448 0 : RsUbFillJfcInfo(jfcCb, info);
1449 :
1450 0 : hccp_info("jfc addr:0x%llx mode:%d", jfcCb->jfcAddr, jfcCb->jfcType);
1451 :
1452 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1453 0 : jfcCb->devCb->jfcCnt++;
1454 0 : RsListAddTail(&jfcCb->list, &devCb->jfcList);
1455 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1456 :
1457 0 : return 0;
1458 :
1459 1 : jfc_cb_init_err:
1460 1 : free(jfcCb);
1461 1 : jfcCb = NULL;
1462 :
1463 1 : return ret;
1464 : }
1465 :
1466 0 : STATIC bool RsUbIsJettyModeValid(int jettyMode, bool lockFlag)
1467 : {
1468 0 : if (jettyMode < 0 || jettyMode >= JETTY_MODE_MAX || (jettyMode == JETTY_MODE_CCU_TA_CACHE && !lockFlag)) {
1469 0 : return false;
1470 : }
1471 :
1472 0 : return true;
1473 : }
1474 :
1475 0 : STATIC int RsUbJettyCbInit(struct RsUbDevCb *devCb, struct CtxQpAttr *jettyAttr,
1476 : struct RsCtxJettyCb *jettyCb)
1477 : {
1478 0 : bool lockFlag = jettyAttr->ub.taCacheMode.lockFlag;
1479 0 : int jettyMode = jettyAttr->ub.mode;
1480 :
1481 0 : if (!RsUbIsJettyModeValid(jettyMode, lockFlag)) {
1482 0 : hccp_err("unsupported jetty_mode:%d, lockFlag:%d", jettyMode, lockFlag);
1483 0 : return -EINVAL;
1484 : }
1485 :
1486 0 : jettyCb->txDepth = jettyAttr->sqDepth;
1487 0 : jettyCb->rxDepth = jettyAttr->rqDepth;
1488 0 : jettyCb->devCb = devCb;
1489 0 : jettyCb->jettyMode = jettyMode;
1490 0 : jettyCb->jettyId = jettyAttr->ub.jettyId;
1491 0 : jettyCb->transportMode = jettyAttr->transportMode;
1492 0 : jettyCb->state = RS_QP_STATUS_DISCONNECT;
1493 0 : jettyCb->flag.value = jettyAttr->ub.flag.value;
1494 0 : jettyCb->jfsFlag.value = jettyAttr->ub.jfsFlag.value;
1495 0 : jettyCb->tokenIdAddr = jettyAttr->ub.tokenIdAddr;
1496 0 : jettyCb->tokenValue = jettyAttr->ub.tokenValue;
1497 0 : jettyCb->priority = jettyAttr->ub.priority;
1498 0 : jettyCb->rnrRetry = jettyAttr->ub.rnrRetry;
1499 0 : jettyCb->errTimeout = jettyAttr->ub.errTimeout;
1500 :
1501 0 : if (jettyCb->jettyMode == JETTY_MODE_CCU_TA_CACHE) {
1502 0 : jettyCb->taCacheMode.lockFlag = jettyAttr->ub.taCacheMode.lockFlag;
1503 0 : jettyCb->taCacheMode.sqeBufIdx = jettyAttr->ub.taCacheMode.sqeBufIdx;
1504 : } else {
1505 0 : jettyCb->extMode.sq = jettyAttr->ub.extMode.sq;
1506 0 : jettyCb->extMode.piType = jettyAttr->ub.extMode.piType;
1507 0 : jettyCb->extMode.cstmFlag = jettyAttr->ub.extMode.cstmFlag;
1508 0 : jettyCb->extMode.sqebbNum = jettyAttr->ub.extMode.sqebbNum;
1509 : }
1510 0 : return 0;
1511 : }
1512 :
1513 : #ifdef CUSTOM_INTERFACE
1514 0 : STATIC int RsUbJettyCbBuffAlloc(struct RsUbDevCb *devCb, struct RsCtxJettyCb *jettyCb, enum JfcMode jfcType)
1515 : {
1516 0 : unsigned int logicDevid = 0;
1517 0 : unsigned long flag = 0;
1518 0 : int ret = 0;
1519 :
1520 0 : if (jfcType != JFC_MODE_NORMAL) {
1521 0 : jettyCb->qpShareInfoAddr = NULL;
1522 0 : return 0;
1523 : }
1524 :
1525 0 : ret = rsGetLocalDevIDByHostDevID(devCb->phyId, &logicDevid);
1526 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rsGetLocalDevIDByHostDevID failed, phyId(%u), ret(%d)",
1527 : devCb->phyId, ret), ret);
1528 :
1529 0 : flag = ((unsigned long)logicDevid << BUFF_FLAGS_DEVID_OFFSET) | BUFF_SP_SVM;
1530 0 : ret = DlHalBuffAllocAlignEx(sizeof(struct CtxQpShareInfo), CI_ADDR_BUFFER_ALIGN_4K_PAGE_SIZE, flag,
1531 0 : (int)devCb->rscb->grpId, (void **)&jettyCb->qpShareInfoAddr);
1532 0 : if (ret != 0) {
1533 0 : hccp_err("dl_hal_buff_alloc_align_ex failed, length:0x%llx, dev_id:0x%x, flag:0x%lx, grp_id:%u, ret:%d",
1534 : sizeof(struct CtxQpShareInfo), logicDevid, flag, devCb->rscb->grpId, ret);
1535 : }
1536 :
1537 0 : return ret;
1538 : }
1539 : #endif
1540 :
1541 1 : STATIC int RsUbCtxInitJettyCb(struct RsUbDevCb *devCb, struct CtxQpAttr *attr,
1542 : struct RsCtxJettyCb **jettyCb)
1543 : {
1544 1 : struct RsCtxJettyCb *tmpJettyCb = NULL;
1545 : int ret;
1546 :
1547 1 : tmpJettyCb = calloc(1, sizeof(struct RsCtxJettyCb));
1548 1 : CHK_PRT_RETURN(tmpJettyCb == NULL, hccp_err("calloc tmp_jetty_cb failed, errno:%d", errno), -ENOMEM);
1549 :
1550 1 : ret = pthread_mutex_init(&tmpJettyCb->mutex, NULL);
1551 1 : if (ret != 0) {
1552 1 : hccp_err("pthread_mutex_init failed, ret:%d", ret);
1553 1 : goto pthread_mutex_init_err;
1554 : }
1555 :
1556 0 : ret = pthread_mutex_init(&tmpJettyCb->crErrInfo.mutex, NULL);
1557 0 : if (ret != 0) {
1558 0 : hccp_err("pthread_mutex_init failed, ret:%d", ret);
1559 0 : goto cr_err_mutex_init_err;
1560 : }
1561 :
1562 0 : ret = RsUbJettyCbInit(devCb, attr, tmpJettyCb);
1563 0 : if (ret != 0) {
1564 0 : hccp_err("jetty_cb init failed ret:%d", ret);
1565 0 : goto jetty_cb_init_err;
1566 : }
1567 :
1568 0 : *jettyCb = tmpJettyCb;
1569 0 : return 0;
1570 :
1571 0 : jetty_cb_init_err:
1572 0 : pthread_mutex_destroy(&tmpJettyCb->crErrInfo.mutex);
1573 0 : cr_err_mutex_init_err:
1574 0 : pthread_mutex_destroy(&tmpJettyCb->mutex);
1575 1 : pthread_mutex_init_err:
1576 1 : free(tmpJettyCb);
1577 1 : tmpJettyCb = NULL;
1578 :
1579 1 : return ret;
1580 : }
1581 :
1582 0 : STATIC void RsUbCtxFillJfsCfg(struct RsCtxJettyCb *jettyCb, struct RsCtxJfcCb *sendJfcCb,
1583 : urma_jfs_cfg_t *jfsCfg)
1584 : {
1585 0 : jfsCfg->depth = (uint32_t)jettyCb->txDepth;
1586 0 : jfsCfg->flag.value = jettyCb->jfsFlag.value;
1587 0 : jfsCfg->trans_mode = jettyCb->transportMode;
1588 0 : jfsCfg->priority = jettyCb->priority;
1589 0 : jfsCfg->max_sge = (uint8_t)jettyCb->devCb->devAttr.sqMaxSge;
1590 0 : jfsCfg->max_rsge = (uint8_t)jettyCb->devCb->devAttr.ub.maxJfsRsge;
1591 0 : jfsCfg->max_inline_data = jettyCb->devCb->devAttr.ub.maxJfsInlineLen;
1592 0 : jfsCfg->rnr_retry = jettyCb->rnrRetry;
1593 0 : jfsCfg->err_timeout = jettyCb->errTimeout;
1594 0 : jfsCfg->jfc = (urma_jfc_t *)(uintptr_t)sendJfcCb->jfcAddr;
1595 0 : jfsCfg->user_ctx = (uint64_t)NULL;
1596 0 : }
1597 :
1598 0 : int RsUbCtxRegJettyDb(struct RsCtxJettyCb *jettyCb, struct udma_u_jetty_info *jettyInfo)
1599 : {
1600 0 : struct MemRegAttrT memAttr = { 0 };
1601 0 : struct MemRegInfoT memInfo = { 0 };
1602 : int ret;
1603 :
1604 : // register dwqe_addr with page size 4096, return db_addr to use, specify ub to alloc token id
1605 0 : hccp_dbg("jetty_info->dwqe_addr:%pK, jettyInfo->dbAddr:%pK", jettyInfo->dwqe_addr, jettyInfo->db_addr);
1606 0 : memAttr.mem.addr = (uint64_t)(uintptr_t)jettyInfo->dwqe_addr;
1607 0 : memAttr.mem.size = 4096U;
1608 0 : memAttr.ub.flags.value = 0;
1609 0 : memAttr.ub.flags.bs.tokenPolicy = URMA_TOKEN_PLAIN_TEXT;
1610 0 : memAttr.ub.flags.bs.cacheable = URMA_NON_CACHEABLE;
1611 0 : memAttr.ub.flags.bs.access = MEM_SEG_ACCESS_READ | MEM_SEG_ACCESS_WRITE;
1612 0 : memAttr.ub.flags.bs.nonPin = 1;
1613 : // use user specified token id to register
1614 0 : if (jettyCb->tokenIdAddr != 0) {
1615 0 : memAttr.ub.flags.bs.tokenIdValid = URMA_TOKEN_ID_VALID;
1616 0 : memAttr.ub.tokenIdAddr = jettyCb->tokenIdAddr;
1617 : }
1618 0 : memAttr.ub.tokenValue = jettyCb->tokenValue;
1619 0 : ret = RsUbCtxLmemReg(jettyCb->devCb, &memAttr, &memInfo);
1620 0 : CHK_PRT_RETURN(ret != 0, hccp_err("RsUbCtxLmemReg failed, ret:%d flags:0x%x", ret, memAttr.ub.flags.value), ret);
1621 :
1622 0 : jettyCb->dbTokenId = memInfo.ub.tokenId;
1623 0 : jettyCb->dbSegHandle = memInfo.ub.targetSegHandle;
1624 0 : return 0;
1625 : }
1626 :
1627 0 : STATIC int RsUbCtxDrvJettyCreate(struct RsCtxJettyCb *jettyCb, struct RsCtxJfcCb *sendJfcCb,
1628 : struct RsCtxJfcCb *recvJfcCb)
1629 : {
1630 0 : urma_jetty_cfg_t jettyInitCfg = {0};
1631 0 : urma_jfs_cfg_t jfsCfg = {0};
1632 :
1633 0 : jettyInitCfg.id = jettyCb->jettyId;
1634 0 : jettyInitCfg.flag = jettyCb->flag;
1635 0 : RsUbCtxFillJfsCfg(jettyCb, sendJfcCb, &jfsCfg);
1636 0 : jettyInitCfg.jfs_cfg = jfsCfg;
1637 :
1638 0 : jettyInitCfg.shared.jfr = jettyCb->devCb->shareJfr;
1639 0 : jettyInitCfg.shared.jfc = (urma_jfc_t *)(uintptr_t)recvJfcCb->jfcAddr;
1640 :
1641 0 : if (jettyCb->jettyMode == JETTY_MODE_URMA_NORMAL) {
1642 0 : jettyCb->jetty = RsUrmaCreateJetty(jettyCb->devCb->urmaCtx, &jettyInitCfg);
1643 0 : if (jettyCb->jetty == NULL) {
1644 0 : hccp_err("rs_urma_create_jetty failed, errno=%d", errno);
1645 : }
1646 : } else {
1647 0 : RsUbCtxExtJettyCreate(jettyCb, &jettyInitCfg);
1648 : }
1649 :
1650 0 : if (jettyCb->jetty == NULL) {
1651 0 : return -ENOMEM;
1652 : }
1653 :
1654 0 : jettyCb->state = RS_JETTY_STATE_CREATED;
1655 :
1656 0 : hccp_run_info("chip_id:%u, devIndex:0x%x, jettyId:%u jetty create succ", jettyCb->devCb->rscb->chipId,
1657 : jettyCb->devCb->index, jettyCb->jetty->jetty_id.id);
1658 :
1659 0 : return 0;
1660 : }
1661 :
1662 0 : STATIC int RsUbFillJettyInfo(struct RsCtxJettyCb *jettyCb, struct QpCreateInfo *jettyInfo)
1663 : {
1664 0 : struct RsJettyKeyInfo jettyKeyInfo = {0};
1665 : int ret;
1666 :
1667 0 : jettyKeyInfo.jettyId = jettyCb->jetty->jetty_id;
1668 0 : jettyKeyInfo.transMode = jettyCb->transportMode;
1669 0 : ret = memcpy_s(jettyInfo->key.value, DEV_QP_KEY_SIZE, &jettyKeyInfo, sizeof(struct RsJettyKeyInfo));
1670 0 : CHK_PRT_RETURN(ret != 0, hccp_err("memcpy jetty_key_info failed, ret:%d", ret), -ESAFEFUNC);
1671 :
1672 0 : jettyInfo->key.size = (uint8_t)sizeof(struct RsJettyKeyInfo);
1673 0 : jettyInfo->ub.uasid = jettyCb->jetty->jetty_id.uasid;
1674 0 : jettyInfo->ub.id = jettyCb->jetty->jetty_id.id;
1675 0 : jettyInfo->ub.dbAddr = jettyCb->dbAddr;
1676 0 : jettyInfo->ub.sqBuffVa = jettyCb->sqBuffVa;
1677 0 : jettyInfo->ub.wqebbSize = WQE_BB_SIZE;
1678 0 : jettyInfo->ub.dbTokenId = jettyCb->dbTokenId;
1679 0 : jettyInfo->va = (uint64_t)(uintptr_t)jettyCb->jetty;
1680 0 : jettyInfo->ub.shareInfoAddr = (uint64_t)(uintptr_t)jettyCb->qpShareInfoAddr;
1681 0 : jettyInfo->ub.shareInfoLen = sizeof(struct CtxQpShareInfo);
1682 :
1683 0 : return 0;
1684 : }
1685 :
1686 0 : STATIC int RsUbQueryJfcCb(struct RsUbDevCb *devCb, unsigned long long scqIndex, unsigned long long rcqIndex,
1687 : struct RsCtxJfcCb **sendJfcCb, struct RsCtxJfcCb **recvJfcCb)
1688 : {
1689 : int ret;
1690 :
1691 0 : ret = RsUbGetJfcCb(devCb, scqIndex, sendJfcCb);
1692 0 : CHK_PRT_RETURN(ret != 0, hccp_err("get send_jfc_cb failed, ret:%d scqIndex:0x%llx", ret, scqIndex), ret);
1693 :
1694 0 : ret = RsUbGetJfcCb(devCb, rcqIndex, recvJfcCb);
1695 0 : CHK_PRT_RETURN(ret != 0, hccp_err("get recv_jfc_cb failed, ret:%d rcqIndex:0x%llx", ret, rcqIndex), ret);
1696 :
1697 0 : return 0;
1698 : }
1699 :
1700 2 : int RsUbCtxJettyCreate(struct RsUbDevCb *devCb, struct CtxQpAttr *attr, struct QpCreateInfo *info)
1701 : {
1702 2 : struct RsCtxJfcCb *sendJfcCb = NULL;
1703 2 : struct RsCtxJfcCb *recvJfcCb = NULL;
1704 2 : struct RsCtxJettyCb *jettyCb = NULL;
1705 : int ret;
1706 :
1707 2 : ret = RsUbCtxInitJettyCb(devCb, attr, &jettyCb);
1708 2 : CHK_PRT_RETURN(ret != 0, hccp_err("alloc mem for jetty_cb failed, ret:%d", ret), ret);
1709 :
1710 2 : ret = RsUbQueryJfcCb(devCb, attr->scqIndex, attr->rcqIndex, &sendJfcCb, &recvJfcCb);
1711 2 : if (ret != 0) {
1712 1 : hccp_err("query jfc_cb scq_index:0x%llx rcq_index:0x%llx failed, ret:%d", attr->scqIndex, attr->rcqIndex,
1713 : ret);
1714 1 : goto free_jetty_cb;
1715 : }
1716 :
1717 : #ifdef CUSTOM_INTERFACE
1718 1 : ret = RsUbJettyCbBuffAlloc(devCb, jettyCb, sendJfcCb->jfcType);
1719 1 : if (ret != 0) {
1720 0 : hccp_err("jetty_cb buff alloc failed ret:%d", ret);
1721 0 : goto free_jetty_cb;
1722 : }
1723 : #endif
1724 :
1725 1 : ret = RsUbCtxDrvJettyCreate(jettyCb, sendJfcCb, recvJfcCb);
1726 1 : if (ret != 0) {
1727 0 : hccp_err("rs_ub_ctx_drv_jetty_create failed, ret:%d", ret);
1728 0 : goto free_jetty_cb;
1729 : }
1730 :
1731 1 : ret = RsUbFillJettyInfo(jettyCb, info);
1732 1 : if (ret != 0) {
1733 1 : hccp_err("rs_ub_fill_jetty_info failed, ret:%d", ret);
1734 1 : goto fill_jetty_info_err;
1735 : }
1736 :
1737 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1738 0 : jettyCb->scqIndex = attr->scqIndex;
1739 0 : jettyCb->rcqIndex = attr->rcqIndex;
1740 0 : RsListAddTail(&jettyCb->list, &devCb->jettyList);
1741 0 : devCb->jettyCnt++;
1742 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1743 :
1744 0 : hccp_run_info("[init][rs_ctx]devIndex:0x%x qp_id:%u mode:%d create success, jettyCnt:%u",
1745 : devCb->index, info->ub.id, jettyCb->jettyMode, devCb->jettyCnt);
1746 :
1747 0 : return 0;
1748 :
1749 1 : fill_jetty_info_err:
1750 1 : RsUbCtxDrvJettyDelete(jettyCb);
1751 2 : free_jetty_cb:
1752 2 : RsUbCtxFreeJettyCb(jettyCb);
1753 :
1754 2 : return ret;
1755 : }
1756 :
1757 2 : int RsUbGetJettyCb(struct RsUbDevCb *devCb, unsigned int jettyId, struct RsCtxJettyCb **jettyCb)
1758 : {
1759 2 : struct RsCtxJettyCb **tempJettyCb = jettyCb;
1760 2 : struct RsCtxJettyCb *jettyCbCurr = NULL;
1761 2 : struct RsCtxJettyCb *jettyCbNext = NULL;
1762 :
1763 2 : RS_LIST_GET_HEAD_ENTRY(jettyCbCurr, jettyCbNext, &devCb->jettyList, list, struct RsCtxJettyCb);
1764 3 : for (; (&jettyCbCurr->list) != &devCb->jettyList;
1765 1 : jettyCbCurr = jettyCbNext,
1766 1 : jettyCbNext = list_entry(jettyCbNext->list.next, struct RsCtxJettyCb, list)) {
1767 2 : if (jettyCbCurr->jetty != NULL && jettyCbCurr->jetty->jetty_id.id == jettyId) {
1768 1 : *tempJettyCb = jettyCbCurr;
1769 1 : return 0;
1770 : }
1771 : }
1772 :
1773 1 : *tempJettyCb = NULL;
1774 1 : return -ENODEV;
1775 : }
1776 :
1777 0 : int RsUbCtxJettyDestroy(struct RsUbDevCb *devCb, unsigned int jettyId)
1778 : {
1779 0 : struct RsCtxJettyCb *jettyCb = NULL;
1780 : int ret;
1781 :
1782 0 : ret = RsUbGetJettyCb(devCb, jettyId, &jettyCb);
1783 0 : CHK_PRT_RETURN(ret != 0, hccp_run_warn("get jetty_cb unsuccessful, ret:%d, jettyId %u", ret, jettyId), ret);
1784 0 : if (jettyCb->state != RS_JETTY_STATE_CREATED) {
1785 0 : hccp_err("jetty_cb->state:%u not support to destroy, jettyId:%u", jettyCb->state, jettyId);
1786 0 : return -EINVAL;
1787 : }
1788 :
1789 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1790 0 : RsListDel(&jettyCb->list);
1791 0 : devCb->jettyCnt--;
1792 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1793 :
1794 0 : RsUbCtxDrvJettyDelete(jettyCb);
1795 :
1796 0 : RsUbCtxFreeJettyCb(jettyCb);
1797 :
1798 0 : hccp_run_info("[deinit][rs_ctx]devIndex:0x%x qp_id:%u destroy success, jettyCnt:%u",
1799 : devCb->index, jettyId, devCb->jettyCnt);
1800 :
1801 0 : return 0;
1802 : }
1803 :
1804 2 : int RsUbCtxJettyFree(struct rs_cb *rscb, unsigned int ueInfo, unsigned int jettyId)
1805 : {
1806 2 : struct RsUbDevCb *devCbCurr = NULL;
1807 2 : struct RsUbDevCb *devCbNext = NULL;
1808 2 : struct RsCtxJettyCb *jettyCb = NULL;
1809 2 : int ret = 0;
1810 :
1811 2 : RS_LIST_GET_HEAD_ENTRY(devCbCurr, devCbNext, &rscb->udevList, list, struct RsUbDevCb);
1812 3 : for (; (&devCbCurr->list) != &rscb->udevList;
1813 1 : devCbCurr = devCbNext, devCbNext = list_entry(devCbNext->list.next, struct RsUbDevCb, list)) {
1814 2 : if ((devCbCurr->index & DEV_INDEX_UE_INFO_MASK) != ueInfo) {
1815 0 : continue;
1816 : }
1817 :
1818 2 : RS_PTHREAD_MUTEX_LOCK(&devCbCurr->mutex);
1819 2 : ret = RsUbGetJettyCb(devCbCurr, jettyId, &jettyCb);
1820 2 : if (ret == 0) {
1821 1 : goto jetty_found;
1822 : }
1823 1 : RS_PTHREAD_MUTEX_ULOCK(&devCbCurr->mutex);
1824 : }
1825 :
1826 1 : hccp_run_warn("get jetty_cb unsuccessful, ueInfo:0x%x, jettyId:%u", ueInfo, jettyId);
1827 1 : return -ENODEV;
1828 :
1829 1 : jetty_found:
1830 1 : RsListDel(&jettyCb->list);
1831 1 : devCbCurr->jettyCnt--;
1832 1 : RS_PTHREAD_MUTEX_ULOCK(&devCbCurr->mutex);
1833 :
1834 1 : if (jettyCb->state == RS_JETTY_STATE_BIND) {
1835 1 : hccp_info("jetty_id:%u will be unbind, devIndex:0x%x", jettyId, devCbCurr->index);
1836 1 : (void)RsUrmaUnbindJetty(jettyCb->jetty);
1837 : }
1838 :
1839 1 : if (jettyCb->state == RS_JETTY_STATE_BIND || jettyCb->state == RS_JETTY_STATE_CREATED) {
1840 1 : hccp_info("jetty_id:%u will be destroyed, devIndex:0x%x", jettyId, devCbCurr->index);
1841 1 : RsUbCtxDrvJettyDelete(jettyCb);
1842 : }
1843 :
1844 1 : RsUbCtxFreeJettyCb(jettyCb);
1845 1 : return 0;
1846 : }
1847 :
1848 0 : STATIC int RsUbCtxInitRjettyCb(struct RsUbDevCb *devCb, struct RsJettyImportAttr *importAttr,
1849 : struct RsCtxRemJettyCb **rjettyCb)
1850 : {
1851 0 : struct RsCtxRemJettyCb *tmpRjettyCb = NULL;
1852 :
1853 0 : tmpRjettyCb = calloc(1, sizeof(struct RsCtxRemJettyCb));
1854 0 : CHK_PRT_RETURN(tmpRjettyCb == NULL, hccp_err("calloc tmp_rjetty_cb failed, errno:%d", errno), -ENOMEM);
1855 :
1856 0 : tmpRjettyCb->devCb = devCb;
1857 0 : tmpRjettyCb->jettyKey = importAttr->key;
1858 0 : tmpRjettyCb->mode = importAttr->attr.mode;
1859 0 : tmpRjettyCb->tokenValue = importAttr->attr.tokenValue;
1860 0 : tmpRjettyCb->policy = importAttr->attr.policy;
1861 0 : tmpRjettyCb->type = importAttr->attr.type;
1862 0 : tmpRjettyCb->flag = importAttr->attr.flag;
1863 0 : tmpRjettyCb->tpType = importAttr->attr.tpType;
1864 0 : tmpRjettyCb->expImportCfg = importAttr->attr.expImportCfg;
1865 :
1866 0 : *rjettyCb = tmpRjettyCb;
1867 0 : return 0;
1868 : }
1869 :
1870 1 : STATIC void RsUbCtxExpJettyImport(struct RsCtxRemJettyCb *rjettyCb, urma_rjetty_t *rjetty,
1871 : urma_token_t *tokenValue)
1872 : {
1873 1 : urma_import_jetty_ex_cfg_t expCfg = {0};
1874 :
1875 1 : expCfg.tp_handle = rjettyCb->expImportCfg.tpHandle;
1876 1 : expCfg.peer_tp_handle = rjettyCb->expImportCfg.peerTpHandle;
1877 1 : expCfg.tag = rjettyCb->expImportCfg.tag;
1878 1 : expCfg.tp_attr.tx_psn = rjettyCb->expImportCfg.txPsn;
1879 1 : expCfg.tp_attr.rx_psn = rjettyCb->expImportCfg.rxPsn;
1880 :
1881 1 : rjettyCb->tjetty = RsUrmaImportJettyEx(rjettyCb->devCb->urmaCtx, rjetty, tokenValue, &expCfg);
1882 1 : }
1883 :
1884 1 : STATIC int RsUbCtxDrvJettyImport(struct RsCtxRemJettyCb *rjettyCb)
1885 : {
1886 : struct RsJettyKeyInfo *jettyKeyInfo;
1887 1 : urma_token_t tokenValue = {0};
1888 1 : urma_rjetty_t rjetty = {0};
1889 :
1890 1 : tokenValue.token = rjettyCb->tokenValue;
1891 1 : jettyKeyInfo = (struct RsJettyKeyInfo *)rjettyCb->jettyKey.value;
1892 1 : rjetty.jetty_id = jettyKeyInfo->jettyId;
1893 1 : rjetty.trans_mode = jettyKeyInfo->transMode;
1894 1 : rjetty.policy = (urma_jetty_grp_policy_t)rjettyCb->policy;
1895 1 : rjetty.type = (urma_target_type_t)rjettyCb->type;
1896 1 : rjetty.flag.value = rjettyCb->flag.value;
1897 1 : rjetty.tp_type = rjettyCb->tpType;
1898 :
1899 1 : if (rjettyCb->mode == JETTY_IMPORT_MODE_NORMAL) {
1900 0 : rjettyCb->tjetty = RsUrmaImportJetty(rjettyCb->devCb->urmaCtx, &rjetty, &tokenValue);
1901 : } else { // rjetty_cb->mode == JETTY_IMPORT_MODE_EXP
1902 1 : RsUbCtxExpJettyImport(rjettyCb, &rjetty, &tokenValue);
1903 : }
1904 1 : CHK_PRT_RETURN(rjettyCb->tjetty == NULL, hccp_err("import_jetty failed, mode:%d errno:%d", rjettyCb->mode, errno),
1905 : -EOPENSRC);
1906 1 : return 0;
1907 : }
1908 :
1909 1 : int RsUbCtxJettyImport(struct RsUbDevCb *devCb, struct RsJettyImportAttr *importAttr,
1910 : struct RsJettyImportInfo *importInfo)
1911 : {
1912 1 : struct RsCtxRemJettyCb *rjettyCb = NULL;
1913 : int ret;
1914 :
1915 1 : ret = RsUbCtxInitRjettyCb(devCb, importAttr, &rjettyCb);
1916 1 : CHK_PRT_RETURN(ret != 0, hccp_err("alloc mem for rjetty_cb failed, ret:%d", ret), ret);
1917 :
1918 1 : ret = RsUbCtxDrvJettyImport(rjettyCb);
1919 1 : if (ret != 0) {
1920 1 : hccp_err("rs_ub_ctx_drv_jetty_import failed, ret:%d", ret);
1921 1 : goto free_rjetty_cb;
1922 : }
1923 :
1924 0 : importInfo->remJettyId = rjettyCb->tjetty->id.id;
1925 0 : importInfo->info.tjettyHandle = (uint64_t)(uintptr_t)rjettyCb->tjetty;
1926 0 : importInfo->info.tpn = rjettyCb->tjetty->tp.tpn;
1927 :
1928 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1929 0 : RsListAddTail(&rjettyCb->list, &devCb->rjettyList);
1930 0 : devCb->rjettyCnt++;
1931 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1932 :
1933 0 : rjettyCb->state = RS_JETTY_STATE_IMPORTED;
1934 :
1935 0 : hccp_run_info("[init][rs_ctx]devIndex:0x%x rem_qp_id:%u mode:%d import success, rjettyCnt:%u",
1936 : devCb->index, importInfo->remJettyId, importAttr->attr.mode, devCb->rjettyCnt);
1937 :
1938 0 : return 0;
1939 :
1940 1 : free_rjetty_cb:
1941 1 : free(rjettyCb);
1942 1 : rjettyCb = NULL;
1943 :
1944 1 : return ret;
1945 : }
1946 :
1947 0 : STATIC int RsUbGetRemJettyCb(struct RsUbDevCb *devCb, unsigned int remJettyId,
1948 : struct RsCtxRemJettyCb **rjettyCb)
1949 : {
1950 0 : struct RsCtxRemJettyCb **tempJettyCb = rjettyCb;
1951 0 : struct RsCtxRemJettyCb *jettyCbCurr = NULL;
1952 0 : struct RsCtxRemJettyCb *jettyCbNext = NULL;
1953 :
1954 0 : RS_LIST_GET_HEAD_ENTRY(jettyCbCurr, jettyCbNext, &devCb->rjettyList, list, struct RsCtxRemJettyCb);
1955 0 : for (; (&jettyCbCurr->list) != &devCb->rjettyList;
1956 0 : jettyCbCurr = jettyCbNext,
1957 0 : jettyCbNext = list_entry(jettyCbNext->list.next, struct RsCtxRemJettyCb, list)) {
1958 0 : if (jettyCbCurr->tjetty == NULL) {
1959 0 : hccp_warn("rem_jetty_id:%u jetty_cb_curr->tjetty is NULL", remJettyId);
1960 0 : continue;
1961 : }
1962 0 : if (jettyCbCurr->tjetty->id.id == remJettyId) {
1963 0 : *tempJettyCb = jettyCbCurr;
1964 0 : return 0;
1965 : }
1966 : }
1967 :
1968 0 : *tempJettyCb = NULL;
1969 0 : hccp_err("rjetty_cb for rem_jetty %u do not available!", remJettyId);
1970 :
1971 0 : return -ENODEV;
1972 : }
1973 :
1974 0 : int RsUbCtxJettyUnimport(struct RsUbDevCb *devCb, unsigned int remJettyId)
1975 : {
1976 0 : struct RsCtxRemJettyCb *rjettyCb = NULL;
1977 : unsigned int rjettyCnt;
1978 : int ret;
1979 :
1980 0 : ret = RsUbGetRemJettyCb(devCb, remJettyId, &rjettyCb);
1981 0 : CHK_PRT_RETURN(ret != 0, hccp_err("get rjetty_cb failed, ret:%d remJettyId:%u", ret, remJettyId), ret);
1982 0 : CHK_PRT_RETURN(rjettyCb->state != RS_JETTY_STATE_IMPORTED, hccp_err("rjetty_cb->state:%u not support to "
1983 : "unimport, jettyId:%u", rjettyCb->state, remJettyId), -EINVAL);
1984 :
1985 0 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
1986 0 : RsListDel(&rjettyCb->list);
1987 0 : devCb->rjettyCnt--;
1988 0 : rjettyCnt = devCb->rjettyCnt;
1989 0 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
1990 :
1991 0 : ret = RsUrmaUnimportJetty(rjettyCb->tjetty);
1992 0 : if (ret != 0) {
1993 0 : hccp_err("rs_urma_unimport_jetty failed, ret:%d, remJettyId %u", ret, remJettyId);
1994 0 : ret = -EOPENSRC;
1995 0 : goto out;
1996 : }
1997 :
1998 0 : hccp_run_info("[deinit][rs_qp]unimport jetty_id:%u success, rjettyCnt:%u, devIndex:0x%x",
1999 : remJettyId, rjettyCnt, devCb->index);
2000 0 : out:
2001 0 : free(rjettyCb);
2002 0 : rjettyCb = NULL;
2003 0 : return ret;
2004 : }
2005 :
2006 0 : int RsUbCtxJettyBind(struct RsUbDevCb *devCb, struct RsCtxQpInfo *jettyInfo,
2007 : struct RsCtxQpInfo *rjettyInfo)
2008 : {
2009 0 : struct RsCtxRemJettyCb *rjettyCb = NULL;
2010 0 : struct RsCtxJettyCb *jettyCb = NULL;
2011 : int ret;
2012 :
2013 0 : ret = RsUbGetJettyCb(devCb, jettyInfo->id, &jettyCb);
2014 0 : CHK_PRT_RETURN(ret != 0, hccp_err("get jetty_cb failed, ret:%d, jettyId %u", ret, jettyInfo->id), ret);
2015 :
2016 0 : ret = RsUbGetRemJettyCb(devCb, rjettyInfo->id, &rjettyCb);
2017 0 : CHK_PRT_RETURN(ret != 0, hccp_err("get rjetty_cb failed, ret:%d, remJettyId %u", ret, rjettyInfo->id), ret);
2018 :
2019 0 : if (jettyCb->state != RS_JETTY_STATE_CREATED || rjettyCb->state != RS_JETTY_STATE_IMPORTED) {
2020 0 : hccp_err("local jetty id:%u state:%u or remote jetty id:%u state:%u not support to bind",
2021 : jettyInfo->id, jettyCb->state, rjettyInfo->id, rjettyCb->state);
2022 0 : return -EINVAL;
2023 : }
2024 :
2025 0 : ret = RsUrmaBindJetty(jettyCb->jetty, rjettyCb->tjetty);
2026 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_bind_jetty failed, ret:%d errno:%d", ret, errno), -EOPENSRC);
2027 :
2028 0 : jettyCb->state = RS_JETTY_STATE_BIND;
2029 :
2030 0 : hccp_run_info("rs ctx local jetty %u bind rem_jetty %u success, devIndex:0x%x",
2031 : jettyInfo->id, rjettyInfo->id, devCb->index);
2032 :
2033 0 : return 0;
2034 : }
2035 :
2036 0 : int RsUbCtxJettyUnbind(struct RsUbDevCb *devCb, unsigned int jettyId)
2037 : {
2038 0 : struct RsCtxJettyCb *jettyCb = NULL;
2039 : int ret;
2040 :
2041 0 : ret = RsUbGetJettyCb(devCb, jettyId, &jettyCb);
2042 0 : CHK_PRT_RETURN(ret != 0, hccp_run_warn("get jetty_cb unsuccessful, ret:%d, jettyId %u", ret, jettyId), ret);
2043 0 : if (jettyCb->state != RS_JETTY_STATE_BIND) {
2044 0 : hccp_err("jetty_cb->state:%u not support to unbind, jettyId:%u", jettyCb->state, jettyId);
2045 0 : return -EINVAL;
2046 : }
2047 :
2048 0 : ret = RsUrmaUnbindJetty(jettyCb->jetty);
2049 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_unbind_jetty failed, ret:%d jettyId %u", ret, jettyId), -EOPENSRC);
2050 :
2051 0 : jettyCb->state = RS_JETTY_STATE_CREATED;
2052 :
2053 0 : hccp_run_info("rs ctx local jetty %u unbind rem jetty success, devIndex:0x%x", jettyId, devCb->index);
2054 :
2055 0 : return 0;
2056 : }
2057 :
2058 0 : STATIC int RsUbCtxFillLsge(struct RsUbDevCb *devCb, urma_sge_t *lsge, struct BatchSendWrData *wrData,
2059 : unsigned int *totalLen, bool isInline)
2060 : {
2061 0 : struct RsSegCb *segCb = NULL;
2062 0 : unsigned int totalLenTmp = 0;
2063 : unsigned int i;
2064 : int ret;
2065 :
2066 0 : if (isInline == false) {
2067 0 : for (i = 0; i < wrData->numSge; i++) {
2068 0 : lsge[i].addr = wrData->sges[i].addr;
2069 0 : lsge[i].len = wrData->sges[i].len;
2070 0 : totalLenTmp += lsge[i].len;
2071 0 : ret = RsUbQuerySegCb(devCb, wrData->sges[i].devLmemHandle, &segCb, &devCb->lsegList);
2072 0 : CHK_PRT_RETURN(ret != 0, hccp_err("[send][rs_ub_ctx]can not find lmem seg cb for addr:0x%llx",
2073 : lsge[i].addr), ret);
2074 0 : lsge[i].tseg = segCb->segment;
2075 : }
2076 : } else {
2077 0 : lsge[0].addr = (uint64_t)(uintptr_t)wrData->inlineData;
2078 0 : lsge[0].len = wrData->inlineSize;
2079 0 : lsge[0].tseg = NULL;
2080 : }
2081 :
2082 0 : *totalLen = totalLenTmp;
2083 0 : return 0;
2084 : }
2085 :
2086 0 : STATIC int RsUbCtxFillRsge(struct RsUbDevCb *devCb, urma_sge_t *rsge, struct BatchSendWrData *wrData,
2087 : unsigned int totalLen, urma_opcode_t opcode)
2088 : {
2089 0 : struct RsSegCb *segCb = NULL;
2090 : int ret;
2091 :
2092 0 : rsge[0].addr = wrData->remoteAddr;
2093 0 : rsge[0].len = totalLen;
2094 0 : ret = RsUbQuerySegCb(devCb, wrData->devRmemHandle, &segCb, &devCb->rsegList);
2095 0 : CHK_PRT_RETURN(ret != 0, hccp_err("[send][rs_ub_ctx]can not find rmem seg cb for addr:0x%llx",
2096 : rsge[0].addr), ret);
2097 0 : rsge[0].tseg = segCb->segment;
2098 :
2099 0 : if (opcode == URMA_OPC_WRITE_NOTIFY) {
2100 0 : rsge[1].addr = wrData->ub.notifyInfo.notifyAddr;
2101 0 : rsge[1].len = 8; /* notify data is fixed 8 bytes */
2102 0 : ret = RsUbQuerySegCb(devCb, wrData->ub.notifyInfo.notifyHandle, &segCb, &devCb->rsegList);
2103 0 : CHK_PRT_RETURN(ret != 0, hccp_err("[send][rs_ub_ctx]can not find rmem seg cb for addr:0x%llx",
2104 : rsge[1].addr), ret);
2105 0 : rsge[1].tseg = segCb->segment;
2106 : }
2107 :
2108 0 : return 0;
2109 : }
2110 :
2111 0 : STATIC int RsUbCtxInitRwWr(struct RsUbDevCb *devCb, urma_jfs_wr_t *ubWr, struct BatchSendWrData *wrData,
2112 : urma_sge_t *lsge, urma_sge_t *rsge)
2113 : {
2114 : unsigned int lsgeNum, rsgeNum;
2115 0 : unsigned int totalLen = 0;
2116 : int ret;
2117 :
2118 0 : lsgeNum = (ubWr->flag.bs.inline_flag == 0) ? wrData->numSge : 1;
2119 0 : ret = RsUbCtxFillLsge(devCb, lsge, wrData, &totalLen, ubWr->flag.bs.inline_flag);
2120 0 : CHK_PRT_RETURN(ret != 0, hccp_err("[send][rs_ub_ctx]fill lsge failed, ret:%d", ret), ret);
2121 :
2122 : /* write with norify have 2 dst sge, sge[0] is data sge, sge[1] is notify sge */
2123 0 : rsgeNum = (ubWr->opcode == URMA_OPC_WRITE_NOTIFY) ? 2 : 1;
2124 0 : ret = RsUbCtxFillRsge(devCb, rsge, wrData, totalLen, ubWr->opcode);
2125 0 : CHK_PRT_RETURN(ret != 0, hccp_err("[send][rs_ub_ctx]fill rsge failed, ret:%d", ret), ret);
2126 :
2127 0 : if (ubWr->opcode == URMA_OPC_READ) {
2128 0 : ubWr->rw.src.sge = rsge;
2129 0 : ubWr->rw.src.num_sge = rsgeNum;
2130 0 : ubWr->rw.dst.sge = lsge;
2131 0 : ubWr->rw.dst.num_sge = lsgeNum;
2132 : } else {
2133 0 : ubWr->rw.src.sge = lsge;
2134 0 : ubWr->rw.src.num_sge = lsgeNum;
2135 0 : ubWr->rw.dst.sge = rsge;
2136 0 : ubWr->rw.dst.num_sge = rsgeNum;
2137 : }
2138 :
2139 : // assign notify data & imm data
2140 0 : if (ubWr->opcode == URMA_OPC_WRITE_NOTIFY) {
2141 0 : ubWr->rw.notify_data = wrData->ub.notifyInfo.notifyData;
2142 : } else {
2143 0 : ubWr->rw.notify_data = (uint64_t)wrData->immData;
2144 : }
2145 :
2146 0 : return 0;
2147 : }
2148 :
2149 0 : STATIC int RsUbCtxInitJfsWr(struct RsCtxJettyCb *jettyCb, struct udma_u_jfs_wr_ex *ubWr,
2150 : struct BatchSendWrData *wrData, urma_sge_t *lsge, urma_sge_t *rsge)
2151 : {
2152 0 : urma_opcode_t opcode = (urma_opcode_t)wrData->ub.opcode;
2153 0 : struct RsCtxRemJettyCb *rjettyCb = NULL;
2154 : int ret;
2155 :
2156 0 : if (wrData->numSge > MAX_SGE_NUM) {
2157 0 : hccp_err("[send][rs_ub_ctx]num_sge is invalid, numSge[%d]", wrData->numSge);
2158 0 : return -EINVAL;
2159 : }
2160 :
2161 0 : ubWr->wr.opcode = opcode;
2162 0 : ubWr->wr.flag.value = wrData->ub.flags.value;
2163 0 : ubWr->wr.user_ctx = wrData->ub.userCtx;
2164 :
2165 0 : if (opcode == URMA_OPC_NOP) {
2166 0 : return 0;
2167 : }
2168 :
2169 : // only write & write with notify & read op support inline reduce
2170 0 : if (opcode == URMA_OPC_READ || opcode == URMA_OPC_WRITE || opcode == URMA_OPC_WRITE_NOTIFY) {
2171 0 : ubWr->reduce_en = wrData->ub.reduceInfo.reduceEn;
2172 0 : ubWr->reduce_opcode = wrData->ub.reduceInfo.reduceOpcode;
2173 0 : ubWr->reduce_data_type = wrData->ub.reduceInfo.reduceDataType;
2174 0 : hccp_dbg("[send][rs_ub_ctx]opcode[%d] reduce_en[%d] reduce_opcode[%d] reduce_data_type[%d]",
2175 : opcode, ubWr->reduce_en, ubWr->reduce_opcode, ubWr->reduce_data_type);
2176 : }
2177 :
2178 0 : if (opcode == URMA_OPC_READ || opcode == URMA_OPC_WRITE || opcode == URMA_OPC_WRITE_NOTIFY ||
2179 : opcode == URMA_OPC_WRITE_IMM) {
2180 0 : ret = RsUbGetRemJettyCb(jettyCb->devCb, (unsigned int)wrData->ub.remJetty, &rjettyCb);
2181 0 : CHK_PRT_RETURN(ret != 0, hccp_err("[send][rs_ub_ctx]get rjetty_cb failed, ret:%d remJettyId:%llu", ret, wrData->ub.remJetty), ret);
2182 :
2183 0 : ubWr->wr.tjetty = rjettyCb->tjetty;
2184 0 : return RsUbCtxInitRwWr(jettyCb->devCb, &ubWr->wr, wrData, lsge, rsge);
2185 : }
2186 :
2187 0 : hccp_err("[send][rs_ub_ctx]invalid opcode[%d]", opcode);
2188 0 : return -EINVAL;
2189 : }
2190 :
2191 0 : STATIC int RsUbCtxBatchSendWrExt(struct RsCtxJettyCb *jettyCb, struct BatchSendWrData *wrData,
2192 : struct SendWrResp *wrResp, struct WrlistSendCompleteNum *wrlistNum)
2193 : {
2194 : #define UB_DWQE_BB_NUM 2U
2195 : #define UB_DWQE_BB_SIZE 64U
2196 0 : unsigned int sendNum = wrlistNum->sendNum;
2197 0 : struct udma_u_jfs_wr_ex *badWr = NULL;
2198 0 : struct udma_u_post_info wrOut = {0};
2199 0 : urma_sge_t rsge[MAX_RSGE_NUM] = {0};
2200 0 : urma_sge_t lsge[MAX_SGE_NUM] = {0};
2201 0 : struct udma_u_jfs_wr_ex ubWr = {0};
2202 0 : struct udma_u_wr_ex wrIn = {0};
2203 0 : urma_user_ctl_out_t out = {0};
2204 0 : urma_user_ctl_in_t in = {0};
2205 : unsigned int i;
2206 0 : int ret = 0;
2207 :
2208 0 : for (i = 0; i < sendNum; i++) {
2209 0 : ret = RsUbCtxInitJfsWr(jettyCb, &ubWr, &wrData[i], &lsge[0], &rsge[0]);
2210 0 : if (ret != 0) {
2211 0 : hccp_err("[send][rs_ub_ctx]init jfs wr failed, ret:%d, curr_num[%u], sendNum[%u]", ret, i, sendNum);
2212 0 : break;
2213 : }
2214 :
2215 0 : wrIn.is_jetty = true;
2216 0 : wrIn.jetty = jettyCb->jetty;
2217 0 : wrIn.wr = &ubWr;
2218 0 : wrIn.bad_wr = &badWr;
2219 :
2220 0 : in.addr = (uint64_t)(uintptr_t)&wrIn;
2221 0 : in.len = (uint32_t)sizeof(struct udma_u_wr_ex);
2222 0 : in.opcode = UDMA_U_USER_CTL_POST_WR;
2223 :
2224 0 : out.addr = (uint64_t)(uintptr_t)&wrOut;
2225 0 : out.len = sizeof(struct udma_u_post_info);
2226 :
2227 0 : ret = RsUrmaUserCtl(jettyCb->devCb->urmaCtx, &in, &out);
2228 0 : if (ret != 0) {
2229 0 : hccp_err("rs_urma_user_ctl batch send wr failed, ret:%d, wr[%u], sendNum[%u] errno:%d",
2230 : ret, i, sendNum, errno);
2231 0 : ret = -EOPENSRC;
2232 0 : break;
2233 : }
2234 :
2235 0 : wrResp[i].doorbellInfo.dieId = (uint16_t)jettyCb->devCb->devAttr.ub.dieId;
2236 0 : wrResp[i].doorbellInfo.funcId = (uint16_t)jettyCb->devCb->devAttr.ub.funcId;
2237 0 : wrResp[i].doorbellInfo.jettyId = (uint16_t)jettyCb->jetty->jetty_id.id;
2238 0 : wrResp[i].doorbellInfo.piVal = (uint16_t)wrOut.pi;
2239 : // prepare dwqe doorbell info, only support 2BB, each BB size is 64B
2240 0 : if (wrOut.pi - jettyCb->lastPi <= UB_DWQE_BB_NUM) {
2241 0 : wrResp[i].doorbellInfo.dwqeSize = (uint16_t)(wrOut.pi - jettyCb->lastPi) * UB_DWQE_BB_SIZE;
2242 0 : ret = memcpy_s(wrResp[i].doorbellInfo.dwqe, wrResp[i].doorbellInfo.dwqeSize,
2243 0 : wrOut.ctrl, wrResp[i].doorbellInfo.dwqeSize);
2244 0 : if (ret != 0) {
2245 0 : hccp_err("[send][rs_ub_ctx]memcpy_s failed, ret:%d, wr[%u], sendNum[%u]", ret, i, sendNum);
2246 0 : ret = -ESAFEFUNC;
2247 0 : break;
2248 : }
2249 : }
2250 0 : jettyCb->lastPi = wrOut.pi;
2251 :
2252 : // record doorbell info
2253 0 : hccp_dbg("jetty_id %u post info: dwqe_addr:%pK, dbAddr:%pK, ctrl:%pK, pi:%u",
2254 : jettyCb->jetty->jetty_id.id, wrOut.dwqe_addr, wrOut.db_addr, wrOut.ctrl, wrOut.pi);
2255 : }
2256 :
2257 0 : *wrlistNum->completeNum = i;
2258 0 : return ret;
2259 : }
2260 :
2261 2 : int RsUbCtxBatchSendWr(struct rs_cb *rsCb, struct WrlistBaseInfo *baseInfo,
2262 : struct BatchSendWrData *wrData, struct SendWrResp *wrResp, struct WrlistSendCompleteNum *wrlistNum)
2263 : {
2264 2 : struct RsCtxJettyCb *jettyCb = NULL;
2265 2 : struct RsUbDevCb *devCb = NULL;
2266 : int ret;
2267 :
2268 2 : if (wrlistNum->sendNum > MAX_CTX_WR_NUM || wrlistNum->sendNum == 0) {
2269 0 : hccp_err("[send][rs_ub_ctx] send_num[%u] is invalid", wrlistNum->sendNum);
2270 0 : return -EINVAL;
2271 : }
2272 :
2273 2 : ret = RsUbGetDevCb(rsCb, baseInfo->devIndex, &devCb);
2274 2 : CHK_PRT_RETURN(ret != 0, hccp_err("[send][rs_ub_ctx]get dev_cb failed, ret:%d, devIndex:0x%x", ret, baseInfo->devIndex), ret);
2275 :
2276 1 : ret = RsUbGetJettyCb(devCb, baseInfo->qpn, &jettyCb);
2277 1 : CHK_PRT_RETURN(ret != 0, hccp_err("[send][rs_ub_ctx]get jetty_cb failed, ret:%d, jettyId[%u]", ret, baseInfo->qpn), ret);
2278 :
2279 0 : ret = RsUbCtxBatchSendWrExt(jettyCb, wrData, wrResp, wrlistNum);
2280 0 : CHK_PRT_RETURN(ret != 0, hccp_err("[send][rs_ub_ctx]send wr ext failed, ret:%d, sendNum[%u], completeNum[%u]",
2281 : ret, wrlistNum->sendNum, *wrlistNum->completeNum), ret);
2282 :
2283 0 : return 0;
2284 : }
2285 :
2286 0 : int RsUbCtxJettyUpdateCi(struct RsUbDevCb *devCb, unsigned int jettyId, uint16_t ci)
2287 : {
2288 0 : struct RsCtxJettyCb *jettyCb = NULL;
2289 0 : struct udma_u_update_ci ciData = { 0 };
2290 0 : urma_user_ctl_out_t out = { 0 };
2291 0 : urma_user_ctl_in_t in = { 0 };
2292 : int ret;
2293 :
2294 0 : ret = RsUbGetJettyCb(devCb, jettyId, &jettyCb);
2295 0 : CHK_PRT_RETURN(ret != 0, hccp_err("get jetty_cb failed, ret:%d, jettyId:%u", ret, jettyId), ret);
2296 :
2297 0 : ciData.is_jetty = true;
2298 0 : ciData.ci = ci;
2299 0 : ciData.jetty = jettyCb->jetty;
2300 0 : in.addr = (uint64_t)(uintptr_t)&ciData;
2301 0 : in.len = (uint32_t)sizeof(struct udma_u_update_ci);
2302 0 : in.opcode = UDMA_U_USER_CTL_UPDATE_CI;
2303 0 : ret = RsUrmaUserCtl(jettyCb->devCb->urmaCtx, &in, &out);
2304 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_urma_user_ctl update ci failed, ret:%d errno:%d jettyId:%u ci:%u",
2305 : ret, errno, jettyId, ci), -EOPENSRC);
2306 :
2307 0 : hccp_info("[update_ci]devIndex:0x%x jetty_id:%u update ci:%u success", devCb->index, jettyId, ci);
2308 :
2309 0 : return 0;
2310 : }
2311 :
2312 5 : STATIC int RsUbGetJettyDestroyBatchInfo(struct RsUbDevCb *devCb, unsigned int jettyIds[],
2313 : struct JettyDestroyBatchInfo *batchInfo, unsigned int *num)
2314 : {
2315 : unsigned int i;
2316 5 : int ret = 0;
2317 :
2318 8 : for (i = 0; i < *num; ++i) {
2319 5 : ret = RsUbGetJettyCb(devCb, jettyIds[i], &batchInfo->jettyCbArr[i]);
2320 5 : CHK_PRT_RETURN(ret != 0, hccp_err("get jetty_cb[%u] failed, jettyId:%u, ret:%d", i, jettyIds[i], ret), ret);
2321 4 : CHK_PRT_RETURN(batchInfo->jettyCbArr[i]->state != RS_JETTY_STATE_CREATED, hccp_err("jetty_cb[%u]->state:%u "
2322 : "not support to destroy, jettyId:%u", i, batchInfo->jettyCbArr[i]->state, jettyIds[i]), -EINVAL);
2323 :
2324 3 : RS_PTHREAD_MUTEX_LOCK(&devCb->mutex);
2325 3 : RsListDel(&batchInfo->jettyCbArr[i]->list);
2326 3 : devCb->jettyCnt--;
2327 3 : RS_PTHREAD_MUTEX_ULOCK(&devCb->mutex);
2328 :
2329 3 : batchInfo->jettyArr[i] = batchInfo->jettyCbArr[i]->jetty;
2330 : }
2331 :
2332 3 : return ret;
2333 : }
2334 :
2335 9 : int RsUbCtxJettyDestroyBatch(struct RsUbDevCb *devCb, unsigned int jettyIds[], unsigned int *num)
2336 : {
2337 9 : struct JettyDestroyBatchInfo batchInfo = {0};
2338 : int ret;
2339 :
2340 9 : CHK_PRT_RETURN(*num == 0, hccp_err("num(%u) = 0, no need to destroy batch", *num), -EINVAL);
2341 :
2342 8 : ret = RsUbCallocJettyBatchInfo(&batchInfo, *num);
2343 8 : if (ret != 0) {
2344 1 : *num = 0;
2345 1 : hccp_err("rs_ub_calloc_jetty_batch_info failed, ret:%d", ret);
2346 1 : goto free_batch_info;
2347 : }
2348 :
2349 7 : ret = RsUbGetJettyDestroyBatchInfo(devCb, jettyIds, &batchInfo, num);
2350 7 : if (ret != 0) {
2351 2 : *num = 0;
2352 2 : hccp_err("get jetty destroy batch info failed, ret:%d", ret);
2353 2 : goto free_batch_info;
2354 : }
2355 :
2356 5 : ret = RsUbDestroyJettyCbBatch(&batchInfo, num);
2357 5 : if (ret != 0) {
2358 2 : hccp_err("rs_ub_destroy_jetty_cb_batch failed, ret:%d", ret);
2359 : }
2360 :
2361 3 : free_batch_info:
2362 8 : RsUbFreeJettyBatchInfo(&batchInfo);
2363 8 : return ret;
2364 : }
2365 :
2366 3 : int RsUbCtxQueryJettyBatch(struct RsUbDevCb *devCb, unsigned int jettyIds[], struct JettyAttr attr[],
2367 : unsigned int *num)
2368 : {
2369 3 : struct RsCtxJettyCb *jettyCb = NULL;
2370 3 : urma_jetty_attr_t attrTmp = {0};
2371 3 : urma_jetty_cfg_t cfg = {0};
2372 3 : unsigned int i = 0;
2373 3 : int ret = 0;
2374 :
2375 6 : for (i = 0; i < *num; ++i) {
2376 5 : (void)memset_s(&attrTmp, sizeof(urma_jetty_attr_t), 0, sizeof(urma_jetty_attr_t));
2377 5 : ret = RsUbGetJettyCb(devCb, jettyIds[i], &jettyCb);
2378 5 : if (ret != 0) {
2379 1 : hccp_err("get jetty_cb failed, ret:%d, jettyId[%u]:%u", ret, i, jettyIds[i]);
2380 1 : break;
2381 : }
2382 :
2383 4 : ret = RsUrmaQueryJetty(jettyCb->jetty, &cfg, &attrTmp);
2384 4 : if (ret != 0) {
2385 1 : hccp_err("rs_urma_query_jetty failed, ret:%d, jettyId[%u]:%u", ret, i, jettyIds[i]);
2386 1 : break;
2387 : }
2388 :
2389 3 : (void)memcpy_s(&attr[i], sizeof(urma_jetty_attr_t), &attrTmp, sizeof(urma_jetty_attr_t));
2390 : }
2391 :
2392 3 : *num = i;
2393 3 : return ret;
2394 : }
|
