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 : #define _GNU_SOURCE
12 : #include "rs.h"
13 : #include "ra_rs_err.h"
14 : #include <unistd.h>
15 : #include <string.h>
16 : #include <stdlib.h>
17 : #include <sys/types.h>
18 : #include <ifaddrs.h>
19 : #include <netinet/in.h>
20 : #include <sys/epoll.h>
21 : #include <sys/eventfd.h>
22 : #include <sys/socket.h>
23 : #include <sys/fcntl.h>
24 : #include <arpa/inet.h>
25 : #include <dlfcn.h>
26 : #include <fnmatch.h>
27 : #include "securec.h"
28 : #include "rs_common_inner.h"
29 : #include "rs_inner.h"
30 : #include "rs_rdma_inner.h"
31 : #include "rs_nda.h"
32 : #include "rs_epoll.h"
33 : #include "rs_tls.h"
34 : #include "ssl_adp.h"
35 : #include "rs_socket.h"
36 : #include "dl_ibverbs_function.h"
37 : #include "dl_hal_function.h"
38 : #include "rs_drv_rdma.h"
39 : #include "file_opt.h"
40 : #ifdef CONFIG_TLV
41 : #include "rs_tlv.h"
42 : #endif
43 : #include "ra_rs_ctx.h"
44 : #include "rs_ctx.h"
45 : #include "rs_esched.h"
46 : #include "dl_net_function.h"
47 : #include "rs_ub.h"
48 : #include "rs_ctx_inner.h"
49 :
50 : __thread struct rs_cb *gRsCb = NULL; //lint !e17
51 : struct rs_cb *gRsCbList[RS_MAX_DEV_NUM] = {0}; //lint !e17
52 : int gInitCounter[RS_MAX_DEV_NUM] = {0};
53 :
54 : /* set current phyId g_rs_cb */
55 1 : void RsSetCtx(unsigned int phyId)
56 : {
57 1 : gRsCb = gRsCbList[phyId];
58 1 : }
59 :
60 : /* get current g_rs_cb */
61 3 : static struct rs_cb *RsGetCurRsCb(void)
62 : {
63 195 : for (int i = 0; i < RS_MAX_DEV_NUM; i++) {
64 192 : if (gRsCbList[i] != NULL) {
65 0 : hccp_info("[rs_get_cur_rs_cb], phyId[%u], rsCb[%p]", i, gRsCbList[i]);
66 0 : return gRsCbList[i];
67 : }
68 : }
69 3 : return NULL;
70 : }
71 :
72 359 : RS_ATTRI_VISI_DEF void RsGetCurTime(struct timeval *time)
73 : {
74 : int ret;
75 :
76 359 : RS_CHECK_POINTER_NULL_RETURN_VOID(time);
77 359 : ret = gettimeofday(time, NULL);
78 359 : if (ret) {
79 1 : hccp_warn("gettimeofday unsuccessful, ret[%d] expect 0", ret);
80 1 : ret = memset_s(time, sizeof(struct timeval), 0, sizeof(struct timeval));
81 1 : if (ret) {
82 1 : hccp_warn("memset_s unsuccessful, ret[%d] expect 0", ret);
83 : }
84 : }
85 :
86 359 : return;
87 : }
88 :
89 163 : RS_ATTRI_VISI_DEF void HccpTimeInterval(struct timeval *endTime, struct timeval *startTime, float *msec)
90 : {
91 163 : RS_CHECK_POINTER_NULL_RETURN_VOID(endTime);
92 163 : RS_CHECK_POINTER_NULL_RETURN_VOID(startTime);
93 163 : RS_CHECK_POINTER_NULL_RETURN_VOID(msec);
94 :
95 : /* if low position is sufficient, then borrow one from the high position */
96 163 : if (endTime->tv_usec < startTime->tv_usec) {
97 3 : endTime->tv_sec -= 1;
98 3 : endTime->tv_usec += MS_PER_SECOND_I * MS_PER_SECOND_I;
99 : }
100 :
101 163 : *msec = (float)((endTime->tv_sec - startTime->tv_sec) * MS_PER_SECOND_F +
102 163 : (endTime->tv_usec - startTime->tv_usec) / US_PER_MS_F);
103 :
104 163 : return;
105 : }
106 :
107 76 : RS_ATTRI_VISI_DEF void RsHeartbeatAlivePrint(struct RsPthreadInfo *pthreadInfo)
108 : {
109 76 : float timeCost = 0.0;
110 : struct timeval now;
111 :
112 76 : if (pthreadInfo == NULL) {
113 0 : hccp_err("pthread_info is NULL!");
114 0 : return;
115 : }
116 :
117 76 : RsGetCurTime(&now);
118 76 : HccpTimeInterval(&now, &pthreadInfo->lastCheckTime, &timeCost);
119 76 : if (timeCost >= RS_HEARTBEAT_TIME || timeCost <= 0) {
120 0 : hccp_info("pthread[%s] is alive!", pthreadInfo->pthreadName);
121 0 : RsGetCurTime(&pthreadInfo->lastCheckTime);
122 : }
123 :
124 76 : return;
125 : }
126 :
127 472 : int RsDev2rscb(uint32_t chipId, struct rs_cb **rsCb, bool initFlag)
128 : {
129 472 : if (gRsCb == NULL) {
130 43 : if (initFlag == false) {
131 2 : hccp_warn("No device initialized !");
132 : }
133 43 : return -ENODEV;
134 : }
135 :
136 429 : if (chipId == gRsCb->chipId) {
137 426 : *rsCb = gRsCb;
138 426 : return 0;
139 : }
140 :
141 3 : hccp_warn("get rs cb unsuccessful for dev %u !", chipId);
142 3 : *rsCb = NULL;
143 :
144 3 : return -ENODEV;
145 : }
146 :
147 32 : int RsGetHccpMode(unsigned int chipId)
148 : {
149 32 : struct rs_cb *rsCb = NULL;
150 : int ret;
151 :
152 32 : ret = RsDev2rscb(chipId, &rsCb, false);
153 32 : CHK_PRT_RETURN(ret, hccp_err("get rs_cb failed(%d)", ret), ret);
154 31 : return (int)rsCb->hccpMode;
155 : }
156 :
157 93 : int RsDev2conncb(uint32_t chipId, struct RsConnCb **connCb)
158 : {
159 : int ret;
160 93 : struct rs_cb *rsCb = NULL;
161 :
162 93 : ret = RsDev2rscb(chipId, &rsCb, false);
163 93 : CHK_PRT_RETURN(ret, hccp_err("get rs_cb failed(%d)", ret), ret);
164 :
165 93 : *connCb = &(rsCb->connCb);
166 :
167 93 : return 0;
168 : }
169 :
170 253 : int RsGetRdevCb(struct rs_cb *rsCb, unsigned int rdevIndex, struct RsRdevCb **rdevCb)
171 : {
172 253 : struct RsRdevCb *rdevCbTmp = NULL;
173 253 : struct RsRdevCb *rdevCbTmp2 = NULL;
174 :
175 253 : RS_LIST_GET_HEAD_ENTRY(rdevCbTmp, rdevCbTmp2, &rsCb->rdevList, list, struct RsRdevCb);
176 254 : for (; (&rdevCbTmp->list) != &rsCb->rdevList;
177 1 : rdevCbTmp = rdevCbTmp2, rdevCbTmp2 = list_entry(rdevCbTmp2->list.next, struct RsRdevCb, list)) {
178 253 : if (rdevCbTmp->rdevIndex == rdevIndex) {
179 252 : *rdevCb = rdevCbTmp;
180 252 : return 0;
181 : }
182 : }
183 :
184 1 : *rdevCb = NULL;
185 1 : hccp_err("rdev_cb for rdev_index[%u] do not available!", rdevIndex);
186 :
187 1 : return -ENODEV;
188 : }
189 :
190 46 : int RsRdev2rdevCb(unsigned int chipId, unsigned int rdevIndex, struct RsRdevCb **rdevCb)
191 : {
192 : int ret;
193 46 : struct rs_cb *rsCb = NULL;
194 :
195 46 : ret = RsDev2rscb(chipId, &rsCb, false);
196 46 : CHK_PRT_RETURN(ret, hccp_err("get rs_cb failed for chipId:%u, ret:%d", chipId, ret), -ENODEV);
197 :
198 46 : ret = RsGetRdevCb(rsCb, rdevIndex, rdevCb);
199 46 : CHK_PRT_RETURN(ret, hccp_err("rs_get_rdev_cb failed!, ret %d, rdevIndex %u", ret, rdevIndex), ret);
200 :
201 45 : return 0;
202 : }
203 :
204 43 : STATIC int RsPthreadMutexInit(struct rs_cb *rscb, struct RsInitConfig *cfg)
205 : {
206 : int ret;
207 : int err;
208 :
209 43 : RS_CHECK_POINTER_NULL_RETURN_INT(cfg);
210 43 : RS_CHECK_POINTER_NULL_RETURN_INT(rscb);
211 43 : rscb->chipId = cfg->chipId;
212 43 : rscb->hccpMode = cfg->hccpMode;
213 43 : rscb->connCb.rscb = rscb;
214 :
215 43 : ret = pthread_mutex_init(&rscb->mutex, NULL);
216 43 : CHK_PRT_RETURN(ret, hccp_err("rscb mutex_init failed ret %d!, normal ret 0", ret), -ESYSFUNC);
217 42 : ret = pthread_mutex_init(&rscb->connCb.connMutex, NULL);
218 42 : if (ret) {
219 0 : hccp_err("conn_cb mutex_init failed ret %d, normal ret 0!", ret);
220 0 : err = pthread_mutex_destroy(&rscb->mutex);
221 0 : hccp_dbg("pthread destroy ret %d", err);
222 0 : return -ESYSFUNC;
223 : }
224 :
225 42 : hccp_info("mutex init ok");
226 :
227 42 : RS_INIT_LIST_HEAD(&rscb->connCb.listenList);
228 42 : RS_INIT_LIST_HEAD(&rscb->connCb.serverAcceptList);
229 42 : RS_INIT_LIST_HEAD(&rscb->connCb.clientConnList);
230 42 : RS_INIT_LIST_HEAD(&rscb->connCb.serverConnList);
231 42 : RS_INIT_LIST_HEAD(&rscb->connCb.whiteList);
232 42 : RS_INIT_LIST_HEAD(&rscb->rdevList);
233 42 : RS_INIT_LIST_HEAD(&rscb->udevList);
234 42 : RS_INIT_LIST_HEAD(&rscb->heterogTcpFdList);
235 42 : rscb->connCb.wlistEnable = cfg->whiteListStatus;
236 42 : return 0;
237 : }
238 :
239 43 : STATIC int RsGetChipLogicId(unsigned int chipId, enum NetworkMode hccpMode, unsigned int *logicId)
240 : {
241 43 : int ret = 0;
242 :
243 43 : ret = DlDrvDeviceGetIndexByPhyId(chipId, logicId);
244 43 : CHK_PRT_RETURN(ret != 0, hccp_err("hal get logicId failed, chipId[%u], ret[%d]", chipId, ret), -ENODEV);
245 :
246 43 : return 0;
247 : }
248 :
249 : #ifdef CUSTOM_INTERFACE
250 43 : STATIC int RsInitNetAdapt(struct rs_cb *rscb) {
251 43 : int ret = 0;
252 :
253 43 : if (rscb->protocol != PROTOCOL_UDMA) {
254 43 : return 0;
255 : }
256 :
257 0 : ret = RsNetAdaptInit();
258 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_net_adapt_init chipId[%u] logic_devid[%u] failed, ret=%d",
259 : rscb->chipId, rscb->logicId, ret), ret);
260 :
261 0 : return ret;
262 : }
263 : #endif
264 :
265 : #ifdef CUSTOM_INTERFACE
266 0 : STATIC void RsDeInitNetAdapt(struct rs_cb *rscb) {
267 0 : if (rscb->protocol != PROTOCOL_UDMA) {
268 0 : return;
269 : }
270 :
271 0 : RsNetAdaptUninit();
272 : }
273 : #endif
274 :
275 43 : STATIC int RsInitRscbCfg(struct rs_cb *rscb)
276 : {
277 : enum ProductType productType;
278 : struct timeval start, end;
279 43 : float timeCost = 0.0;
280 : int ret;
281 :
282 43 : ret = RsGetChipLogicId(rscb->chipId, rscb->hccpMode, &rscb->logicId);
283 43 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_get_chip_logic_id failed, ret[%d]", ret), ret);
284 :
285 43 : productType = RsGetProductType(rscb->logicId);
286 43 : CHK_PRT_RETURN(productType == PRODUCT_TYPE_INVALID, hccp_err("RsGetProductType failed, logicId:%u", rscb->logicId),
287 : -EINVAL);
288 : #ifdef CUSTOM_INTERFACE
289 43 : if (RsIsUdmaSupported() || RsIsRdmaSupported()) {
290 0 : ret = RsGetChipProtocol(rscb->chipId, rscb->hccpMode, &rscb->protocol, rscb->logicId);
291 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_get_chip_protocol failed, ret[%d]", ret), ret);
292 : // make sure RsRoceGetApiVersion and RsNetGetApiVersion are valid
293 0 : ret = RsCtxApiInit(rscb->hccpMode, rscb->protocol);
294 0 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_ctx_api_init failed, ret[%d]", ret), ret);
295 0 : ret = RsEschedInit(rscb);
296 0 : if (ret != 0) {
297 0 : hccp_err("rs_esched_init chipId[%u] logic_devid[%u] failed, ret=%d productType=%d",
298 : rscb->chipId, rscb->logicId, ret, productType);
299 0 : goto esched_init_err;
300 : }
301 : }
302 :
303 43 : ret = RsInitNetAdapt(rscb);
304 43 : if (ret != 0) {
305 0 : goto net_adapt_init_err;
306 : }
307 :
308 : #endif
309 :
310 43 : ret = rs_ssl_init(rscb);
311 43 : if (ret != 0) {
312 0 : hccp_err("init ssl failed, ret[%d]", ret);
313 0 : goto ssl_init_err;
314 : }
315 :
316 43 : RsGetCurTime(&start);
317 43 : ret = RsEpollConnectHandleInit(rscb);
318 43 : if (ret != 0) {
319 3 : hccp_err("create pthread failed, ret[%d]", ret);
320 3 : goto create_pthread_err;
321 : }
322 :
323 40 : RsGetCurTime(&end);
324 40 : HccpTimeInterval(&end, &start, &timeCost);
325 40 : hccp_info("rs_epoll_connect_handle_init ok cost [%f] ms", timeCost);
326 40 : return 0;
327 :
328 3 : create_pthread_err:
329 3 : rs_ssl_deinit(rscb);
330 3 : ssl_init_err:
331 : #ifdef CUSTOM_INTERFACE
332 3 : if (RsIsUdmaSupported() || RsIsRdmaSupported()) {
333 0 : RsDeInitNetAdapt(rscb);
334 0 : net_adapt_init_err:
335 0 : RsEschedDeinit(rscb->protocol);
336 0 : esched_init_err:
337 0 : (void)RsCtxApiDeinit(rscb->hccpMode, rscb->protocol);
338 : }
339 : #endif
340 3 : return ret;
341 : }
342 :
343 1 : STATIC void RsDeinitRscbCfg(struct rs_cb *rscb)
344 : {
345 1 : int tryAgain = RS_TRY_TIME;
346 1 : eventfd_t event = 1;
347 : int ret;
348 :
349 : #ifdef CUSTOM_INTERFACE
350 1 : if (RsIsUdmaSupported() || RsIsRdmaSupported()) {
351 0 : RsDeInitNetAdapt(rscb);
352 0 : RsEschedDeinit(rscb->protocol);
353 0 : (void)RsCtxApiDeinit(rscb->hccpMode, rscb->protocol);
354 : }
355 : #endif
356 1 : rs_ssl_deinit(rscb);
357 : // deinit resources in rs_epoll_connect_handle_init
358 : // deinit epoll thread, send event to eventfd to waking up epoll handle thread
359 1 : ret = (int)write(rscb->connCb.eventfd, &event, sizeof(eventfd_t));
360 1 : if (ret != sizeof(eventfd_t)) {
361 0 : hccp_warn("eventfd_write unsuccessful(0x%x), chipId:%u, errno:%d", ret, rscb->chipId, errno);
362 : }
363 2 : while (((rscb->state & RS_STATE_HALT) == 0) && (tryAgain != 0)) {
364 1 : usleep(RS_USLEEP_TIME);
365 1 : tryAgain--;
366 : };
367 1 : if (tryAgain == 0) {
368 0 : hccp_warn("try_again exhausted, epoll thread quit unsuccessful, rscb state:%u", rscb->state);
369 : }
370 1 : rscb->state &= ~RS_STATE_HALT;
371 :
372 : // deinit connect thread, already been RS_CONN_EXIT_FLAG, no need to change conn_flag
373 1 : if (rscb->connFlag != RS_CONN_EXIT_FLAG) {
374 1 : rscb->connFlag = 0;
375 : }
376 1 : tryAgain = RS_TRY_TIME;
377 200 : while ((rscb->connFlag != RS_CONN_EXIT_FLAG) && (tryAgain != 0)) {
378 199 : usleep(RS_USLEEP_TIME);
379 199 : tryAgain--;
380 : }
381 1 : if (tryAgain == 0) {
382 0 : hccp_warn("try_again exhausted, connect thread quit unsuccessful, rscb connFlag:%d", rscb->connFlag);
383 : }
384 :
385 1 : RsDestroyEpoll(rscb);
386 1 : }
387 :
388 44 : RS_ATTRI_VISI_DEF int RsInit(struct RsInitConfig *cfg)
389 : {
390 44 : struct rs_cb *rscb = NULL;
391 : int ret;
392 :
393 44 : RS_CHECK_POINTER_NULL_RETURN_INT(cfg);
394 44 : ret = DlHalInit();
395 44 : if (ret != 0) {
396 0 : hccp_err("[init][rs_init]dl_hal_init failed, ret = %d", ret);
397 0 : return ret;
398 : }
399 :
400 44 : int counter = __sync_fetch_and_add(&(gInitCounter[cfg->chipId]), 1);
401 44 : if (counter > 0) {
402 0 : hccp_warn("rs has been init for device %u!", cfg->chipId);
403 0 : return 0;
404 : }
405 44 : ret = RsDev2rscb(cfg->chipId, &rscb, true);
406 44 : CHK_PRT_RETURN(ret == 0, hccp_err("rs_cb exist for device %u! do NOT init it again!", cfg->chipId), -EEXIST);
407 :
408 44 : rscb = calloc(1, sizeof(struct rs_cb));
409 44 : CHK_PRT_RETURN(rscb == NULL, hccp_err("calloc rscb failed"), -ENOMEM);
410 :
411 43 : ret = RsPthreadMutexInit(rscb, cfg);
412 43 : if (ret != 0) {
413 1 : hccp_err("Init mutex failed, ret[%d]", ret);
414 1 : goto pthread_mutex_err;
415 : }
416 :
417 42 : ret = RsInitRscbCfg(rscb);
418 42 : if (ret != 0) {
419 3 : hccp_err("rs init rscb configure failed,ret:%d", ret);
420 3 : pthread_mutex_destroy(&rscb->mutex);
421 3 : pthread_mutex_destroy(&rscb->connCb.connMutex);
422 3 : goto pthread_mutex_err;
423 : }
424 :
425 39 : rscb->fdMap = calloc(1, sizeof(void*) * RS_MAX_FD_NUM);
426 39 : if (rscb->fdMap == NULL) {
427 0 : hccp_err("no memory for fd_map");
428 0 : ret = -ENOMEM;
429 0 : goto fd_map_err;
430 : }
431 :
432 39 : ret = getifaddrs(&rscb->ifaddrList);
433 39 : if (ret != 0) {
434 0 : hccp_err("getifaddrs failed, ret:%d", ret);
435 0 : goto getifaddrs_err;
436 : }
437 :
438 39 : gRsCbList[cfg->chipId] = gRsCb;
439 :
440 39 : hccp_run_info("rs init success, chipId[%u]", cfg->chipId);
441 39 : return 0;
442 :
443 0 : getifaddrs_err:
444 0 : free(rscb->fdMap);
445 0 : rscb->fdMap = NULL;
446 :
447 0 : fd_map_err:
448 0 : pthread_mutex_destroy(&rscb->mutex);
449 0 : pthread_mutex_destroy(&rscb->connCb.connMutex);
450 0 : RsDeinitRscbCfg(rscb);
451 :
452 4 : pthread_mutex_err:
453 4 : free(rscb);
454 4 : rscb = NULL;
455 4 : return ret;
456 : }
457 :
458 2 : RS_ATTRI_VISI_DEF int RsGetTlsEnable(unsigned int phyId, bool *tlsEnable)
459 : {
460 2 : struct rs_cb *rsCb = NULL;
461 : int ret;
462 :
463 2 : CHK_PRT_RETURN(tlsEnable == NULL, hccp_err("param err, tlsEnable is NULL"), -EINVAL);
464 1 : ret = RsGetRsCb(phyId, &rsCb);
465 1 : CHK_PRT_RETURN(ret != 0, hccp_err("RsGetRsCb failed, phyId(%u) invalid, ret(%d)", phyId, ret), ret);
466 :
467 0 : *tlsEnable = (rsCb->sslEnable == 0) ? false : true;
468 0 : return 0;
469 : }
470 :
471 1 : RS_ATTRI_VISI_DEF int RsGetHccnCfg(unsigned int phyId, enum HccnCfgKey key, char *value,
472 : unsigned int *valueLen)
473 : {
474 : #define HCCN_CFGFILE_PATH "/etc/hccl.cfg"
475 1 : const char *keyName[HCCN_CFG_KEY_INVALID] = {
476 : "udp_port_mode", "multi_qp_count", "multi_qp_udp_ports", "resv_mem", "qos_dscp"
477 : };
478 1 : unsigned int cfg_key = (unsigned int)key;
479 1 : unsigned int valLen = 0;
480 : unsigned int bufLen;
481 1 : int ret = 0;
482 :
483 1 : CHK_PRT_RETURN(value == NULL || valueLen == NULL, hccp_err("param err, value or valueLen is NULL"), -EINVAL);
484 1 : CHK_PRT_RETURN(cfg_key >= HCCN_CFG_KEY_INVALID,
485 : hccp_err("param err, key[%u] should < [%d]", cfg_key, HCCN_CFG_KEY_INVALID), -EINVAL);
486 :
487 1 : bufLen = *valueLen;
488 1 : CHK_PRT_RETURN(bufLen < HCCN_CFG_MSG_DATA_LEN,
489 : hccp_err("param err, bufLen[%u] should >= [%u]", bufLen, HCCN_CFG_MSG_DATA_LEN), -EINVAL);
490 :
491 1 : *valueLen = 0;
492 1 : ret = FileReadCfg(HCCN_CFGFILE_PATH, (int)phyId, keyName[cfg_key], value, bufLen);
493 1 : CHK_PRT_RETURN(ret == FILE_OPT_INNER_PARAM_ERR || ret == FILE_OPT_SYS_READ_FILE_ERR,
494 : hccp_run_warn("get hccn cfg file unsuccessful, ret(%d)", ret), 0);
495 1 : CHK_PRT_RETURN(ret == FILE_OPT_NO_MEM_ERR,
496 : hccp_err("value_len > buf_len[%d], ret(%d)", bufLen, ret), -ENOMEM);
497 1 : CHK_PRT_RETURN(ret != 0, hccp_run_warn("get hccn cfg [%s] unsuccessful, ret(%d)", keyName[cfg_key], ret), 0);
498 :
499 1 : valLen = (unsigned int)strlen(value);
500 1 : *valueLen = (valLen == 0) ? valLen : (valLen + 1);
501 1 : return 0;
502 : }
503 :
504 1 : RS_ATTRI_VISI_DEF int RsBindHostpid(unsigned int chipId, pid_t pid)
505 : {
506 : #define QUERY_BIND_HOST_PID_TIME_US 10000
507 : #define QUERY_BIND_HOST_PID_CNT 12000
508 1 : struct rs_cb *rsCb = NULL;
509 : unsigned int hostPid;
510 : pid_t devPid;
511 : int ret;
512 : int i;
513 :
514 : // get current hccp pid on device
515 1 : devPid = getpid();
516 1 : CHK_PRT_RETURN(devPid < 0, hccp_err("getpid failed, ret:%d errno:%d", devPid, errno), -EINVAL);
517 :
518 : // query corresponding host_pid every 10ms, total timeout cost 120s
519 1 : for (i = 0; i < QUERY_BIND_HOST_PID_CNT; i++) {
520 1 : ret = DlDrvQueryProcessHostPid(devPid, NULL, NULL, &hostPid, NULL);
521 1 : if (ret == DRV_ERROR_NONE) {
522 1 : break;
523 : }
524 :
525 0 : usleep(QUERY_BIND_HOST_PID_TIME_US);
526 : }
527 :
528 1 : if (i >= QUERY_BIND_HOST_PID_CNT) {
529 0 : hccp_err("query process host_pid failed, i:%d >= %d ret:%d", i, QUERY_BIND_HOST_PID_CNT, ret);
530 0 : return -EINVAL;
531 : }
532 :
533 1 : if (pid != (pid_t)hostPid) {
534 0 : hccp_err("check process failed, pid from tsd: %d, process hostPid: %u", pid, hostPid);
535 0 : return -EINVAL;
536 : }
537 :
538 1 : hccp_dbg("dl_drv_query_process_host_pid success, total retry cnt:%d", i);
539 :
540 : // save host_pid for later setup sharemem
541 1 : ret = RsDev2rscb(chipId, &rsCb, false);
542 1 : CHK_PRT_RETURN(ret, hccp_err("get rs_cb failed, ret:%d, chipId:%u", ret, chipId), -ENODEV);
543 0 : rsCb->hostPid = pid;
544 :
545 0 : return 0;
546 : }
547 :
548 : #ifdef CUSTOM_INTERFACE
549 1 : STATIC int RsSetRscbGrpId(struct rs_cb *rsCb, unsigned int devId)
550 : {
551 1 : GrpQueryGroupIdInfo grpQueryOut = {0};
552 1 : unsigned int chipId = rsCb->chipId;
553 1 : GrpQueryGroupId grpQueryIn = {0};
554 1 : struct MemInfo memInfo = {0};
555 : unsigned int outLen;
556 : unsigned int grpId;
557 : int ret;
558 :
559 : // query grp_name
560 1 : ret = DlHalMemGetInfoEx(devId, MEM_INFO_TYPE_SVM_GRP_INFO, &memInfo);
561 1 : CHK_PRT_RETURN(ret, hccp_err("dl_hal_mem_get_info_ex failed, ret:%d chipId:%u devId:%u", ret, chipId,
562 : devId), ret);
563 :
564 1 : hccp_dbg("query group name success, chipId:%u devId:%u grp_name:%s", chipId, devId, memInfo.grp_info.name);
565 :
566 : // query grp_id
567 1 : ret = memcpy_s(&grpQueryIn.grpName, BUFF_GRP_NAME_LEN, &memInfo.grp_info.name, SVM_GRP_NAME_LEN);
568 1 : CHK_PRT_RETURN(ret, hccp_err("memcpy_s failed, ret:%d chipId:%u devId:%u", ret, chipId, devId), ret);
569 1 : outLen = (unsigned int)sizeof(grpQueryOut);
570 1 : ret = DlHalGrpQuery(GRP_QUERY_GROUP_ID, &grpQueryIn, sizeof(grpQueryIn), &grpQueryOut,
571 : &outLen);
572 1 : CHK_PRT_RETURN(ret, hccp_err("dl_hal_grp_query failed, ret:%d chipId:%u devId:%u", ret, chipId, devId), ret);
573 1 : grpId = (unsigned int)grpQueryOut.groupId;
574 :
575 : // set grp_id
576 1 : rsCb->grpId = grpId;
577 :
578 1 : hccp_dbg("query group id success, chipId:%u devId:%u grpId:%u grp_name:%s", chipId, devId, grpId,
579 : grpQueryIn.grpName);
580 1 : return 0;
581 : }
582 :
583 3 : STATIC int RsBindSibling(struct rs_cb *rsCb, int hostPid, unsigned int vfId, unsigned int devId)
584 : {
585 : #define QUERY_BIND_SIBLING_TIME_US 10000
586 : #define QUERY_BIND_SIBLING_CNT 12000
587 3 : struct halQueryDevpidInfo pidInfo = {0};
588 : pid_t aicpuPid;
589 : int ret;
590 : int i;
591 :
592 : // query aicpu pid
593 3 : pidInfo.hostpid = hostPid;
594 3 : pidInfo.devid = devId;
595 3 : pidInfo.proc_type = DEVDRV_PROCESS_CP1;
596 3 : ret = DlHalQueryDevPid(pidInfo, &aicpuPid);
597 3 : CHK_PRT_RETURN(ret != 0, hccp_err("dl_hal_query_dev_pid failed, ret:%d devId:%u", ret, devId), ret);
598 :
599 : // try to bind sibling every 10ms, total timeout cost 120s
600 1 : for (i = 0; i < QUERY_BIND_SIBLING_CNT; i++) {
601 1 : ret = DlHalMemBindSibling(hostPid, aicpuPid, vfId, devId, SVM_MEM_BIND_SP_GRP);
602 1 : if (ret == DRV_ERROR_NONE) {
603 1 : break;
604 : }
605 :
606 0 : usleep(QUERY_BIND_SIBLING_TIME_US);
607 : }
608 :
609 1 : if (i >= QUERY_BIND_SIBLING_CNT) {
610 0 : hccp_err("bind sibling to setup sharemem failed, i:%d >= %d ret:%d", i, QUERY_BIND_SIBLING_CNT, ret);
611 0 : return -EINVAL;
612 : }
613 :
614 1 : rsCb->aicpuPid = aicpuPid;
615 1 : hccp_dbg("dl_hal_mem_bind_sibling success, total retry cnt:%d", i);
616 :
617 1 : return 0;
618 : }
619 :
620 35 : int RsSetupSharemem(struct rs_cb *rsCb, bool backupFlag, unsigned int backupPhyid)
621 : {
622 35 : unsigned int chipId = rsCb->chipId;
623 35 : pid_t pid = rsCb->hostPid;
624 35 : int64_t deviceInfo = 0;
625 : unsigned int logicId;
626 : int ret;
627 :
628 : // setup sharemem or skipped already, no need to setup again
629 35 : if (rsCb->grpSetupFlag) {
630 4 : hccp_dbg("grp_setup_flag:%d grp_id:%u chipId:%u", rsCb->grpSetupFlag, rsCb->grpId, chipId);
631 4 : return 0;
632 : }
633 :
634 31 : ret = DlDrvDeviceGetIndexByPhyId(chipId, &logicId);
635 31 : CHK_PRT_RETURN(ret, hccp_err("dl_drv_device_get_index_by_phy_id failed, ret:%d chipId:%u", ret, chipId), ret);
636 31 : ret = DlHalGetDeviceInfo(logicId, MODULE_TYPE_SYSTEM, INFO_TYPE_VERSION, &deviceInfo);
637 31 : CHK_PRT_RETURN(ret != 0, hccp_err("dl_hal_get_device_info failed, ret:%d logicId:%u chipId:%u",
638 : ret, logicId, chipId), ret);
639 : // not 910b/910_93 and not protocol udma, skip to setup share mem
640 31 : if (DlHalPlatGetChip((uint64_t)deviceInfo) != CHIP_TYPE_910B_910_93 && rsCb->protocol != PROTOCOL_UDMA) {
641 28 : hccp_info("logicId:%u chipId:%u protocol:%d skip to setup share mem", logicId, chipId, rsCb->protocol);
642 28 : rsCb->grpSetupFlag = true;
643 28 : return 0;
644 : }
645 :
646 : // use backup info to setup share mem
647 3 : if (backupFlag) {
648 1 : ret = DlDrvGetLocalDevIdByHostDevId(backupPhyid, &logicId);
649 1 : CHK_PRT_RETURN(ret != 0, hccp_err("DlDrvGetLocalDevIdByHostDevId failed, phyId(%u), ret(%d)",
650 : backupPhyid, ret), ret);
651 1 : hccp_dbg("setup sharemem with backup, phyId:%u logicId:%u", backupPhyid, logicId);
652 : }
653 :
654 : // bind sibling, default vfid is 0; query & save grp_id on rs_cb
655 3 : ret = RsBindSibling(rsCb, pid, 0, logicId);
656 3 : CHK_PRT_RETURN(ret != 0, hccp_err("rs_bind_sibling failed, ret:%d logicId:%u chipId:%u",
657 : ret, logicId, chipId), ret);
658 :
659 : // query & save grp_id on rs_cb
660 1 : ret = RsSetRscbGrpId(rsCb, logicId);
661 1 : CHK_PRT_RETURN(ret, hccp_err("rs_set_rscb_grp_id failed, ret:%d logicId:%u chipId:%u", ret, logicId, chipId),
662 : ret);
663 :
664 1 : rsCb->grpSetupFlag = true;
665 1 : return 0;
666 : }
667 : #endif
668 :
669 33 : STATIC int RsCompareIpGid(struct rdev rdevInfo, union ibv_gid *gid)
670 : {
671 33 : return RsDrvCompareIpGid(rdevInfo.family, rdevInfo.localIp, gid);
672 : }
673 :
674 33 : int RsQueryGid(struct rdev rdevInfo, struct ibv_context *ibCtxTmp, uint8_t ibPort, int *gidIdx)
675 : {
676 : static const char *portStates[] = {"Nop", "Down", "Init", "Armed", "", "Active Defer"};
677 33 : struct ibv_port_attr attr = {0};
678 : enum ibv_gid_type_sysfs type;
679 : union ibv_gid gidTmp;
680 : int ret;
681 : int i;
682 :
683 33 : CHK_PRT_RETURN(gidIdx == NULL, hccp_err("gid_idx is NULL"), -EINVAL);
684 :
685 33 : ret = RsIbvQueryPort(ibCtxTmp, ibPort, &attr);
686 33 : CHK_PRT_RETURN(ret, hccp_err("ibv_query_port failed, ret %d ibPort %u", ret, ibPort), -EOPENSRC);
687 :
688 70 : for (i = 0; i < attr.gid_tbl_len; i++) {
689 68 : ret = RsIbvQueryGidType(ibCtxTmp, ibPort, (unsigned int)i, &type);
690 68 : CHK_PRT_RETURN(ret, hccp_err("query gid type failed i %d, ret %d", i, ret), -EOPENSRC);
691 68 : if (type != IBV_GID_TYPE_SYSFS_ROCE_V2) {
692 35 : continue;
693 : }
694 33 : ret = RsIbvQueryGid(ibCtxTmp, ibPort, i, &gidTmp);
695 33 : CHK_PRT_RETURN(ret, hccp_err("query gid failed i %d, ret %d", i, ret), -EOPENSRC);
696 33 : ret = RsCompareIpGid(rdevInfo, &gidTmp);
697 33 : if (ret == 0) {
698 31 : CHK_PRT_RETURN(attr.state != IBV_PORT_ACTIVE, hccp_err("port number %u state is %s",
699 : ibPort, portStates[attr.state]), -ENOLINK);
700 29 : *gidIdx = i;
701 29 : return 0;
702 : }
703 : }
704 :
705 2 : if (i == attr.gid_tbl_len) {
706 2 : return -EEXIST;
707 : }
708 0 : return 0;
709 : }
710 :
711 25 : STATIC int RsGetDevRdevIndex(struct RsRdevCb *rdevCb, unsigned int *rdevIndex, int index)
712 : {
713 : #ifdef CUSTOM_INTERFACE
714 25 : struct roce_dev_data rdevData = {0}; //lint !e565
715 : int retVal;
716 :
717 25 : if (RsIsCustomInterfaceSupported()) {
718 25 : RS_PTHREAD_MUTEX_LOCK(&rdevCb->rsCb->mutex);
719 : /*lint -e132*/
720 25 : rdevCb->devName = RsIbvGetDeviceName(rdevCb->devList[index]); //lint !e101
721 25 : retVal = RsRoceGetRoceDevData(rdevCb->devName, &rdevData); //lint !e101
722 : /*lint +e132*/
723 25 : if (retVal) {
724 0 : hccp_err("rs_roce_get_roce_dev_data failed, retVal:%d, devName:%s", retVal, rdevCb->devName);
725 0 : RS_PTHREAD_MUTEX_ULOCK(&rdevCb->rsCb->mutex);
726 0 : return retVal;
727 : }
728 25 : *rdevIndex = rdevData.rdev_index; // rdev_index is same to port_id
729 25 : rdevCb->rdevIndex = *rdevIndex;
730 25 : RS_PTHREAD_MUTEX_ULOCK(&rdevCb->rsCb->mutex);
731 : }
732 : #endif
733 25 : return 0;
734 : }
735 :
736 4 : STATIC int RsGetHostRdevIndex(struct rdev rdevInfo, struct RsRdevCb *rdevCb, unsigned int *rdevIndex, int index)
737 : {
738 4 : struct RsRdevCb *rdevCbTmp2 = NULL;
739 4 : struct RsRdevCb *rdevCbTmp = NULL;
740 4 : unsigned int tmpRdevIndex = 0;
741 :
742 4 : RS_PTHREAD_MUTEX_LOCK(&rdevCb->rsCb->mutex);
743 4 : rdevCb->devName = RsIbvGetDeviceName(rdevCb->devList[index]);
744 4 : if (rdevCb->devName == NULL) {
745 0 : hccp_err("rs_ibv_get_device_name failed, errno:%d", errno);
746 0 : RS_PTHREAD_MUTEX_ULOCK(&rdevCb->rsCb->mutex);
747 0 : return -EINVAL;
748 : }
749 :
750 : struct RsIpAddrInfo localIp;
751 4 : int ret = RsConvertIpAddr(rdevInfo.family, &rdevInfo.localIp, &localIp);
752 4 : if (ret != 0) {
753 1 : hccp_err("convert(ntop) ip failed, ret:%d", ret);
754 1 : RS_PTHREAD_MUTEX_ULOCK(&rdevCb->rsCb->mutex);
755 1 : return ret;
756 : }
757 :
758 3 : RS_LIST_GET_HEAD_ENTRY(rdevCbTmp, rdevCbTmp2, &rdevCb->rsCb->rdevList, list, struct RsRdevCb);
759 3 : for (; (&rdevCbTmp->list) != &rdevCb->rsCb->rdevList;
760 0 : rdevCbTmp = rdevCbTmp2, rdevCbTmp2 = list_entry(rdevCbTmp2->list.next, struct RsRdevCb, list)) {
761 0 : tmpRdevIndex = rdevCbTmp->rdevIndex;
762 0 : if (!RsCompareIpAddr(&rdevCbTmp->localIp, &localIp)) {
763 0 : *rdevIndex = tmpRdevIndex;
764 0 : rdevCb->rdevIndex = *rdevIndex;
765 0 : rdevCb->localIp = localIp;
766 0 : RS_PTHREAD_MUTEX_ULOCK(&rdevCb->rsCb->mutex);
767 0 : return 0;
768 : }
769 : }
770 :
771 3 : *rdevIndex = tmpRdevIndex + 1;
772 3 : rdevCb->rdevIndex = *rdevIndex;
773 3 : rdevCb->localIp = localIp;
774 3 : RS_PTHREAD_MUTEX_ULOCK(&rdevCb->rsCb->mutex);
775 3 : return 0;
776 : }
777 :
778 30 : STATIC int RsGetIbCtxAndRdevIndex(struct rdev rdevInfo, struct RsRdevCb *rdevCb, unsigned int *rdevIndex)
779 : {
780 30 : struct ibv_context *ibCtxTmp = NULL;
781 30 : int gidIndex = -1;
782 : int ret;
783 : int i;
784 :
785 30 : for (i = 0; (i < rdevCb->devNum) && (rdevCb->devList[i] != NULL); ++i) { //lint !e101
786 30 : ibCtxTmp = RsIbvOpenDevice(rdevCb->devList[i]);
787 30 : CHK_PRT_RETURN(ibCtxTmp == NULL, hccp_err("ibv_open_device failed !"), -ENODEV);
788 30 : ret = RsQueryGid(rdevInfo, ibCtxTmp, rdevCb->ibPort, &gidIndex);
789 30 : if (ret == 0) {
790 28 : if (rdevCb->rsCb->hccpMode == NETWORK_PEER_ONLINE) {
791 3 : ret = RsGetHostRdevIndex(rdevInfo, rdevCb, rdevIndex, i);
792 : } else {
793 25 : ret = RsGetDevRdevIndex(rdevCb, rdevIndex, i);
794 : }
795 28 : if (ret != 0) {
796 0 : hccp_err("get index failed, ret:%d", ret);
797 0 : RsIbvCloseDevice(ibCtxTmp);
798 0 : return ret;
799 : }
800 28 : ret = RsIbvQueryDevice(ibCtxTmp, &rdevCb->deviceAttr);
801 28 : if (ret != 0) {
802 0 : hccp_err("query device failed, ret:%d", ret);
803 0 : RsIbvCloseDevice(ibCtxTmp);
804 0 : return ret;
805 : }
806 28 : rdevCb->ibCtx = ibCtxTmp;
807 28 : return 0;
808 2 : } else if (ret == -EEXIST) {
809 0 : RsIbvCloseDevice(ibCtxTmp);
810 : } else {
811 2 : RsIbvCloseDevice(ibCtxTmp);
812 2 : hccp_err("rs_query_gid failed, ret:%d", ret);
813 2 : return ret;
814 : }
815 : }
816 :
817 0 : CHK_PRT_RETURN(i == rdevCb->devNum, hccp_err("can not find ib_ctx for phyId[%u] local_ip[0x%x] in dev_list!",
818 : rdevInfo.phyId, rdevInfo.localIp.addr.s_addr), -EEXIST);
819 0 : return 0;
820 : }
821 :
822 40 : int RsGetRsCb(unsigned int phyId, struct rs_cb **rsCb)
823 : {
824 : unsigned int chipId;
825 : int ret;
826 :
827 40 : CHK_PRT_RETURN(phyId >= RS_MAX_DEV_NUM, hccp_err("rs set param error ! phyId:%u", phyId), -EINVAL);
828 40 : ret = rsGetLocalDevIDByHostDevID(phyId, &chipId);
829 40 : CHK_PRT_RETURN(ret, hccp_err("phyId[%u] invalid, ret %d", phyId, ret), ret);
830 :
831 32 : ret = RsDev2rscb(chipId, rsCb, false);
832 32 : CHK_PRT_RETURN(ret, hccp_err("get rs_cb failed, ret:%d", ret), -ENODEV);
833 32 : return 0;
834 : }
835 :
836 30 : STATIC int RsGetSqDepthAndQpMaxNum(struct RsRdevCb *rdevCb, unsigned int rdevIndex)
837 : {
838 : #ifdef CUSTOM_INTERFACE
839 30 : unsigned int tempDepth = 0;
840 30 : unsigned int qpMaxNum = 0;
841 30 : unsigned int sqDepth = 0;
842 : int ret;
843 :
844 30 : if (RsIsCustomInterfaceSupported()) {
845 30 : ret = RsRoceGetTsqpDepth(rdevCb->devName, rdevIndex, &tempDepth, &qpMaxNum, &sqDepth);
846 30 : CHK_PRT_RETURN(ret, hccp_err("rs_roce_get_tsqp_depth failed, ret:%d, devName:%s, rdevIndex:%u", ret,
847 : rdevCb->devName, rdevIndex), ret);
848 :
849 30 : rdevCb->txDepth = sqDepth;
850 30 : rdevCb->rxDepth = sqDepth;
851 30 : rdevCb->qpMaxNum = qpMaxNum;
852 30 : hccp_run_info("qp_max_num:%u, sqDepth:%u", qpMaxNum, sqDepth);
853 : }
854 : #endif
855 30 : return 0;
856 : }
857 :
858 30 : STATIC int RsSetupPdAndNotify(struct RsRdevCb *rdevCb)
859 : {
860 : int ret;
861 :
862 30 : ret = RsDrvQueryNotifyAndAllocPd(rdevCb);
863 30 : CHK_PRT_RETURN(ret, hccp_err("rs_drv_query_notify_and_alloc_pd failed, ret[%d]", ret), ret);
864 :
865 29 : ret = RsDrvRegNotifyMr(rdevCb);
866 29 : if (ret) {
867 1 : hccp_err("reg notify mr failed, ret[%d]", ret);
868 1 : goto dealloc_pd;
869 : }
870 :
871 28 : return 0;
872 1 : dealloc_pd:
873 1 : RsIbvDeallocPd(rdevCb->ibPd);
874 1 : return ret;
875 : }
876 :
877 36 : STATIC int RsRdevCbInfoInit(struct rdev rdevInfo, struct rs_cb *rsCb, struct RsRdevCb *rdevCb)
878 : {
879 : int ret;
880 :
881 36 : rdevCb->ibPort = RS_PORT_DEF;
882 36 : rdevCb->rsCb = rsCb;
883 36 : rdevCb->notifyVaBase = rsCb->notifyVaBase;
884 36 : rdevCb->notifySize = rsCb->notifySize;
885 :
886 36 : rdevCb->localIp.family = (uint32_t)rdevInfo.family;
887 36 : rdevCb->localIp.binAddr = rdevInfo.localIp;
888 36 : ret = RsInetNtop(rdevInfo.family, &(rdevInfo.localIp), rdevCb->localIp.readAddr, RS_MAX_IP_LEN);
889 36 : CHK_PRT_RETURN(ret, hccp_err("rs_inet_ntop failed, ret %d", ret), -EINVAL);
890 :
891 36 : return 0;
892 : }
893 :
894 36 : STATIC int RsRdevCbInit(struct rdev rdevInfo, struct RsRdevCb *rdevCb, struct rs_cb *rsCb,
895 : unsigned int *rdevIndex)
896 : {
897 : int ret;
898 :
899 36 : ret = RsRdevCbInfoInit(rdevInfo, rsCb, rdevCb);
900 36 : CHK_PRT_RETURN(ret, hccp_err("rs_rdev_cb_info_init failed, ret %d", ret), ret);
901 :
902 36 : ret = pthread_mutex_init(&rdevCb->rdevMutex, NULL);
903 36 : CHK_PRT_RETURN(ret, hccp_err("rdev_cb mutex_init failed ret %d!, normal ret 0", ret), -ESYSFUNC);
904 :
905 35 : ret = pthread_mutex_init(&rdevCb->cqeErrCntMutex, NULL);
906 35 : if (ret) {
907 0 : hccp_err("rdev_cb cqe_err_cnt_mutex init failed ret %d!, normal ret 0", ret);
908 0 : goto destroy_rdev_mutex;
909 : }
910 :
911 35 : RS_PTHREAD_MUTEX_LOCK(&rdevCb->rdevMutex);
912 35 : RS_INIT_LIST_HEAD(&rdevCb->qpList);
913 35 : RS_INIT_LIST_HEAD(&rdevCb->typicalMrList);
914 35 : RS_PTHREAD_MUTEX_ULOCK(&rdevCb->rdevMutex);
915 :
916 35 : ret = RsGetIbCtxAndRdevIndex(rdevInfo, rdevCb, rdevIndex);
917 35 : if (ret) {
918 3 : hccp_err("rs_get_ib_ctx_and_rdev_index failed, ret:%d", ret);
919 3 : goto destroy_cqe_mutex;
920 : }
921 :
922 32 : ret = RsGetSqDepthAndQpMaxNum(rdevCb, *rdevIndex);
923 32 : if (ret) {
924 1 : hccp_err("rs_get_sq_depth_and_qp_max_num failed, ret[%d], rdevIndex[%u]", ret, *rdevIndex);
925 1 : goto close_dev;
926 : }
927 :
928 : #ifdef CUSTOM_INTERFACE
929 31 : if (RsIsCustomInterfaceSupported()) {
930 31 : ret = RsRoceMmapAiDbReg(rdevCb->ibCtx, (unsigned int)rdevCb->rsCb->aicpuPid);
931 31 : if (ret) {
932 0 : hccp_err("rs_roce_mmap_ai_db_reg failed, ret[%d], rdevIndex[%u]", ret, *rdevIndex);
933 0 : goto close_dev;
934 : }
935 : }
936 : #endif
937 :
938 31 : ret = RsInitNdaCb(rdevCb);
939 31 : if (ret != 0) {
940 0 : hccp_err("RsInitNdaCb failed, ret[%d], rdevIndex[%u]", ret, *rdevIndex);
941 0 : goto unmmap_ai_db;
942 : }
943 :
944 31 : ret = RsSetupPdAndNotify(rdevCb);
945 31 : if (ret != 0) {
946 3 : hccp_err("RsSetupPdAndNotify failed, ret[%d], rdevIndex[%u]", ret, *rdevIndex);
947 3 : goto free_nda_cb;
948 : }
949 :
950 28 : return 0;
951 :
952 3 : free_nda_cb:
953 3 : RsDeinitNdaCb(rdevCb);
954 3 : unmmap_ai_db:
955 : #ifdef CUSTOM_INTERFACE
956 3 : if (RsIsCustomInterfaceSupported()) {
957 3 : (void)RsRoceUnmmapAiDbReg(rdevCb->ibCtx);
958 : }
959 : #endif
960 0 : close_dev:
961 4 : RsIbvCloseDevice(rdevCb->ibCtx);
962 7 : destroy_cqe_mutex:
963 7 : pthread_mutex_destroy(&rdevCb->cqeErrCntMutex);
964 7 : destroy_rdev_mutex:
965 7 : pthread_mutex_destroy(&rdevCb->rdevMutex);
966 7 : return ret;
967 : }
968 :
969 4 : int RsRetryTimeoutExceptionCheck(struct SensorNode *sensorNode)
970 : {
971 4 : int ret = 0;
972 :
973 : /* sensor may not support, handle is 0 */
974 4 : if (sensorNode->sensorHandle == 0) {
975 2 : return 0;
976 : }
977 :
978 : /*
979 : * The notification alarm framework does not filter alarms. In this example, only one notification
980 : * alarm is reported by a single process, which does not need to be accurate. Therefore, no lock is used.
981 : */
982 2 : if (sensorNode->sensorUpdateCnt == 0) {
983 2 : ret = DlHalSensorNodeUpdateState(sensorNode->logicDevid, sensorNode->sensorHandle,
984 : RDMA_CQE_ERR_RETRY_TIMEOUT_EVENT_TYPE, GENERAL_EVENT_TYPE_ONE_TIME);
985 2 : if (ret == 0) {
986 1 : sensorNode->sensorUpdateCnt++;
987 : }
988 : }
989 :
990 2 : return ret;
991 : }
992 :
993 38 : STATIC int RsRdevInitWithBackupInfo(struct rdev rdevInfo, struct RsBackupInfo backupInfo,
994 : unsigned int notifyType, unsigned int *rdevIndex)
995 : {
996 38 : unsigned int phyId = rdevInfo.phyId;
997 38 : struct RsRdevCb *rdevCb = NULL;
998 38 : struct rs_cb *rsCb = NULL;
999 : int ret;
1000 :
1001 38 : RS_CHECK_POINTER_NULL_RETURN_INT(rdevIndex);
1002 :
1003 38 : ret = RsApiInit();
1004 38 : CHK_PRT_RETURN(ret, hccp_err("RsApiInit failed! ret[%d]", ret), ret);
1005 :
1006 38 : ret = RsGetRsCb(phyId, &rsCb);
1007 38 : if (ret) {
1008 8 : hccp_err("RsGetRsCb failed, phyId[%u] invalid, ret %d", phyId, ret);
1009 8 : goto get_rs_cb_fail;
1010 : }
1011 :
1012 30 : rdevCb = calloc(1, sizeof(struct RsRdevCb));
1013 30 : if (rdevCb == NULL) {
1014 0 : hccp_err("calloc for rdev_cb failed");
1015 0 : ret = -ENOMEM;
1016 0 : goto get_rs_cb_fail;
1017 : }
1018 :
1019 30 : rdevCb->backupInfo.backupFlag = backupInfo.backupFlag;
1020 30 : (void)memcpy_s(&rdevCb->backupInfo.rdevInfo, sizeof(struct rdev),
1021 : &backupInfo.rdevInfo, sizeof(struct rdev));
1022 : #ifdef CUSTOM_INTERFACE
1023 30 : if (RsIsCustomInterfaceSupported()) {
1024 : // setup sharemem for aicpu rdma unfold
1025 30 : ret = RsSetupSharemem(rsCb, rdevCb->backupInfo.backupFlag, rdevCb->backupInfo.rdevInfo.phyId);
1026 30 : if (ret != 0) {
1027 0 : hccp_err("[init][rs_rdev]RsSetupSharemem failed, phyId(%u), ret(%d)", phyId, ret);
1028 0 : goto free_rs_cb;
1029 : }
1030 : }
1031 : #endif
1032 :
1033 30 : rdevCb->notifyType = notifyType;
1034 30 : rdevCb->devList = RsIbvGetDeviceList(&(rdevCb->devNum));
1035 30 : if (rdevCb->devList == NULL || rdevCb->devNum == 0) {
1036 0 : hccp_err("dev_list is NULL, or devNum[%d] is 0", rdevCb->devNum);
1037 0 : ret = -EINVAL;
1038 0 : goto free_rs_cb;
1039 : }
1040 :
1041 30 : ret = RsSensorNodeRegister(phyId, rsCb);
1042 30 : if (ret != 0) {
1043 0 : hccp_err("[init][rs_rdev]rs_sensor_node_register failed, phyId(%u), ret(%d)", phyId, ret);
1044 0 : goto free_dev_list;
1045 : }
1046 :
1047 30 : hccp_info("ibv_get_device_list phyId[%d] dev_num[%d]", phyId, rdevCb->devNum);
1048 :
1049 30 : ret = RsRdevCbInit(rdevInfo, rdevCb, rsCb, rdevIndex);
1050 30 : if (ret != 0) {
1051 2 : RsSensorNodeUnregister(rdevCb->rsCb);
1052 2 : hccp_err("rs_rdev_cb_init failed ret %d!, normal ret 0", ret);
1053 2 : goto free_dev_list;
1054 : }
1055 :
1056 28 : RS_PTHREAD_MUTEX_LOCK(&rsCb->mutex);
1057 28 : RsListAddTail(&rdevCb->list, &rsCb->rdevList);
1058 28 : RS_PTHREAD_MUTEX_ULOCK(&rsCb->mutex);
1059 :
1060 28 : hccp_run_info("rdev init success, phyId:%u, localIp:0x%x, rdevIndex:%u", phyId, rdevInfo.localIp.addr.s_addr,
1061 : *rdevIndex);
1062 28 : return 0;
1063 :
1064 2 : free_dev_list:
1065 2 : RsIbvFreeDeviceList(rdevCb->devList);
1066 2 : free_rs_cb:
1067 2 : free(rdevCb);
1068 2 : rdevCb = NULL;
1069 10 : get_rs_cb_fail:
1070 10 : RsApiDeinit();
1071 10 : return ret;
1072 : }
1073 :
1074 1 : RS_ATTRI_VISI_DEF int RsRdevInitWithBackup(struct rdev rdevInfo, struct rdev backupRdevInfo,
1075 : unsigned int notifyType, unsigned int *rdevIndex)
1076 : {
1077 1 : struct RsBackupInfo backupInfo = { 0 };
1078 :
1079 1 : backupInfo.backupFlag = true;
1080 1 : (void)memcpy_s(&backupInfo.rdevInfo, sizeof(struct rdev), &backupRdevInfo, sizeof(struct rdev));
1081 :
1082 1 : return RsRdevInitWithBackupInfo(rdevInfo, backupInfo, notifyType, rdevIndex);
1083 : }
1084 :
1085 37 : RS_ATTRI_VISI_DEF int RsRdevInit(struct rdev rdevInfo, unsigned int notifyType, unsigned int *rdevIndex)
1086 : {
1087 37 : struct RsBackupInfo backupInfo = { 0 };
1088 :
1089 37 : return RsRdevInitWithBackupInfo(rdevInfo, backupInfo, notifyType, rdevIndex);
1090 : }
1091 :
1092 28 : STATIC void RsDestroyQpList(unsigned int phyId, unsigned int rdevIndex,
1093 : struct RsRdevCb *rdevCb, struct RsQpCb *qpCb, struct RsQpCb *qpCb2)
1094 : {
1095 : int ret;
1096 :
1097 28 : if (!RsListEmpty(&rdevCb->qpList)) {
1098 0 : hccp_warn("qp list do not empty!");
1099 0 : RS_LIST_GET_HEAD_ENTRY(qpCb, qpCb2, &rdevCb->qpList, list, struct RsQpCb);
1100 0 : for (; (&qpCb->list) != &rdevCb->qpList;
1101 0 : qpCb = qpCb2, qpCb2 = list_entry(qpCb2->list.next, struct RsQpCb, list)) {
1102 0 : hccp_info("qpn[%u] will be destroyed", qpCb->ibQp->qp_num);
1103 0 : if (qpCb->ibQpEx != NULL) {
1104 0 : ret = RsNdaQpDestroy(phyId, rdevIndex, qpCb->ibQp->qp_num);
1105 : } else {
1106 0 : ret = RsQpDestroy(phyId, rdevIndex, qpCb->ibQp->qp_num);
1107 : }
1108 0 : if (ret != 0) {
1109 0 : hccp_err("rs_qp_destroy failed, ret:%d", ret);
1110 : }
1111 : }
1112 : }
1113 :
1114 28 : return;
1115 : }
1116 :
1117 28 : STATIC void RsFreeTypicalMrCb(struct RsRdevCb *devCb)
1118 : {
1119 28 : struct RsListHead *typicalMrList = &devCb->typicalMrList;
1120 28 : struct RsMrCb *mrCurr = NULL;
1121 28 : struct RsMrCb *mrNext = NULL;
1122 :
1123 28 : RS_PTHREAD_MUTEX_LOCK(&devCb->rdevMutex);
1124 28 : RS_LIST_GET_HEAD_ENTRY(mrCurr, mrNext, typicalMrList, list, struct RsMrCb);
1125 28 : for (; (&mrCurr->list) != typicalMrList;
1126 0 : mrCurr = mrNext, mrNext = list_entry(mrNext->list.next, struct RsMrCb, list)) {
1127 0 : (void)RsDrvMrDereg(mrCurr->ibMr);
1128 0 : RsListDel(&mrCurr->list);
1129 0 : free(mrCurr);
1130 0 : mrCurr = NULL;
1131 : }
1132 28 : RS_PTHREAD_MUTEX_ULOCK(&devCb->rdevMutex);
1133 :
1134 28 : hccp_info("rs_free_typical_mr_cb is succ");
1135 28 : }
1136 :
1137 30 : RS_ATTRI_VISI_DEF int RsRdevDeinit(unsigned int phyId, unsigned int notifyType, unsigned int rdevIndex)
1138 : {
1139 30 : struct RsRdevCb *rdevCb = NULL;
1140 30 : struct RsQpCb *qpCb2 = NULL;
1141 30 : struct RsQpCb *qpCb = NULL;
1142 : unsigned int chipId;
1143 : int ret;
1144 :
1145 30 : hccp_info("rdev deinit start, phyId:%u, rdevIndex:%u", phyId, rdevIndex);
1146 30 : CHK_PRT_RETURN(phyId >= RS_MAX_DEV_NUM, hccp_err("rs set param error ! phyId:%u", phyId), -EINVAL);
1147 30 : ret = rsGetLocalDevIDByHostDevID(phyId, &chipId);
1148 30 : CHK_PRT_RETURN(ret, hccp_err("phyId[%u] invalid, ret %d", phyId, ret), ret);
1149 :
1150 28 : ret = RsRdev2rdevCb(chipId, rdevIndex, &rdevCb);
1151 28 : CHK_PRT_RETURN(ret || rdevCb == NULL, hccp_err("rs_rdev2rdev_cb for chipId[%u] failed, ret %d",
1152 : chipId, ret), ret);
1153 :
1154 28 : if (rdevCb->notifyType != NO_USE && rdevCb->notifyMr != NULL) {
1155 26 : ret = RsDrvMrDereg(rdevCb->notifyMr);
1156 26 : if (ret) {
1157 0 : hccp_err("rs_drv_mr_dereg failed, ret %d", ret);
1158 : }
1159 : }
1160 :
1161 28 : hccp_info("poll_cqe_num[%d]", rdevCb->pollCqeNum);
1162 :
1163 28 : RsDestroyQpList(phyId, rdevIndex, rdevCb, qpCb, qpCb2);
1164 :
1165 28 : RsFreeTypicalMrCb(rdevCb);
1166 :
1167 : #ifdef CUSTOM_INTERFACE
1168 28 : if (RsIsCustomInterfaceSupported()) {
1169 28 : (void)RsRoceUnmmapAiDbReg(rdevCb->ibCtx);
1170 : }
1171 : #endif
1172 :
1173 28 : RsIbvDeallocPd(rdevCb->ibPd);
1174 :
1175 28 : RsDeinitNdaCb(rdevCb);
1176 :
1177 28 : RsIbvCloseDevice(rdevCb->ibCtx);
1178 :
1179 : #ifdef CUSTOM_INTERFACE
1180 28 : if (RsIsCustomInterfaceSupported()) {
1181 28 : RsCloseBackupIbCtx(rdevCb);
1182 : }
1183 : #endif
1184 :
1185 28 : pthread_mutex_destroy(&rdevCb->cqeErrCntMutex);
1186 :
1187 28 : pthread_mutex_destroy(&rdevCb->rdevMutex);
1188 :
1189 28 : RsIbvFreeDeviceList(rdevCb->devList);
1190 :
1191 28 : RS_PTHREAD_MUTEX_LOCK(&gRsCb->mutex);
1192 28 : RsListDel(&rdevCb->list);
1193 28 : RS_PTHREAD_MUTEX_ULOCK(&gRsCb->mutex);
1194 28 : RsSensorNodeUnregister(rdevCb->rsCb);
1195 28 : RsApiDeinit();
1196 28 : hccp_run_info("rdev deinit success, phyId:%u, rdevIndex:%u", phyId, rdevIndex);
1197 28 : free(rdevCb);
1198 28 : rdevCb = NULL;
1199 28 : return 0;
1200 : }
1201 :
1202 0 : STATIC void RsHeterogTcpFreeFdNode(struct RsHeterogTcpFdInfo *fdNode)
1203 : {
1204 : int fd;
1205 :
1206 0 : RS_PTHREAD_MUTEX_LOCK(&gRsCb->mutex);
1207 0 : fd = fdNode->fd;
1208 0 : RsListDel(&fdNode->list);
1209 0 : free(fdNode);
1210 0 : fdNode = NULL;
1211 0 : gRsCb->fdMap[fd] = NULL;
1212 0 : RS_PTHREAD_MUTEX_ULOCK(&gRsCb->mutex);
1213 0 : }
1214 :
1215 1 : RS_ATTRI_VISI_DEF int RsEpollCtlAdd(const void *fdHandle, enum RaEpollEvent event)
1216 : {
1217 1 : struct RsHeterogTcpFdInfo *fdNode = NULL;
1218 1 : unsigned int tmpEvent = event;
1219 1 : int fd = RS_FD_INVALID;
1220 : int ret;
1221 :
1222 1 : if (event == RA_EPOLLONESHOT) {
1223 0 : tmpEvent = EPOLLIN | EPOLLET | EPOLLONESHOT;
1224 1 : } else if (event == RA_EPOLLIN) {
1225 1 : tmpEvent = EPOLLIN;
1226 : } else {
1227 0 : hccp_err("unknown event[%u]", tmpEvent);
1228 0 : return -EINVAL;
1229 : }
1230 :
1231 1 : if (gRsCb == NULL) {
1232 1 : gRsCb = RsGetCurRsCb();
1233 1 : if (gRsCb == NULL) {
1234 1 : hccp_err("[rs_epoll_ctl_add]rs_get_cur_rs_cb failed rs_cb(NULL)");
1235 1 : return -EINVAL;
1236 : }
1237 : }
1238 0 : tmpEvent = tmpEvent | EPOLLRDHUP;
1239 0 : fdNode = calloc(1, sizeof(struct RsHeterogTcpFdInfo));
1240 0 : CHK_PRT_RETURN(fdNode == NULL, hccp_err("no memory for fd_node"), -ENOMEM);
1241 :
1242 0 : fd = ((const struct SocketPeerInfo *)fdHandle)->fd;
1243 0 : fdNode->fd = fd;
1244 0 : RS_PTHREAD_MUTEX_LOCK(&gRsCb->mutex);
1245 0 : RsListAddTail(&fdNode->list, &gRsCb->heterogTcpFdList);
1246 0 : gRsCb->fdMap[fd] = fdHandle;
1247 0 : RS_PTHREAD_MUTEX_ULOCK(&gRsCb->mutex);
1248 0 : ret = RsEpollCtl(gRsCb->connCb.epollfd, EPOLL_CTL_ADD, fd, tmpEvent);
1249 0 : if (ret != 0) {
1250 0 : hccp_err("[rs_epoll_ctl_add]RsEpollCtl failed ret(%d), fd:%d, event:%u", ret, fd, event);
1251 0 : goto out;
1252 : }
1253 0 : return 0;
1254 0 : out:
1255 0 : RsHeterogTcpFreeFdNode(fdNode);
1256 0 : fdNode = NULL;
1257 0 : return ret;
1258 : }
1259 :
1260 5 : RS_ATTRI_VISI_DEF int RsEpollCtlMod(const void *fdHandle, enum RaEpollEvent event)
1261 : {
1262 5 : unsigned int tmpEvent = event;
1263 5 : int fd = RS_FD_INVALID;
1264 : int ret;
1265 :
1266 5 : if (event == RA_EPOLLONESHOT) {
1267 1 : tmpEvent = EPOLLIN | EPOLLET | EPOLLONESHOT;
1268 4 : } else if (event == RA_EPOLLIN) {
1269 3 : tmpEvent = EPOLLIN;
1270 : } else {
1271 1 : hccp_err("unknown event[%u]", event);
1272 1 : return -EINVAL;
1273 : }
1274 :
1275 4 : tmpEvent = tmpEvent | EPOLLRDHUP;
1276 4 : fd = ((const struct SocketPeerInfo *)fdHandle)->fd;
1277 :
1278 4 : if (gRsCb == NULL) {
1279 1 : gRsCb = RsGetCurRsCb();
1280 1 : if (gRsCb == NULL) {
1281 1 : hccp_err("[rs_epoll_ctl_mod]rs_get_cur_rs_cb failed rs_cb(NULL)");
1282 1 : return -EINVAL;
1283 : }
1284 : }
1285 :
1286 3 : ret = RsEpollCtl(gRsCb->connCb.epollfd, EPOLL_CTL_MOD, fd, tmpEvent);
1287 3 : CHK_PRT_RETURN(ret, hccp_err("[rs_epoll_ctl_mod]RsEpollCtl failed ret(%d), fd:%d, event:%u",
1288 : ret, fd, event), ret);
1289 1 : return 0;
1290 : }
1291 :
1292 3 : RS_ATTRI_VISI_DEF int RsEpollCtlDel(int fd)
1293 : {
1294 : int ret;
1295 3 : struct RsHeterogTcpFdInfo *fdNode = NULL;
1296 3 : struct RsHeterogTcpFdInfo *fdNode1 = NULL;
1297 :
1298 3 : if (gRsCb == NULL) {
1299 1 : gRsCb = RsGetCurRsCb();
1300 1 : if (gRsCb == NULL) {
1301 1 : hccp_err("[rs_epoll_ctl_del]rs_get_cur_rs_cb failed rs_cb(NULL)");
1302 1 : return -EINVAL;
1303 : }
1304 : }
1305 2 : RS_LIST_GET_HEAD_ENTRY(fdNode, fdNode1, &gRsCb->heterogTcpFdList, list, struct RsHeterogTcpFdInfo);
1306 2 : for (; (&fdNode->list) != &gRsCb->heterogTcpFdList;
1307 0 : fdNode = fdNode1, fdNode1 = list_entry(fdNode1->list.next, struct RsHeterogTcpFdInfo, list)) {
1308 0 : if (fdNode->fd == fd) {
1309 : // 删除节点
1310 0 : RsHeterogTcpFreeFdNode(fdNode);
1311 0 : fdNode = NULL;
1312 0 : break; //lint !e108
1313 : }
1314 : }
1315 :
1316 : // 为了兼容epoll不同版本，这里加EPOLLIN参数
1317 2 : ret = RsEpollCtl(gRsCb->connCb.epollfd, EPOLL_CTL_DEL, fd, EPOLLIN);
1318 2 : CHK_PRT_RETURN(ret, hccp_err("[rs_epoll_ctl_del]RsEpollCtl failed ret(%d), fd:%d", ret, fd), ret);
1319 1 : return 0;
1320 : }
1321 :
1322 3 : RS_ATTRI_VISI_DEF void RsSetTcpRecvCallback(const void *callback)
1323 : {
1324 3 : if (gRsCb == NULL) {
1325 1 : hccp_err("param error, gRsCb is NULL");
1326 1 : return;
1327 : }
1328 2 : gRsCb->tcpRecvCallback = (void (*)(const void *))callback;
1329 : }
1330 :
1331 1 : STATIC void RsFreeAcceptOneNode(struct rs_cb *rscb, struct RsAcceptInfo *accept)
1332 : {
1333 : int ret;
1334 :
1335 1 : ret = RsEpollCtl(rscb->connCb.epollfd, EPOLL_CTL_DEL, accept->connFd, EPOLLIN);
1336 1 : if (ret) {
1337 1 : hccp_err("epoll ctl del fd %d failed, ret:%d", accept->connFd, ret);
1338 : }
1339 :
1340 1 : RS_PTHREAD_MUTEX_LOCK(&rscb->connCb.connMutex);
1341 1 : RsListDel(&accept->list);
1342 1 : RS_PTHREAD_MUTEX_ULOCK(&rscb->connCb.connMutex);
1343 :
1344 1 : if (rscb->sslEnable == RS_SSL_ENABLE) {
1345 1 : if (accept->ssl == NULL) {
1346 0 : hccp_warn("[Server] accept->ssl is NULL, it maybe has not establish tls link");
1347 : } else {
1348 1 : ssl_adp_shutdown(accept->ssl);
1349 1 : ssl_adp_free(accept->ssl);
1350 1 : accept->ssl = NULL;
1351 : }
1352 : }
1353 :
1354 1 : RS_CLOSE_RETRY_FOR_EINTR(ret, accept->connFd);
1355 :
1356 1 : hccp_info("free accept_server IP:%s, port:%d, connFd:%d", accept->serverIpAddr.readAddr,
1357 : accept->sockPort, accept->connFd);
1358 1 : accept->connFd = RS_FD_INVALID;
1359 :
1360 1 : free(accept);
1361 1 : accept = NULL;
1362 1 : }
1363 :
1364 39 : STATIC void RsFreeAccpetList(struct rs_cb *rscb)
1365 : {
1366 39 : struct RsAcceptInfo *accept = NULL;
1367 39 : struct RsAcceptInfo *accept2 = NULL;
1368 :
1369 39 : if (!RsListEmpty(&rscb->connCb.serverAcceptList)) {
1370 0 : hccp_warn("Server accept list do not empty!");
1371 0 : RS_LIST_GET_HEAD_ENTRY(accept, accept2, &rscb->connCb.serverAcceptList, list, struct RsAcceptInfo);
1372 0 : for (; (&accept->list) != &rscb->connCb.serverAcceptList;
1373 0 : accept = accept2, accept2 = list_entry(accept2->list.next, struct RsAcceptInfo, list)) {
1374 0 : RsFreeAcceptOneNode(rscb, accept);
1375 0 : accept = NULL;
1376 : }
1377 : }
1378 :
1379 39 : return ;
1380 : }
1381 :
1382 12 : STATIC void RsFreeDesignatedAccpetNode(struct rs_cb *rscb, struct RsIpAddrInfo *localIp)
1383 : {
1384 12 : struct RsAcceptInfo *accept = NULL;
1385 12 : struct RsAcceptInfo *accept2 = NULL;
1386 :
1387 12 : if (!RsListEmpty(&rscb->connCb.serverAcceptList)) {
1388 0 : RS_LIST_GET_HEAD_ENTRY(accept, accept2, &rscb->connCb.serverAcceptList, list, struct RsAcceptInfo);
1389 0 : for (; (&accept->list) != &rscb->connCb.serverAcceptList;
1390 0 : accept = accept2, accept2 = list_entry(accept2->list.next, struct RsAcceptInfo, list)) {
1391 0 : if (!RsCompareIpAddr(&accept->serverIpAddr, localIp)) {
1392 0 : RsFreeAcceptOneNode(rscb, accept);
1393 0 : accept = NULL;
1394 : }
1395 : }
1396 : }
1397 :
1398 12 : return;
1399 : }
1400 :
1401 2 : STATIC void RsFreeConnOneNode(struct rs_cb *rscb, struct RsConnInfo *conn)
1402 : {
1403 : int ret;
1404 :
1405 2 : RS_PTHREAD_MUTEX_LOCK(&rscb->connCb.connMutex);
1406 2 : RsListDel(&conn->list);
1407 2 : RS_PTHREAD_MUTEX_ULOCK(&rscb->connCb.connMutex);
1408 :
1409 2 : if (rscb->sslEnable == RS_SSL_ENABLE) {
1410 0 : if (conn->ssl == NULL) {
1411 0 : hccp_warn("[Client] conn->ssl is NULL, it maybe has not establish tls link");
1412 : } else {
1413 0 : ssl_adp_shutdown(conn->ssl);
1414 0 : ssl_adp_free(conn->ssl);
1415 0 : conn->ssl = NULL;
1416 : }
1417 : }
1418 :
1419 2 : RS_CLOSE_RETRY_FOR_EINTR(ret, conn->connfd);
1420 :
1421 2 : hccp_info("free for conn IP:%s, port:%d, connfd:%d, state:%u",
1422 : conn->clientIp.readAddr, conn->port, conn->connfd, conn->state);
1423 :
1424 2 : conn->connfd = RS_FD_INVALID;
1425 2 : conn->state = RS_CONN_STATE_RESET;
1426 :
1427 2 : free(conn);
1428 2 : conn = NULL;
1429 2 : }
1430 :
1431 39 : STATIC void RsFreeClientConnList(struct rs_cb *rscb)
1432 : {
1433 39 : struct RsConnInfo *conn = NULL;
1434 39 : struct RsConnInfo *conn2 = NULL;
1435 :
1436 39 : if (!RsListEmpty(&rscb->connCb.clientConnList)) {
1437 0 : hccp_warn("Client conn node do not empty!");
1438 0 : RS_LIST_GET_HEAD_ENTRY(conn, conn2, &rscb->connCb.clientConnList, list, struct RsConnInfo);
1439 0 : for (; (&conn->list) != &rscb->connCb.clientConnList;
1440 0 : conn = conn2, conn2 = list_entry(conn2->list.next, struct RsConnInfo, list)) {
1441 0 : RsFreeConnOneNode(rscb, conn);
1442 0 : conn = NULL;
1443 : }
1444 : }
1445 :
1446 39 : return;
1447 : }
1448 :
1449 12 : STATIC void RsFreeDesignatedClientConnNode(struct rs_cb *rscb, struct RsIpAddrInfo *localIp)
1450 : {
1451 12 : struct RsConnInfo *conn = NULL;
1452 12 : struct RsConnInfo *conn2 = NULL;
1453 :
1454 12 : if (!RsListEmpty(&rscb->connCb.clientConnList)) {
1455 0 : RS_LIST_GET_HEAD_ENTRY(conn, conn2, &rscb->connCb.clientConnList, list, struct RsConnInfo);
1456 0 : for (; (&conn->list) != &rscb->connCb.clientConnList;
1457 0 : conn = conn2, conn2 = list_entry(conn2->list.next, struct RsConnInfo, list)) {
1458 0 : if (!RsCompareIpAddr(&conn->clientIp, localIp)) {
1459 0 : hccp_warn("Client conn node for IP[%s] do not empty!", localIp->readAddr);
1460 0 : RsFreeConnOneNode(rscb, conn);
1461 0 : conn = NULL;
1462 : }
1463 : }
1464 : }
1465 :
1466 12 : return;
1467 : }
1468 :
1469 39 : STATIC void RsFreeServerConnList(struct rs_cb *rscb)
1470 : {
1471 39 : struct RsConnInfo *conn = NULL;
1472 39 : struct RsConnInfo *conn2 = NULL;
1473 :
1474 39 : if (!RsListEmpty(&rscb->connCb.serverConnList)) {
1475 1 : hccp_warn("Server conn node do not empty!");
1476 1 : RS_LIST_GET_HEAD_ENTRY(conn, conn2, &rscb->connCb.serverConnList, list, struct RsConnInfo);
1477 2 : for (; (&conn->list) != &rscb->connCb.serverConnList;
1478 1 : conn = conn2, conn2 = list_entry(conn2->list.next, struct RsConnInfo, list)) {
1479 1 : RsFreeConnOneNode(rscb, conn);
1480 1 : conn = NULL;
1481 : }
1482 : }
1483 :
1484 39 : return;
1485 : }
1486 :
1487 12 : STATIC void RsFreeDesignatedServerConnNode(struct rs_cb *rscb, struct RsIpAddrInfo *localIp)
1488 : {
1489 12 : struct RsConnInfo *conn = NULL;
1490 12 : struct RsConnInfo *conn2 = NULL;
1491 :
1492 12 : if (!RsListEmpty(&rscb->connCb.serverConnList)) {
1493 1 : RS_LIST_GET_HEAD_ENTRY(conn, conn2, &rscb->connCb.serverConnList, list, struct RsConnInfo);
1494 2 : for (; (&conn->list) != &rscb->connCb.serverConnList;
1495 1 : conn = conn2, conn2 = list_entry(conn2->list.next, struct RsConnInfo, list)) {
1496 1 : if (!RsCompareIpAddr(&conn->serverIp, localIp)) {
1497 1 : hccp_warn("Server conn node for IP[%s] do not empty!", localIp->readAddr);
1498 1 : RsFreeConnOneNode(rscb, conn);
1499 1 : conn = NULL;
1500 : }
1501 : }
1502 : }
1503 12 : return;
1504 : }
1505 :
1506 1 : STATIC void RsFreeListenOneNode(struct rs_cb *rscb, struct RsListenInfo *listen)
1507 : {
1508 : int ret;
1509 :
1510 1 : ret = RsEpollCtl(rscb->connCb.epollfd, EPOLL_CTL_DEL, listen->listenFd, EPOLLIN);
1511 1 : if (ret) {
1512 0 : hccp_err("delete from epoll failed, ret:%d, epollfd:%d, listenFd:%d", ret, rscb->connCb.epollfd,
1513 : listen->listenFd);
1514 : }
1515 :
1516 1 : RS_PTHREAD_MUTEX_LOCK(&rscb->connCb.connMutex);
1517 1 : RsListDel(&listen->list);
1518 1 : RS_PTHREAD_MUTEX_ULOCK(&rscb->connCb.connMutex);
1519 :
1520 1 : RS_CLOSE_RETRY_FOR_EINTR(ret, listen->listenFd);
1521 :
1522 1 : hccp_info("free Listen IP:%s, port:%d, listenFd:%d, state:%u",
1523 : listen->serverIpAddr.readAddr, ntohs(listen->sockPort), listen->listenFd, listen->state);
1524 :
1525 1 : listen->listenFd = RS_FD_INVALID;
1526 1 : listen->state = RS_CONN_STATE_RESET;
1527 :
1528 1 : free(listen);
1529 1 : }
1530 :
1531 39 : STATIC void RsFreeListenList(struct rs_cb *rscb)
1532 : {
1533 39 : struct RsListenInfo *listen = NULL;
1534 39 : struct RsListenInfo *listen2 = NULL;
1535 :
1536 39 : if (!RsListEmpty(&rscb->connCb.listenList)) {
1537 1 : hccp_warn("Server listen node do not empty!");
1538 1 : RS_LIST_GET_HEAD_ENTRY(listen, listen2, &rscb->connCb.listenList, list, struct RsListenInfo);
1539 2 : for (; (&listen->list) != &rscb->connCb.listenList;
1540 1 : listen = listen2, listen2 = list_entry(listen2->list.next, struct RsListenInfo, list)) {
1541 1 : RsFreeListenOneNode(rscb, listen);
1542 1 : listen = NULL;
1543 : }
1544 : }
1545 :
1546 39 : return;
1547 : }
1548 :
1549 12 : STATIC void RsFreeDesignatedListenNode(struct rs_cb *rscb, struct RsIpAddrInfo *localIp)
1550 : {
1551 12 : struct RsListenInfo *listen = NULL;
1552 12 : struct RsListenInfo *listen2 = NULL;
1553 :
1554 12 : if (!RsListEmpty(&rscb->connCb.listenList)) {
1555 0 : RS_LIST_GET_HEAD_ENTRY(listen, listen2, &rscb->connCb.listenList, list, struct RsListenInfo);
1556 0 : for (; (&listen->list) != &rscb->connCb.listenList;
1557 0 : listen = listen2, listen2 = list_entry(listen2->list.next, struct RsListenInfo, list)) {
1558 0 : if (!RsCompareIpAddr(&listen->serverIpAddr, localIp)) {
1559 0 : RsFreeListenOneNode(rscb, listen);
1560 0 : listen = NULL;
1561 : }
1562 : }
1563 : }
1564 :
1565 12 : return;
1566 : }
1567 :
1568 11 : STATIC void RsWhiteListNodeFree(struct rs_cb *rscb, struct RsWhiteList *wlist)
1569 : {
1570 11 : struct RsWhiteListInfo *wlistNode = NULL;
1571 11 : struct RsWhiteListInfo *wlistNode1 = NULL;
1572 :
1573 11 : if (!RsListEmpty(&wlist->whiteList)) {
1574 10 : RS_LIST_GET_HEAD_ENTRY(wlistNode, wlistNode1, &wlist->whiteList, list, struct RsWhiteListInfo);
1575 21 : for (; (&wlistNode->list) != &wlist->whiteList;
1576 11 : wlistNode = wlistNode1, wlistNode1 = list_entry(wlistNode1->list.next,
1577 : struct RsWhiteListInfo, list)) {
1578 11 : RS_PTHREAD_MUTEX_LOCK(&rscb->connCb.connMutex);
1579 11 : RsListDel(&wlistNode->list);
1580 11 : RS_PTHREAD_MUTEX_ULOCK(&rscb->connCb.connMutex);
1581 :
1582 11 : hccp_info("free White list client IP:%s, tag:%s", wlistNode->clientIp.readAddr, wlistNode->tag);
1583 11 : free(wlistNode);
1584 11 : wlistNode = NULL;
1585 : }
1586 : }
1587 11 : }
1588 :
1589 11 : STATIC void RsFreeWhiteOneNode(struct rs_cb *rscb, struct RsWhiteList *wlist)
1590 : {
1591 11 : RsWhiteListNodeFree(rscb, wlist);
1592 :
1593 11 : RS_PTHREAD_MUTEX_LOCK(&rscb->connCb.connMutex);
1594 11 : RsListDel(&wlist->list);
1595 11 : RS_PTHREAD_MUTEX_ULOCK(&rscb->connCb.connMutex);
1596 :
1597 11 : hccp_info("White list server IP:%s", wlist->serverIp.readAddr);
1598 11 : free(wlist);
1599 11 : wlist = NULL;
1600 11 : }
1601 :
1602 39 : STATIC void RsFreeWhiteList(struct rs_cb *rscb)
1603 : {
1604 39 : struct RsWhiteList *wlist = NULL;
1605 39 : struct RsWhiteList *wlist2 = NULL;
1606 :
1607 39 : if (!RsListEmpty(&rscb->connCb.whiteList)) {
1608 1 : hccp_warn("Server white list do not empty!");
1609 1 : RS_LIST_GET_HEAD_ENTRY(wlist, wlist2, &rscb->connCb.whiteList, list, struct RsWhiteList);
1610 2 : for (; (&wlist->list) != &rscb->connCb.whiteList;
1611 1 : wlist = wlist2, wlist2 = list_entry(wlist2->list.next, struct RsWhiteList, list)) {
1612 1 : RsFreeWhiteOneNode(rscb, wlist);
1613 1 : wlist = NULL;
1614 : }
1615 : }
1616 :
1617 39 : return;
1618 : }
1619 :
1620 12 : STATIC void RsFreeDesignatedWhiteNode(struct rs_cb *rscb, struct RsIpAddrInfo *localIp)
1621 : {
1622 12 : struct RsWhiteList *wlist = NULL;
1623 12 : struct RsWhiteList *wlist2 = NULL;
1624 :
1625 12 : if (!RsListEmpty(&rscb->connCb.whiteList)) {
1626 10 : RS_LIST_GET_HEAD_ENTRY(wlist, wlist2, &rscb->connCb.whiteList, list, struct RsWhiteList);
1627 20 : for (; (&wlist->list) != &rscb->connCb.whiteList;
1628 10 : wlist = wlist2, wlist2 = list_entry(wlist2->list.next, struct RsWhiteList, list)) {
1629 10 : if (!RsCompareIpAddr(&wlist->serverIp, localIp)) {
1630 10 : RsFreeWhiteOneNode(rscb, wlist);
1631 10 : wlist = NULL;
1632 : }
1633 : }
1634 : }
1635 :
1636 12 : return;
1637 : }
1638 :
1639 12 : STATIC void RsFreeSocketList(struct rs_cb *rscb, struct RsIpAddrInfo *localIp)
1640 : {
1641 12 : RsFreeDesignatedAccpetNode(rscb, localIp);
1642 12 : RsFreeDesignatedClientConnNode(rscb, localIp);
1643 :
1644 12 : RsFreeDesignatedServerConnNode(rscb, localIp);
1645 :
1646 12 : RsFreeDesignatedListenNode(rscb, localIp);
1647 :
1648 12 : RsFreeDesignatedWhiteNode(rscb, localIp);
1649 :
1650 12 : return ;
1651 : }
1652 :
1653 15 : RS_ATTRI_VISI_DEF int RsSocketDeinit(struct rdev rdevInfo)
1654 : {
1655 : int ret;
1656 15 : unsigned int phyId = rdevInfo.phyId;
1657 : unsigned int chipId;
1658 15 : struct rs_cb *rscb = NULL;
1659 :
1660 15 : hccp_info("rs socket deinit start, phyId:%u", phyId);
1661 15 : CHK_PRT_RETURN(phyId >= RS_MAX_DEV_NUM, hccp_err("rs set param error ! phyId:%u", phyId), -EINVAL);
1662 15 : ret = rsGetLocalDevIDByHostDevID(phyId, &chipId);
1663 15 : CHK_PRT_RETURN(ret, hccp_err("phyId[%u] invalid, ret %d", phyId, ret), ret);
1664 :
1665 15 : CHK_PRT_RETURN((rdevInfo.family != AF_INET) && (rdevInfo.family != AF_INET6),
1666 : hccp_err("family[%d] invalid", rdevInfo.family), -EPROTONOSUPPORT);
1667 :
1668 13 : if (rdevInfo.family == AF_INET) {
1669 13 : unsigned int *localIp = NULL;
1670 13 : localIp = &(rdevInfo.localIp.addr.s_addr);
1671 13 : ret = RsSocketNodeid2vnic(*localIp, localIp);
1672 13 : hccp_info("socket deinit local IP is 0x%llx, ret:%d", *localIp, ret);
1673 : }
1674 :
1675 : struct RsIpAddrInfo localIp;
1676 13 : RsConvertIpAddr(rdevInfo.family, &rdevInfo.localIp, &localIp);
1677 :
1678 13 : ret = RsDev2rscb(chipId, &rscb, false);
1679 13 : CHK_PRT_RETURN(ret, hccp_err("get rscb failed for chipId:%u, ret:%d", chipId, ret), -ENODEV);
1680 :
1681 12 : RS_PTHREAD_MUTEX_LOCK(&rscb->mutex);
1682 12 : RsFreeSocketList(rscb, &localIp);
1683 12 : RS_PTHREAD_MUTEX_ULOCK(&rscb->mutex);
1684 12 : hccp_run_info("socket deinit success, phyId:%u, localIp:%s", phyId, localIp.readAddr);
1685 12 : return 0;
1686 : }
1687 :
1688 43 : STATIC void RsFreeRdevList(struct rs_cb *rsCb)
1689 : {
1690 43 : struct RsRdevCb *rdevCbCurr = NULL;
1691 43 : struct RsRdevCb *rdevCbNext = NULL;
1692 43 : unsigned int phyId = 0;
1693 : int ret;
1694 :
1695 43 : if (RsListEmpty(&rsCb->rdevList)) {
1696 40 : return;
1697 : }
1698 :
1699 3 : hccp_run_warn("Rdev list is not empty!");
1700 3 : ret = rsGetDevIDByLocalDevID(rsCb->chipId, &phyId);
1701 3 : if (ret != 0) {
1702 1 : hccp_err("chipId[%u] invalid, ret %d", rsCb->chipId, ret);
1703 1 : return;
1704 : }
1705 :
1706 2 : RS_LIST_GET_HEAD_ENTRY(rdevCbCurr, rdevCbNext, &rsCb->rdevList, list, struct RsRdevCb);
1707 4 : for (; (&rdevCbCurr->list) != &rsCb->rdevList;
1708 2 : rdevCbCurr = rdevCbNext, rdevCbNext = list_entry(rdevCbNext->list.next, struct RsRdevCb, list)) {
1709 2 : ret = RsRdevDeinit(phyId, rdevCbCurr->notifyType, rdevCbCurr->rdevIndex);
1710 2 : if (ret != 0) {
1711 1 : hccp_err("rs_rdev_deinit failed, ret:%d, phyId:%u", ret, phyId);
1712 : }
1713 : }
1714 :
1715 2 : return;
1716 : }
1717 :
1718 42 : STATIC void RsFreeUdevList(struct rs_cb *rsCb)
1719 : {
1720 42 : struct RsUbDevCb *udevCbCurr = NULL;
1721 42 : struct RsUbDevCb *udevCbNext = NULL;
1722 : int ret;
1723 :
1724 42 : if (RsListEmpty(&rsCb->udevList)) {
1725 40 : return;
1726 : }
1727 :
1728 2 : hccp_run_warn("Udev list is not empty!");
1729 2 : RS_LIST_GET_HEAD_ENTRY(udevCbCurr, udevCbNext, &rsCb->udevList, list, struct RsUbDevCb);
1730 4 : for (; (&udevCbCurr->list) != &rsCb->udevList;
1731 2 : udevCbCurr = udevCbNext, udevCbNext = list_entry(udevCbNext->list.next, struct RsUbDevCb, list)) {
1732 2 : ret = RsUbCtxDeinit(udevCbCurr);
1733 2 : if (ret != 0) {
1734 1 : hccp_err("rs_ub_ctx_deinit failed, ret:%d", ret);
1735 : }
1736 : }
1737 :
1738 2 : return;
1739 : }
1740 :
1741 39 : STATIC void RsFreeHeterogTcpFdList(struct rs_cb *rsCb)
1742 : {
1743 39 : struct RsHeterogTcpFdInfo *fdNode = NULL;
1744 39 : struct RsHeterogTcpFdInfo *fdNode1 = NULL;
1745 :
1746 39 : if (!RsListEmpty(&rsCb->heterogTcpFdList)) {
1747 0 : hccp_warn("heterog_tcp_fd_list do not empty!");
1748 0 : RS_LIST_GET_HEAD_ENTRY(fdNode, fdNode1, &rsCb->heterogTcpFdList, list, struct RsHeterogTcpFdInfo);
1749 0 : for (; (&fdNode->list) != &rsCb->heterogTcpFdList;
1750 0 : fdNode = fdNode1, fdNode1 = list_entry(fdNode1->list.next, struct RsHeterogTcpFdInfo, list)) {
1751 0 : hccp_info(">>>>>fd_node->fd:%d", fdNode->fd);
1752 : // 删除节点
1753 0 : RS_PTHREAD_MUTEX_LOCK(&rsCb->mutex);
1754 0 : RsListDel(&fdNode->list);
1755 0 : free(fdNode);
1756 0 : fdNode = NULL;
1757 0 : RS_PTHREAD_MUTEX_ULOCK(&rsCb->mutex);
1758 : }
1759 : }
1760 :
1761 39 : return;
1762 : }
1763 :
1764 39 : STATIC void RsListFree(struct rs_cb *rscb)
1765 : {
1766 39 : RsFreeAccpetList(rscb);
1767 39 : RsFreeClientConnList(rscb);
1768 :
1769 39 : RsFreeServerConnList(rscb);
1770 :
1771 39 : RsFreeListenList(rscb);
1772 :
1773 39 : RsFreeWhiteList(rscb);
1774 :
1775 39 : return ;
1776 : }
1777 :
1778 40 : STATIC void RsSslFree(struct rs_cb *rscb)
1779 : {
1780 40 : if (rscb->sslEnable == RS_SSL_ENABLE) {
1781 2 : if (rscb->skidSubjectCb != NULL) {
1782 1 : if (memset_s(rscb->skidSubjectCb, sizeof(struct RsCertSkidSubjectCb), 0,
1783 : sizeof(struct RsCertSkidSubjectCb))) {
1784 1 : hccp_warn("memset_s for skid_subject_cb unsuccessful");
1785 : }
1786 1 : free(rscb->skidSubjectCb);
1787 1 : rscb->skidSubjectCb = NULL;
1788 : }
1789 2 : ssl_adp_ctx_free(rscb->serverSslCtx);
1790 2 : rscb->serverSslCtx = NULL;
1791 2 : ssl_adp_ctx_free(rscb->clientSslCtx);
1792 2 : rscb->clientSslCtx = NULL;
1793 : }
1794 40 : }
1795 :
1796 39 : STATIC void RsDeinitFreeRscb(struct rs_cb *rscb)
1797 : {
1798 39 : RS_PTHREAD_MUTEX_LOCK(&rscb->mutex);
1799 39 : RsListFree(rscb);
1800 :
1801 39 : free(rscb->fdMap);
1802 39 : rscb->fdMap = NULL;
1803 39 : freeifaddrs(rscb->ifaddrList);
1804 39 : rscb->ifaddrList = NULL;
1805 39 : RS_PTHREAD_MUTEX_ULOCK(&rscb->mutex);
1806 39 : RsFreeRdevList(rscb);
1807 39 : RsFreeUdevList(rscb);
1808 39 : RsSslFree(rscb);
1809 39 : RsFreeHeterogTcpFdList(rscb);
1810 : #ifdef CONFIG_TLV
1811 : if (RsIsTlvSupported()) {
1812 : if (rscb->tlvCb.initFlag) {
1813 : RsTlvDeinit(rscb->tlvCb.phyId);
1814 : }
1815 : }
1816 : #endif
1817 39 : pthread_mutex_destroy(&rscb->mutex);
1818 39 : pthread_mutex_destroy(&rscb->connCb.connMutex);
1819 39 : RsDestroyEpoll(rscb);
1820 :
1821 : #ifdef CUSTOM_INTERFACE
1822 39 : if (RsIsUdmaSupported() || RsIsRdmaSupported()) {
1823 0 : RsDeInitNetAdapt(rscb);
1824 0 : RsEschedDeinit(rscb->protocol);
1825 0 : (void)RsCtxApiDeinit(rscb->hccpMode, rscb->protocol);
1826 : }
1827 : #endif
1828 :
1829 39 : free(rscb);
1830 39 : rscb = NULL;
1831 39 : gRsCb = NULL;
1832 39 : }
1833 :
1834 43 : RS_ATTRI_VISI_DEF int RsDeinit(struct RsInitConfig *cfg)
1835 : {
1836 43 : struct rs_cb *rscb = gRsCb;
1837 : unsigned int chipId;
1838 : eventfd_t event;
1839 : int ret;
1840 :
1841 43 : CHK_PRT_RETURN(cfg == NULL, hccp_err("param error, cfg is NULL"), -EINVAL);
1842 :
1843 43 : chipId = cfg->chipId;
1844 43 : if (__sync_fetch_and_sub(&(gInitCounter[chipId]), 1) > 1) {
1845 0 : return 0;
1846 : }
1847 43 : if (rscb && (chipId == rscb->chipId)) {
1848 39 : event = 1;
1849 : /* send event to eventfd to waking up epoll handle thread */
1850 39 : ret = (int)write(rscb->connCb.eventfd, &event, sizeof(eventfd_t));
1851 39 : CHK_PRT_RETURN(ret != sizeof(eventfd_t), hccp_err("eventfd_write failed(0x%x), chipId:%u, errno:%d",
1852 : ret, chipId, errno), -EFILEOPER);
1853 :
1854 39 : hccp_info("epoll wait up ok, rscb->connFlag:%d", rscb->connFlag);
1855 : // already been RS_CONN_EXIT_FLAG, no need to change conn_flag
1856 39 : if (rscb->connFlag != RS_CONN_EXIT_FLAG) {
1857 39 : rscb->connFlag = 0;
1858 : }
1859 39 : int tryAgain = RS_TRY_TIME;
1860 78 : while (((rscb->state & RS_STATE_HALT) == 0) && tryAgain > 0) {
1861 39 : usleep(RS_USLEEP_TIME);
1862 39 : tryAgain--;
1863 : };
1864 :
1865 39 : if (tryAgain == 0) {
1866 0 : hccp_warn("try_again exhausted, rscb state:%u", rscb->state);
1867 : }
1868 :
1869 39 : tryAgain = RS_TRY_TIME;
1870 6159 : while ((rscb->connFlag != RS_CONN_EXIT_FLAG) && tryAgain > 0) {
1871 6120 : usleep(RS_USLEEP_TIME);
1872 6120 : tryAgain--;
1873 : }
1874 :
1875 39 : CHK_PRT_RETURN(tryAgain == 0, hccp_warn("connect thread quit unsuccessful"), -EAGAIN);
1876 39 : rscb->state &= ~RS_STATE_HALT;
1877 39 : RsDeinitFreeRscb(rscb);
1878 39 : gRsCbList[chipId] = NULL;
1879 39 : DlHalDeinit();
1880 :
1881 39 : hccp_run_info("rs_deinit chipId[%u] ok", chipId);
1882 :
1883 39 : return 0;
1884 : }
1885 :
1886 4 : DlHalDeinit();
1887 4 : return -ENODEV;
1888 : }
1889 :
1890 0 : RS_ATTRI_VISI_DEF int RsGetVnicIp(unsigned int phyId, unsigned int *vnicIp)
1891 : {
1892 0 : int64_t deviceInfo = 0;
1893 : int ret;
1894 :
1895 0 : CHK_PRT_RETURN(phyId >= RS_MAX_DEV_NUM, hccp_err("phyId:%u >= [%d], is invalid", phyId,
1896 : RS_MAX_DEV_NUM), -EINVAL);
1897 0 : CHK_PRT_RETURN(vnicIp == NULL, hccp_err("vnic_ip is null!"), -EINVAL);
1898 :
1899 0 : ret = DlHalGetDeviceInfo(phyId, MODULE_TYPE_SYSTEM, INFO_TYPE_VNIC_IP, &deviceInfo);
1900 0 : CHK_PRT_RETURN(ret != 0, hccp_err("phyId:%u dl_hal_get_device_info failed! ret:%d", phyId, ret), ret);
1901 :
1902 0 : *vnicIp = (unsigned int)deviceInfo;
1903 0 : return 0;
1904 : }
1905 :
1906 4 : STATIC int RsGetVnicIpInfo(unsigned int phyId, unsigned int id, enum IdType type, struct IpInfo *info)
1907 : {
1908 4 : int64_t deviceInfo = 0;
1909 : unsigned int vnicIp;
1910 : int ret;
1911 :
1912 : // get vnic ip by id with different type
1913 4 : if (type == PHY_ID_VNIC_IP) {
1914 1 : ret = DlHalGetDeviceInfo(id, MODULE_TYPE_SYSTEM, INFO_TYPE_VNIC_IP, &deviceInfo);
1915 1 : CHK_PRT_RETURN(ret != 0, hccp_err("cur_phy_id:%u dl_hal_get_device_info failed! phyId:%u ret:%d",
1916 : phyId, id, ret), ret);
1917 3 : } else if (type == SDID_VNIC_IP) {
1918 1 : ret = DlHalGetDeviceInfo(id, MODULE_TYPE_SYSTEM, INFO_TYPE_SPOD_VNIC_IP, &deviceInfo);
1919 1 : CHK_PRT_RETURN(ret != 0, hccp_err("phyId:%u dl_hal_get_device_info failed! sdid:0x%x ret:%d",
1920 : phyId, id, ret), ret);
1921 : } else {
1922 2 : hccp_err("phyId:%u get vnic ip failed! id:0x%x, invalid type:%u", phyId, id, type);
1923 2 : return -EINVAL;
1924 : }
1925 :
1926 : // prepare ip info, only support IPv4
1927 2 : vnicIp = (unsigned int)deviceInfo;
1928 2 : info->family = AF_INET;
1929 2 : info->ip.addr.s_addr = vnicIp;
1930 :
1931 2 : hccp_dbg("phyId:%u query id:%u type:%u got vnic_ip:%u", phyId, id, type, vnicIp);
1932 :
1933 2 : return 0;
1934 : }
1935 :
1936 3 : RS_ATTRI_VISI_DEF int RsGetVnicIpInfos(unsigned int phyId, enum IdType type, unsigned int ids[], unsigned int num,
1937 : struct IpInfo infos[])
1938 : {
1939 : unsigned int i;
1940 : int ret;
1941 :
1942 3 : CHK_PRT_RETURN(ids == NULL, hccp_err("phyId:%u, ids is null!", phyId), -EINVAL);
1943 2 : CHK_PRT_RETURN(infos == NULL, hccp_err("phyId:%u, infos is null!", phyId), -EINVAL);
1944 :
1945 1 : for (i = 0; i < num; i++) {
1946 1 : ret = RsGetVnicIpInfo(phyId, ids[i], type, &infos[i]);
1947 1 : if (ret != 0) {
1948 1 : hccp_err("phyId:%u get vnic ip info failed! ids[%u]:0x%x type:%u", phyId, i, ids[i], type);
1949 1 : return ret;
1950 : }
1951 : }
1952 :
1953 0 : return 0;
1954 : }
1955 :
1956 453 : int rsGetLocalDevIDByHostDevID(unsigned int phyId, unsigned int *chipId)
1957 : {
1958 453 : CHK_PRT_RETURN(gRsCb == NULL, hccp_warn("No device initialized !"), -ENODEV);
1959 :
1960 441 : if (gRsCb->hccpMode == NETWORK_PEER_ONLINE) {
1961 49 : *chipId = phyId;
1962 49 : return 0;
1963 : } else {
1964 : // to be compatible with mdev scenario: ignore phyId to get current devId(chipId)
1965 392 : return DlDrvQueryProcessHostPid(getpid(), chipId, NULL, NULL, NULL);
1966 : }
1967 : }
1968 :
1969 15 : int rsGetDevIDByLocalDevID(unsigned int chipId, unsigned int *phyId)
1970 : {
1971 15 : CHK_PRT_RETURN(gRsCb == NULL, hccp_warn("No device initialized !"), -ENODEV);
1972 :
1973 15 : if (gRsCb->hccpMode == NETWORK_PEER_ONLINE) {
1974 0 : *phyId = chipId;
1975 0 : return 0;
1976 : } else {
1977 15 : return DlDrvGetDevIdByLocalDevId(chipId, phyId);
1978 : }
1979 : }
1980 :
1981 2 : RS_ATTRI_VISI_DEF int RsSetQpAttrQos(unsigned int phyId, unsigned int rdevIndex, unsigned int qpn,
1982 : struct QosAttr *attr)
1983 : {
1984 : int ret;
1985 2 : struct RsQpCb *qpCb = NULL;
1986 :
1987 2 : RS_QP_PARA_CHECK(phyId);
1988 2 : ret = RsQpn2qpcb(phyId, rdevIndex, qpn, &qpCb);
1989 2 : CHK_PRT_RETURN(ret != 0 || qpCb == NULL, hccp_err("get qp cb failed qpn %u, ret %d", qpn, ret), ret);
1990 :
1991 2 : qpCb->qosAttr.tc = attr->tc;
1992 2 : qpCb->qosAttr.sl = attr->sl;
1993 :
1994 2 : hccp_info("set qp qos attr: qpn[%u] tc[%u] sl[%u]", qpn, attr->tc, attr->sl);
1995 2 : return 0;
1996 : }
1997 :
1998 2 : RS_ATTRI_VISI_DEF int RsSetQpAttrTimeout(unsigned int phyId, unsigned int rdevIndex, unsigned int qpn,
1999 : unsigned int *timeout)
2000 : {
2001 : int ret;
2002 2 : struct RsQpCb *qpCb = NULL;
2003 :
2004 2 : RS_QP_PARA_CHECK(phyId);
2005 2 : ret = RsQpn2qpcb(phyId, rdevIndex, qpn, &qpCb);
2006 2 : CHK_PRT_RETURN(ret != 0 || qpCb == NULL, hccp_err("get qp cb failed qpn %u, ret %d", qpn, ret), ret);
2007 :
2008 2 : qpCb->timeout = *timeout;
2009 :
2010 2 : hccp_info("set qp qos attr: qpn[%u] timeout[%u]", qpn, *timeout);
2011 2 : return 0;
2012 : }
2013 :
2014 2 : RS_ATTRI_VISI_DEF int RsSetQpAttrRetryCnt(unsigned int phyId, unsigned int rdevIndex, unsigned int qpn,
2015 : unsigned int *retryCnt)
2016 : {
2017 : int ret;
2018 2 : struct RsQpCb *qpCb = NULL;
2019 :
2020 2 : RS_QP_PARA_CHECK(phyId);
2021 2 : ret = RsQpn2qpcb(phyId, rdevIndex, qpn, &qpCb);
2022 2 : CHK_PRT_RETURN(ret != 0 || qpCb == NULL, hccp_err("get qp cb failed qpn %u, ret %d", qpn, ret), ret);
2023 :
2024 2 : qpCb->retryCnt = *retryCnt;
2025 :
2026 2 : hccp_info("set qp qos attr: qpn[%u] retry_cnt[%u]", qpn, *retryCnt);
2027 2 : return 0;
2028 : }
2029 :
2030 1 : RS_ATTRI_VISI_DEF int RsGetCqeErrInfo(struct CqeErrInfo *info)
2031 : {
2032 : int ret;
2033 :
2034 1 : ret = RsDrvGetCqeErrInfo(info);
2035 1 : CHK_PRT_RETURN(ret, hccp_err("get failed! ret:%d", ret), ret);
2036 1 : return 0;
2037 : }
2038 :
2039 2 : RS_ATTRI_VISI_DEF int RsGetCqeErrInfoNum(unsigned int phyId, unsigned int rdevIdx, unsigned int *num)
2040 : {
2041 2 : struct RsRdevCb *rdevCb = NULL;
2042 : unsigned int chipId;
2043 : int ret;
2044 :
2045 2 : CHK_PRT_RETURN(phyId >= RS_MAX_DEV_NUM, hccp_err("rs get cqe err param error, phyId[%u]", phyId), -EINVAL);
2046 1 : ret = rsGetLocalDevIDByHostDevID(phyId, &chipId);
2047 1 : CHK_PRT_RETURN(ret, hccp_err("phyId[%u] invalid, ret %d", phyId, ret), ret);
2048 :
2049 1 : ret = RsRdev2rdevCb(chipId, rdevIdx, &rdevCb);
2050 1 : CHK_PRT_RETURN(ret != 0 || rdevCb == NULL, hccp_err("rs_rdev2rdev_cb for chipId[%u] failed, ret %d",
2051 : chipId, ret), ret);
2052 :
2053 0 : *num = rdevCb->cqeErrCnt;
2054 :
2055 0 : return 0;
2056 : }
2057 :
2058 3 : RS_ATTRI_VISI_DEF int RsGetCqeErrInfoList(unsigned int phyId, unsigned int rdevIdx, struct CqeErrInfo *info,
2059 : unsigned int *num)
2060 : {
2061 3 : struct RsQpCb *qpCbCurr = NULL;
2062 3 : struct RsQpCb *qpCbNext = NULL;
2063 3 : struct RsRdevCb *rdevCb = NULL;
2064 3 : unsigned int cqeErrIdx = 0;
2065 3 : unsigned int numTmp = *num;
2066 : unsigned int chipId;
2067 : int ret;
2068 :
2069 3 : CHK_PRT_RETURN(phyId >= RS_MAX_DEV_NUM, hccp_err("rs get cqe err param error, phyId[%u]", phyId), -EINVAL);
2070 2 : ret = rsGetLocalDevIDByHostDevID(phyId, &chipId);
2071 2 : CHK_PRT_RETURN(ret, hccp_err("phyId[%u] invalid, ret %d", phyId, ret), ret);
2072 :
2073 2 : ret = RsRdev2rdevCb(chipId, rdevIdx, &rdevCb);
2074 2 : CHK_PRT_RETURN(ret != 0 || rdevCb == NULL, hccp_err("rs_rdev2rdev_cb for chipId[%u] failed, ret %d",
2075 : chipId, ret), ret);
2076 :
2077 2 : if (RsListEmpty(&rdevCb->qpList)) {
2078 1 : *num = 0;
2079 1 : return 0;
2080 : }
2081 :
2082 1 : RS_LIST_GET_HEAD_ENTRY(qpCbCurr, qpCbNext, &rdevCb->qpList, list, struct RsQpCb);
2083 2 : for (; (&qpCbCurr->list) != &rdevCb->qpList;
2084 1 : qpCbCurr = qpCbNext, qpCbNext = list_entry(qpCbNext->list.next, struct RsQpCb, list)) {
2085 1 : if (qpCbCurr->cqeErrInfo.info.status != 0) {
2086 1 : RS_PTHREAD_MUTEX_LOCK(&qpCbCurr->cqeErrInfo.mutex);
2087 1 : info[cqeErrIdx].status = qpCbCurr->cqeErrInfo.info.status;
2088 1 : info[cqeErrIdx].qpn = qpCbCurr->cqeErrInfo.info.qpn;
2089 1 : info[cqeErrIdx].time = qpCbCurr->cqeErrInfo.info.time;
2090 1 : qpCbCurr->cqeErrInfo.info.status = 0;
2091 1 : RS_PTHREAD_MUTEX_ULOCK(&qpCbCurr->cqeErrInfo.mutex);
2092 1 : RS_PTHREAD_MUTEX_LOCK(&qpCbCurr->rdevCb->cqeErrCntMutex);
2093 1 : qpCbCurr->rdevCb->cqeErrCnt--;
2094 1 : RS_PTHREAD_MUTEX_ULOCK(&qpCbCurr->rdevCb->cqeErrCntMutex);
2095 1 : cqeErrIdx++;
2096 1 : if (cqeErrIdx == numTmp) {
2097 0 : break;
2098 : }
2099 : }
2100 : }
2101 :
2102 1 : *num = cqeErrIdx;
2103 :
2104 1 : return 0;
2105 : }
2106 :
2107 3 : int RsQueryMrCb(struct RsRdevCb *devCb, uint64_t addr, struct RsMrCb **mrCb,
2108 : struct RsListHead *mrList)
2109 : {
2110 3 : struct RsMrCb *mrCurr = NULL;
2111 3 : struct RsMrCb *mrNext = NULL;
2112 :
2113 3 : RS_PTHREAD_MUTEX_LOCK(&devCb->rdevMutex);
2114 3 : RS_LIST_GET_HEAD_ENTRY(mrCurr, mrNext, mrList, list, struct RsMrCb);
2115 3 : for (; (&mrCurr->list) != mrList;
2116 0 : mrCurr = mrNext, mrNext = list_entry(mrNext->list.next, struct RsMrCb, list)) {
2117 2 : if ((mrCurr->mrInfo.addr <= addr) && (addr < mrCurr->mrInfo.addr + mrCurr->mrInfo.len)) {
2118 2 : *mrCb = mrCurr;
2119 2 : RS_PTHREAD_MUTEX_ULOCK(&devCb->rdevMutex);
2120 2 : return 0;
2121 : }
2122 : }
2123 :
2124 1 : *mrCb = NULL;
2125 1 : RS_PTHREAD_MUTEX_ULOCK(&devCb->rdevMutex);
2126 :
2127 1 : hccp_info("cannot find mrcb for addr@0x%lx !", addr);
2128 :
2129 1 : return -ENODEV;
2130 : }
2131 :
2132 4 : STATIC int RsGetLinuxVersion(struct RsLinuxVersionInfo *verInfo)
2133 : {
2134 : #define LINUX_VERSION_MAX_CHAR 1024
2135 : #define LINUX_VERSION_TYPE_NUM 3
2136 : #define LINUX_VERSION_STR "Linux version "
2137 4 : char buffer[LINUX_VERSION_MAX_CHAR] = {0};
2138 : char *versionStr;
2139 4 : int retClose = 0;
2140 4 : int ret = 0;
2141 : int fd;
2142 :
2143 4 : fd = open("/proc/version", O_RDONLY);
2144 4 : CHK_PRT_RETURN(fd < 0, hccp_run_warn("open proc/version unsuccessful, errno[%d] fd[%d]", errno, fd), -EFILEOPER);
2145 :
2146 : do {
2147 3 : ret = (int)read(fd, buffer, sizeof(buffer) - 1);
2148 3 : } while ((ret < 0) && (errno == EINTR));
2149 :
2150 3 : if (ret < 0) {
2151 1 : hccp_run_warn("read fd unsuccessful[%d]", ret);
2152 1 : RS_CLOSE_RETRY_FOR_EINTR(retClose, fd);
2153 1 : return -EFILEOPER;
2154 : }
2155 :
2156 2 : versionStr = strstr(buffer, LINUX_VERSION_STR);
2157 2 : if (versionStr == NULL) {
2158 1 : hccp_run_warn("can't get Linux version");
2159 1 : RS_CLOSE_RETRY_FOR_EINTR(retClose, fd);
2160 1 : return -EFILEOPER;
2161 : }
2162 1 : versionStr += strlen(LINUX_VERSION_STR);
2163 1 : if (sscanf_s(versionStr, "%d.%d.%d", &verInfo->major, &verInfo->minor, &verInfo->patch) !=
2164 : LINUX_VERSION_TYPE_NUM) {
2165 1 : hccp_run_warn("can't extract Linux version");
2166 1 : RS_CLOSE_RETRY_FOR_EINTR(retClose, fd);
2167 1 : return -EFILEOPER;
2168 : }
2169 :
2170 0 : RS_CLOSE_RETRY_FOR_EINTR(retClose, fd);
2171 0 : return retClose;
2172 : }
2173 :
2174 5 : RS_ATTRI_VISI_DEF int RsGetSecRandom(unsigned int *value)
2175 : {
2176 : #define SEC_LINUX_VERSION_MAJOR 5
2177 : #define SEC_LINUX_VERSION_MINOR 18
2178 : #define SEC_LINUX_VERSION_PATCH 0
2179 5 : struct RsLinuxVersionInfo verInfo = {0};
2180 : int ret;
2181 :
2182 5 : ret = RsGetLinuxVersion(&verInfo);
2183 5 : CHK_PRT_RETURN(ret, hccp_run_warn("[rs_get_random]get_linux_version unsuccessful ret(%d)", ret), ret);
2184 :
2185 : // linux_version > 5.18, urandom is secure
2186 1 : if (verInfo.major > SEC_LINUX_VERSION_MAJOR || (verInfo.major == SEC_LINUX_VERSION_MAJOR &&
2187 1 : verInfo.minor > SEC_LINUX_VERSION_MINOR) || (verInfo.major == SEC_LINUX_VERSION_MAJOR &&
2188 0 : verInfo.minor == SEC_LINUX_VERSION_MINOR && verInfo.patch > SEC_LINUX_VERSION_PATCH)) {
2189 1 : ret = RsDrvGetRandomNum((int *)value);
2190 : } else {
2191 0 : hccp_run_warn("[rs_get_random]linux_version is not secure version");
2192 0 : return -ENOTSUPP;
2193 : }
2194 :
2195 1 : if (ret != 0) {
2196 1 : hccp_run_warn("[get][get_random]rs_get_sec_random unsuccessful, ret(%d)", ret);
2197 : }
2198 1 : return ret;
2199 : }
2200 :
2201 440 : RS_ATTRI_VISI_DEF enum ProductType RsGetProductType(int devId)
2202 : {
2203 : static enum ProductType type = PRODUCT_TYPE_NO_VALUE;
2204 : static halChipInfo chipInfo = {0};
2205 : int ret;
2206 :
2207 440 : if (type != PRODUCT_TYPE_NO_VALUE) { // Cache result after first query
2208 438 : hccp_info("[Get][ChipInfo]chip name is %s, type:%d", chipInfo.name, type);
2209 438 : return type;
2210 : }
2211 :
2212 2 : DlHalInit();
2213 2 : ret = DlHalGetChipInfo(devId, &chipInfo);
2214 2 : DlHalDeinit();
2215 :
2216 2 : CHK_PRT_RETURN(ret != 0, hccp_err("[Get][ChipInfo]DlHalGetChipInfo failed ret:%d", ret),
2217 : PRODUCT_TYPE_INVALID);
2218 :
2219 2 : if (fnmatch("910_93[a-zA-Z1-9_]*", (const char *)chipInfo.name, 0) == 0) {
2220 0 : type = PRODUCT_TYPE_910_93;
2221 2 : } else if (fnmatch("910B[a-zA-Z1-9_]*", (const char *)chipInfo.name, 0) == 0) {
2222 0 : type = PRODUCT_TYPE_910B;
2223 2 : } else if (fnmatch("910_96[a-zA-Z1-9_]*", (const char *)chipInfo.name, 0) == 0) {
2224 0 : type = PRODUCT_TYPE_910_96;
2225 2 : } else if (fnmatch("910[a-zA-Z1-9]*", (const char *)chipInfo.name, 0) == 0) {
2226 0 : type = PRODUCT_TYPE_910;
2227 2 : } else if (fnmatch("310p[a-zA-Z1-9]*", (const char *)chipInfo.name, 0) == 0) {
2228 0 : type = PRODUCT_TYPE_310p;
2229 2 : } else if (fnmatch("950[a-zA-Z1-9]*", (const char *)chipInfo.name, 0) == 0) {
2230 0 : type = PRODUCT_TYPE_950;
2231 2 : } else if (fnmatch("350[a-zA-Z1-9]*", (const char *)chipInfo.name, 0) == 0) {
2232 0 : type = PRODUCT_TYPE_350;
2233 : } else {
2234 2 : type = PRODUCT_TYPE_OTHERS;
2235 : }
2236 :
2237 2 : hccp_run_info("[Get][ChipInfo]chip name is %s, type:%d", chipInfo.name, type);
2238 2 : return type;
2239 : }
|
