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