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