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