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