1 /*
2  * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * miscservices under the License is miscservices on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "softbus_hisysevt_connreporter.h"
17 
18 #include "comm_log.h"
19 #include "securec.h"
20 #include "softbus_adapter_thread.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_errcode.h"
23 #include "softbus_hisysevt_common.h"
24 #include "softbus_hisysevt_bus_center.h"
25 #include "softbus_utils.h"
26 
27 #define DEFAULT_PACKAGE_NAME "dsoftbus"
28 #define TOTAL_TIME_KEY "TOTAL_TIME"
29 #define TOTAL_COUNT_KEY "TOTAL_COUNT"
30 #define COUNT1_KEY "COUNT1"
31 #define COUNT2_KEY "COUNT2"
32 #define COUNT3_KEY "COUNT3"
33 #define COUNT4_KEY "COUNT4"
34 #define COUNT5_KEY "COUNT5"
35 #define REQID_MAX 1000000
36 
37 // CONN_DURATION
38 #define CONN_RESULT_DURATION_PARAM_NUM 13
39 #define SOFT_BUS_VERSION_KEY "SOFT_BUS_VERSION"
40 #define PACKAGE_VERSION_KEY "PACKAGE_VERSION"
41 #define CALLER_PACKAGE_NAME_KEY "CALLER_PACKAGE_NAME"
42 #define LINK_TYPE_KEY "LINK_TYPE"
43 #define FAIL_TIME_KEY "FAIL_TOTAL_TIME"
44 #define FAIL_COUNT_KEY "FAIL_TOTAL_COUNT"
45 
46 // PROCESS_STEP_DURATION
47 #define PROCESS_STEP_DURATION_PARAM_NUM 11
48 #define SOFT_BUS_VERSION_KEY "SOFT_BUS_VERSION"
49 #define PACKAGE_VERSION_KEY "PACKAGE_VERSION"
50 #define PROCESS_STEP_KEY "PROCESS_STEP"
51 #define LINK_TYPE_KEY "LINK_TYPE"
52 
53 typedef struct {
54     SoftBusEvtParamType paramType;
55     char paramName[SOFTBUS_HISYSEVT_NAME_LEN];
56 } SoftBusEvtParamSize;
57 
58 typedef enum {
59     STANDARD_S = 1500,
60     STANDARD_A = 2000,
61     STANDARD_B = 2500,
62     STANDARD_C = 3000,
63     STANDARD_D = 4000,
64 } ConnThreshold;
65 
66 typedef struct {
67     uint64_t mConnTotalTime;
68     uint32_t mConnTotalCount;
69     uint64_t mConnFailTime;
70     uint32_t mConnFailCount;
71     uint32_t mConnCount1;
72     uint32_t mConnCount2;
73     uint32_t mConnCount3;
74     uint32_t mConnCount4;
75     uint32_t mConnCount5;
76 } ConnResultRecord;
77 
78 typedef struct {
79     ListNode node;
80     uint32_t pId;
81     char pkgName[PKG_NAME_SIZE_MAX];
82 } PIdOfPkgNameNode;
83 
84 typedef struct {
85     ListNode node;
86     char pkgName[PKG_NAME_SIZE_MAX];
87     ConnResultRecord connResultRecord[SOFTBUS_HISYSEVT_CONN_TYPE_BUTT];
88 } ConnResultApiRecordNode;
89 
90 static SoftBusEvtParamSize g_connResultParam[CONN_RESULT_DURATION_PARAM_NUM] = {
91     {SOFTBUS_EVT_PARAMTYPE_STRING, SOFT_BUS_VERSION_KEY},
92     {SOFTBUS_EVT_PARAMTYPE_STRING, PACKAGE_VERSION_KEY},
93     {SOFTBUS_EVT_PARAMTYPE_STRING, CALLER_PACKAGE_NAME_KEY},
94     {SOFTBUS_EVT_PARAMTYPE_UINT32, LINK_TYPE_KEY},
95     {SOFTBUS_EVT_PARAMTYPE_UINT64, FAIL_TIME_KEY},
96     {SOFTBUS_EVT_PARAMTYPE_UINT32, FAIL_COUNT_KEY},
97     {SOFTBUS_EVT_PARAMTYPE_UINT64, TOTAL_TIME_KEY},
98     {SOFTBUS_EVT_PARAMTYPE_UINT32, TOTAL_COUNT_KEY},
99     {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT1_KEY},
100     {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT2_KEY},
101     {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT3_KEY},
102     {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT4_KEY},
103     {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT5_KEY},
104 };
105 
106 typedef struct {
107     uint64_t mStepTotalTime;
108     uint32_t mStepTotalCount;
109     uint32_t mStepCount1;
110     uint32_t mStepCount2;
111     uint32_t mStepCount3;
112     uint32_t mStepCount4;
113     uint32_t mStepCount5;
114 } ProcessStepRecord;
115 
116 static SoftBusEvtParamSize g_processStepParam[PROCESS_STEP_DURATION_PARAM_NUM] = {
117     {SOFTBUS_EVT_PARAMTYPE_STRING, SOFT_BUS_VERSION_KEY},
118     {SOFTBUS_EVT_PARAMTYPE_STRING, PACKAGE_VERSION_KEY},
119     {SOFTBUS_EVT_PARAMTYPE_UINT32, PROCESS_STEP_KEY},
120     {SOFTBUS_EVT_PARAMTYPE_UINT32, LINK_TYPE_KEY},
121     {SOFTBUS_EVT_PARAMTYPE_UINT64, TOTAL_TIME_KEY},
122     {SOFTBUS_EVT_PARAMTYPE_UINT32, TOTAL_COUNT_KEY},
123     {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT1_KEY},
124     {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT2_KEY},
125     {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT3_KEY},
126     {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT4_KEY},
127     {SOFTBUS_EVT_PARAMTYPE_UINT32, COUNT5_KEY},
128 };
129 
130 static ListNode g_pIdOfPkgName = {0};
131 static SoftBusMutex g_pIdOfNameLock = {0};
132 
133 static ListNode g_connResultApiRecord = {0};
134 static SoftBusMutex g_connResApiLock = {0};
135 
136 static ProcessStepRecord g_processStep[SOFTBUS_HISYSEVT_CONN_TYPE_BUTT][STEP_BUTT] = {0};
137 static SoftBusMutex g_procStepLock = {0};
138 
139 static char *g_softbusVersion = "default softbus version";
140 static char *g_packageVersion = "default package version";
141 
SoftbusGetConnectTraceId()142 uint32_t SoftbusGetConnectTraceId()
143 {
144     static uint32_t connectTraceId = 0;
145     connectTraceId = connectTraceId % REQID_MAX;
146     return connectTraceId++;
147 }
148 
ClearConnResultRecord(void)149 static void ClearConnResultRecord(void)
150 {
151     PIdOfPkgNameNode *pIdItem = NULL;
152     PIdOfPkgNameNode *pIdNext = NULL;
153     if (g_pIdOfPkgName.prev == NULL && g_pIdOfPkgName.next == NULL) {
154         COMM_LOGE(COMM_EVENT, "g_pIdOfPkgName is NULL");
155         return;
156     }
157     LIST_FOR_EACH_ENTRY_SAFE(pIdItem, pIdNext, &(g_pIdOfPkgName), PIdOfPkgNameNode, node) {
158         ListDelete(&pIdItem->node);
159         SoftBusFree(pIdItem);
160     }
161 
162     ConnResultApiRecordNode *conItem = NULL;
163     ConnResultApiRecordNode *conNext = NULL;
164     if (g_connResultApiRecord.prev == NULL && g_connResultApiRecord.next == NULL) {
165         COMM_LOGE(COMM_EVENT, "g_connResultApiRecord is NULL");
166         return;
167     }
168     LIST_FOR_EACH_ENTRY_SAFE(conItem, conNext, &(g_connResultApiRecord), ConnResultApiRecordNode, node) {
169         ListDelete(&conItem->node);
170         SoftBusFree(conItem);
171     }
172 }
173 
ClearProcessStep(void)174 static void ClearProcessStep(void)
175 {
176     for (int32_t i = SOFTBUS_HISYSEVT_CONN_TYPE_P2P; i < SOFTBUS_HISYSEVT_CONN_TYPE_BUTT; i++) {
177         for (int32_t j = NEGOTIATION_STEP; j < STEP_BUTT; j++) {
178             ProcessStepRecord *stepRecord = &g_processStep[i][j];
179             if (stepRecord == NULL) {
180                 COMM_LOGE(COMM_EVENT, "stepRecord is NULL");
181                 continue;
182             }
183             stepRecord->mStepTotalTime = 0;
184             stepRecord->mStepTotalCount = 0;
185             stepRecord->mStepCount1 = 0;
186             stepRecord->mStepCount2 = 0;
187             stepRecord->mStepCount3 = 0;
188             stepRecord->mStepCount4 = 0;
189             stepRecord->mStepCount5 = 0;
190         }
191     }
192 }
193 
GetPkgNameByPId(uint32_t pId)194 static PIdOfPkgNameNode *GetPkgNameByPId(uint32_t pId)
195 {
196     PIdOfPkgNameNode *item = NULL;
197     PIdOfPkgNameNode *next = NULL;
198 
199     LIST_FOR_EACH_ENTRY_SAFE(item, next, &(g_pIdOfPkgName), PIdOfPkgNameNode, node) {
200         if (pId == item->pId) {
201             return item;
202         }
203     }
204     return NULL;
205 }
206 
AddPIdOfPkgNameNode(PIdOfPkgNameNode ** pIdOfNameNode,uint32_t pId,const char * pkgName)207 static int32_t AddPIdOfPkgNameNode(PIdOfPkgNameNode **pIdOfNameNode, uint32_t pId, const char *pkgName)
208 {
209     PIdOfPkgNameNode *newNode = (PIdOfPkgNameNode *)SoftBusCalloc(sizeof(PIdOfPkgNameNode));
210     COMM_CHECK_AND_RETURN_RET_LOGE(newNode != NULL, SOFTBUS_MALLOC_ERR, COMM_EVENT, "malloc fail");
211     if (strcpy_s(newNode->pkgName, PKG_NAME_SIZE_MAX, pkgName) != EOK) {
212         COMM_LOGE(COMM_EVENT, "strcpy pkgName fail. pkgName=%{public}s", pkgName);
213         SoftBusFree(newNode);
214         return SOFTBUS_STRCPY_ERR;
215     }
216     newNode->pId = pId;
217     ListAdd(&g_pIdOfPkgName, &newNode->node);
218     *pIdOfNameNode = newNode;
219     return SOFTBUS_OK;
220 }
221 
GetRecordNodeByPkgName(const char * pkgName)222 static ConnResultApiRecordNode *GetRecordNodeByPkgName(const char *pkgName)
223 {
224     ConnResultApiRecordNode *item = NULL;
225     ConnResultApiRecordNode *next = NULL;
226 
227     LIST_FOR_EACH_ENTRY_SAFE(item, next, &(g_connResultApiRecord), ConnResultApiRecordNode, node) {
228         if (strcmp(item->pkgName, pkgName) == 0) {
229             return item;
230         }
231     }
232     return NULL;
233 }
234 
InitConnResultRecord(ConnResultRecord * connResultRecord)235 static int32_t InitConnResultRecord(ConnResultRecord *connResultRecord)
236 {
237     for (SoftBusConnType connType = SOFTBUS_HISYSEVT_CONN_TYPE_BR; connType < SOFTBUS_HISYSEVT_CONN_TYPE_BUTT;
238          connType++) {
239         ConnResultRecord *connRecord = &connResultRecord[connType];
240         connRecord->mConnTotalTime = 0;
241         connRecord->mConnTotalCount = 0;
242         connRecord->mConnFailTime = 0;
243         connRecord->mConnFailCount = 0;
244         connRecord->mConnCount1 = 0;
245         connRecord->mConnCount2 = 0;
246         connRecord->mConnCount3 = 0;
247         connRecord->mConnCount4 = 0;
248         connRecord->mConnCount5 = 0;
249     }
250     return SOFTBUS_OK;
251 }
252 
AddConnResultApiRecordNode(ConnResultApiRecordNode ** connResultNode,char * pkgName)253 static int32_t AddConnResultApiRecordNode(ConnResultApiRecordNode **connResultNode, char *pkgName)
254 {
255     ConnResultApiRecordNode *newNode = (ConnResultApiRecordNode *)SoftBusCalloc(sizeof(ConnResultApiRecordNode));
256     COMM_CHECK_AND_RETURN_RET_LOGE(newNode != NULL, SOFTBUS_MALLOC_ERR, COMM_EVENT, "malloc fail");
257     if (strcpy_s(newNode->pkgName, PKG_NAME_SIZE_MAX, pkgName) != EOK) {
258         COMM_LOGE(COMM_EVENT, "strcpy pkgName fail. pkgName=%{public}s", pkgName);
259         SoftBusFree(newNode);
260         return SOFTBUS_STRCPY_ERR;
261     }
262     InitConnResultRecord(newNode->connResultRecord);
263     ListAdd(&g_connResultApiRecord, &newNode->node);
264     *connResultNode = newNode;
265     return SOFTBUS_OK;
266 }
267 
SetMsgParamNameAndType(SoftBusEvtReportMsg * msg,SoftBusEvtParamSize * paramSize)268 static int32_t SetMsgParamNameAndType(SoftBusEvtReportMsg *msg, SoftBusEvtParamSize *paramSize)
269 {
270     SoftBusEvtParam *param = NULL;
271     for (uint32_t i = SOFTBUS_EVT_PARAM_ZERO; i < msg->paramNum; i++) {
272         param = &msg->paramArray[i];
273         param->paramType = paramSize[i].paramType;
274         if (strcpy_s(param->paramName, SOFTBUS_HISYSEVT_PARAM_LEN, paramSize[i].paramName) != EOK) {
275             COMM_LOGE(COMM_EVENT, "copy param name fail. paramName=%{public}s", paramSize[i].paramName);
276             return SOFTBUS_STRCPY_ERR;
277         }
278     }
279     return SOFTBUS_OK;
280 }
281 
SetDevConnResultMsgParamValue(SoftBusEvtReportMsg * msg,ConnResultRecord * record,char * pkgName,SoftBusConnType connType)282 static int32_t SetDevConnResultMsgParamValue(SoftBusEvtReportMsg *msg, ConnResultRecord *record, char *pkgName,
283                                              SoftBusConnType connType)
284 {
285     SoftBusEvtParam *param = msg->paramArray;
286     errno_t errnoRet = strcpy_s(param[SOFTBUS_EVT_PARAM_ZERO].paramValue.str, SOFTBUS_HISYSEVT_PARAM_LEN,
287                                 g_softbusVersion);
288     COMM_CHECK_AND_RETURN_RET_LOGE(errnoRet == EOK, SOFTBUS_STRCPY_ERR, COMM_EVENT, "strcpy softbus version fail");
289 
290     errnoRet = strcpy_s(param[SOFTBUS_EVT_PARAM_ONE].paramValue.str, SOFTBUS_HISYSEVT_PARAM_LEN, g_packageVersion);
291     COMM_CHECK_AND_RETURN_RET_LOGE(errnoRet == EOK, SOFTBUS_STRCPY_ERR, COMM_EVENT, "strcpy package version fail");
292 
293     errnoRet = strcpy_s(param[SOFTBUS_EVT_PARAM_TWO].paramValue.str, PKG_NAME_SIZE_MAX, pkgName);
294     COMM_CHECK_AND_RETURN_RET_LOGE(errnoRet == EOK, SOFTBUS_STRCPY_ERR, COMM_EVENT, "strcpy package name fail");
295 
296     param[SOFTBUS_EVT_PARAM_THREE].paramValue.u32v = connType;
297     param[SOFTBUS_EVT_PARAM_FOUR].paramValue.u64v = record->mConnFailTime;
298     param[SOFTBUS_EVT_PARAM_FIVE].paramValue.u32v = record->mConnFailCount;
299     param[SOFTBUS_EVT_PARAM_SIX].paramValue.u64v = record->mConnTotalTime;
300     param[SOFTBUS_EVT_PARAM_SEVEN].paramValue.u32v = record->mConnTotalCount;
301     param[SOFTBUS_EVT_PARAM_EIGHT].paramValue.u32v = record->mConnCount1;
302     param[SOFTBUS_EVT_PARAM_NINE].paramValue.u32v = record->mConnCount2;
303     param[SOFTBUS_EVT_PARAM_TEN].paramValue.u32v = record->mConnCount3;
304     param[SOFTBUS_EVT_PARAM_ELEVEN].paramValue.u32v = record->mConnCount4;
305     param[SOFTBUS_EVT_PARAM_TWELVE].paramValue.u32v = record->mConnCount5;
306 
307     return SOFTBUS_OK;
308 }
309 
SetDevProcStepMsgParamValue(SoftBusEvtReportMsg * msg,ProcessStepRecord * record,SoftBusConnType connType,ProcessStep step)310 static int32_t SetDevProcStepMsgParamValue(SoftBusEvtReportMsg *msg, ProcessStepRecord *record,
311                                            SoftBusConnType connType, ProcessStep step)
312 {
313     SoftBusEvtParam *param = msg->paramArray;
314     errno_t errnoRet = strcpy_s(param[SOFTBUS_EVT_PARAM_ZERO].paramValue.str, SOFTBUS_HISYSEVT_PARAM_LEN,
315                                 g_softbusVersion);
316     COMM_CHECK_AND_RETURN_RET_LOGE(errnoRet == EOK, SOFTBUS_STRCPY_ERR, COMM_EVENT, "strcpy softbus version fail");
317 
318     errnoRet = strcpy_s(param[SOFTBUS_EVT_PARAM_ONE].paramValue.str, SOFTBUS_HISYSEVT_PARAM_LEN, g_packageVersion);
319     COMM_CHECK_AND_RETURN_RET_LOGE(errnoRet == EOK, SOFTBUS_STRCPY_ERR, COMM_EVENT, "strcpy package version fail");
320 
321     param[SOFTBUS_EVT_PARAM_TWO].paramValue.u32v = step;
322     param[SOFTBUS_EVT_PARAM_THREE].paramValue.u32v = connType;
323     param[SOFTBUS_EVT_PARAM_FOUR].paramValue.u64v = record->mStepTotalTime;
324     param[SOFTBUS_EVT_PARAM_FIVE].paramValue.u32v = record->mStepTotalCount;
325     param[SOFTBUS_EVT_PARAM_SIX].paramValue.u32v = record->mStepCount1;
326     param[SOFTBUS_EVT_PARAM_SEVEN].paramValue.u32v = record->mStepCount2;
327     param[SOFTBUS_EVT_PARAM_EIGHT].paramValue.u32v = record->mStepCount3;
328     param[SOFTBUS_EVT_PARAM_NINE].paramValue.u32v = record->mStepCount4;
329     param[SOFTBUS_EVT_PARAM_TEN].paramValue.u32v = record->mStepCount5;
330     return SOFTBUS_OK;
331 }
332 
SoftBusCreateConnDurMsg(SoftBusEvtReportMsg * msg,ConnResultRecord * record,char * pkgName,SoftBusConnType connType)333 static int32_t SoftBusCreateConnDurMsg(SoftBusEvtReportMsg *msg, ConnResultRecord *record, char *pkgName,
334                                        SoftBusConnType connType)
335 {
336     errno_t errnoRet = strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_CONN_DURATION);
337     COMM_CHECK_AND_RETURN_RET_LOGE(errnoRet == EOK, SOFTBUS_STRCPY_ERR, COMM_EVENT,
338         "strcpy evtname fail. STATISTIC_EVT_CONN_DURATION=%{public}s", STATISTIC_EVT_CONN_DURATION);
339     msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
340     msg->paramNum = CONN_RESULT_DURATION_PARAM_NUM;
341 
342     int32_t ret = SetMsgParamNameAndType(msg, g_connResultParam);
343     if (ret != SOFTBUS_OK) {
344         COMM_LOGE(COMM_EVENT, "set name and type fail");
345         return ret;
346     }
347     ret = SetDevConnResultMsgParamValue(msg, record, pkgName, connType);
348     if (ret != SOFTBUS_OK) {
349         COMM_LOGE(COMM_EVENT, "set param value fail");
350         return ret;
351     }
352     return SOFTBUS_OK;
353 }
354 
SoftBusCreateProcStepMsg(SoftBusEvtReportMsg * msg,SoftBusConnType connType,ProcessStep step)355 static int32_t SoftBusCreateProcStepMsg(SoftBusEvtReportMsg *msg, SoftBusConnType connType, ProcessStep step)
356 {
357     ProcessStepRecord *record = &g_processStep[connType][step];
358     errno_t errnoRet = strcpy_s(msg->evtName, SOFTBUS_HISYSEVT_NAME_LEN, STATISTIC_EVT_PROCESS_STEP_DURATION);
359     COMM_CHECK_AND_RETURN_RET_LOGE(errnoRet == EOK, SOFTBUS_STRCPY_ERR, COMM_EVENT,
360         "strcpy evtname fail. STATISTIC_EVT_PROCESS_STEP_DURATION=%{public}s", STATISTIC_EVT_PROCESS_STEP_DURATION);
361     msg->evtType = SOFTBUS_EVT_TYPE_STATISTIC;
362     msg->paramNum = PROCESS_STEP_DURATION_PARAM_NUM;
363 
364     int32_t ret = SetMsgParamNameAndType(msg, g_processStepParam);
365     if (ret != SOFTBUS_OK) {
366         COMM_LOGE(COMM_EVENT, "set param name and type fail");
367         return ret;
368     }
369     ret = SetDevProcStepMsgParamValue(msg, record, connType, step);
370     if (ret != SOFTBUS_OK) {
371         COMM_LOGE(COMM_EVENT, "set param value fail");
372         return ret;
373     }
374     return SOFTBUS_OK;
375 }
376 
ClearConnResultMsg(SoftBusEvtReportMsg * msg)377 static inline void ClearConnResultMsg(SoftBusEvtReportMsg *msg)
378 {
379     SoftbusFreeEvtReportMsg(msg);
380     ClearConnResultRecord();
381     SoftBusMutexUnlock(&g_connResApiLock);
382 }
383 
SoftBusReportConnResultRecordEvt(void)384 static int32_t SoftBusReportConnResultRecordEvt(void)
385 {
386     COMM_LOGD(COMM_EVENT, "report conn duration event");
387     int32_t ret = SoftBusMutexLock(&g_connResApiLock);
388     COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_EVENT, "g_connResApiLock fail");
389 
390     SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(CONN_RESULT_DURATION_PARAM_NUM);
391     if (msg == NULL) {
392         COMM_LOGE(COMM_EVENT, "create duration event msg fail");
393         ClearConnResultRecord();
394         SoftBusMutexUnlock(&g_connResApiLock);
395         return SOFTBUS_MALLOC_ERR;
396     }
397     ConnResultApiRecordNode *item = NULL;
398     ConnResultApiRecordNode *next = NULL;
399 
400     LIST_FOR_EACH_ENTRY_SAFE(item, next, &(g_connResultApiRecord), ConnResultApiRecordNode, node) {
401         for (SoftBusConnType connType = SOFTBUS_HISYSEVT_CONN_TYPE_BR; connType < SOFTBUS_HISYSEVT_CONN_TYPE_BUTT;
402              connType++)  {
403             COMM_LOGD(COMM_EVENT, "create conn duration event msg connType=%{public}d", connType);
404             char *pkgName = item->pkgName;
405             ConnResultRecord *record = &item->connResultRecord[connType];
406             if (record->mConnTotalCount == 0) {
407                 continue;
408             }
409             ret = SoftBusCreateConnDurMsg(msg, record, pkgName, connType);
410             if (ret != SOFTBUS_OK) {
411                 ClearConnResultMsg(msg);
412                 COMM_LOGE(COMM_EVENT, "create conn duration event msg fail");
413                 return ret;
414             }
415             ret = SoftbusWriteHisEvt(msg);
416             if (ret != SOFTBUS_OK) {
417                 ClearConnResultMsg(msg);
418                 COMM_LOGE(COMM_EVENT, "create conn duration event msg fail");
419                 return ret;
420             }
421         }
422     }
423     ClearConnResultMsg(msg);
424     return SOFTBUS_OK;
425 }
426 
ClearProcStepMsg(SoftBusEvtReportMsg * msg)427 static inline void ClearProcStepMsg(SoftBusEvtReportMsg *msg)
428 {
429     SoftbusFreeEvtReportMsg(msg);
430     ClearProcessStep();
431     SoftBusMutexUnlock(&g_procStepLock);
432 }
433 
SoftBusReportProcessStepRecordEvt(void)434 static int32_t SoftBusReportProcessStepRecordEvt(void)
435 {
436     COMM_LOGD(COMM_EVENT, "report process step duration event");
437     int32_t ret = SoftBusMutexLock(&g_procStepLock);
438     COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_EVENT, "process step duration lock fail");
439     SoftBusEvtReportMsg *msg = SoftbusCreateEvtReportMsg(PROCESS_STEP_DURATION_PARAM_NUM);
440     if (msg == NULL) {
441         COMM_LOGE(COMM_EVENT, "create process step reportMsg fail");
442         ClearProcessStep();
443         SoftBusMutexUnlock(&g_procStepLock);
444         return SOFTBUS_MALLOC_ERR;
445     }
446     for (SoftBusConnType connType = SOFTBUS_HISYSEVT_CONN_TYPE_P2P; connType < SOFTBUS_HISYSEVT_CONN_TYPE_BUTT;
447          connType++)  {
448         for (ProcessStep step = NEGOTIATION_STEP; step < STEP_BUTT; step++) {
449             if (g_processStep[connType][step].mStepTotalCount == 0) {
450                 continue;
451             }
452             ret = SoftBusCreateProcStepMsg(msg, connType, step);
453             if (ret != SOFTBUS_OK) {
454                 ClearProcStepMsg(msg);
455                 COMM_LOGE(COMM_EVENT, "create process step duration reportMsg fail");
456                 return ret;
457             }
458             ret = SoftbusWriteHisEvt(msg);
459             if (ret != SOFTBUS_OK) {
460                 ClearProcStepMsg(msg);
461                 COMM_LOGE(COMM_EVENT, "write process step duration reportMsg fail");
462                 return ret;
463             }
464         }
465     }
466     ClearProcStepMsg(msg);
467     return SOFTBUS_OK;
468 }
469 
SoftBusRecordPIdAndPkgName(uint32_t pId,const char * pkgName)470 int32_t SoftBusRecordPIdAndPkgName(uint32_t pId, const char *pkgName)
471 {
472     COMM_CHECK_AND_RETURN_RET_LOGE(IsValidString(pkgName, PKG_NAME_SIZE_MAX), SOFTBUS_INVALID_PKGNAME, COMM_EVENT,
473         "invalid param!");
474     COMM_LOGD(COMM_EVENT, "record pid and pkg name, pid=%{public}d, pkgName=%{public}s", pId, pkgName);
475     int32_t ret = SoftBusMutexLock(&g_pIdOfNameLock);
476     COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_EVENT, "pId of name lock fail");
477     PIdOfPkgNameNode *pIdOfPkgNameNode = GetPkgNameByPId(pId);
478     if (pIdOfPkgNameNode == NULL) {
479         ret = AddPIdOfPkgNameNode(&pIdOfPkgNameNode, pId, pkgName);
480         if (ret != SOFTBUS_OK) {
481             COMM_LOGE(COMM_EVENT, "add pId of pkg name node fail");
482             SoftBusMutexUnlock(&g_pIdOfNameLock);
483             return ret;
484         }
485     }
486     (void)SoftBusMutexUnlock(&g_pIdOfNameLock);
487     return SOFTBUS_OK;
488 }
489 
ConnResultRecordCount(ConnResultRecord * record,uint64_t costTime)490 static void ConnResultRecordCount(ConnResultRecord *record, uint64_t costTime)
491 {
492     record->mConnTotalTime += costTime;
493     record->mConnTotalCount++;
494     if (costTime > STANDARD_S) {
495         record->mConnCount1++;
496     }
497     if (costTime > STANDARD_A) {
498         record->mConnCount2++;
499     }
500     if (costTime > STANDARD_B) {
501         record->mConnCount3++;
502     }
503     if (costTime > STANDARD_C) {
504         record->mConnCount4++;
505     }
506     if (costTime > STANDARD_D) {
507         record->mConnCount5++;
508     }
509 }
510 
SoftbusReportConnFault(SoftBusConnType connType,int32_t errCode,char * pkgName)511 static int32_t SoftbusReportConnFault(SoftBusConnType connType, int32_t errCode, char *pkgName)
512 {
513     COMM_LOGD(COMM_EVENT, "report conn fault event");
514     SoftBusFaultEvtInfo connFaultInfo;
515     (void)memset_s(&connFaultInfo, sizeof(SoftBusFaultEvtInfo), 0, sizeof(SoftBusFaultEvtInfo));
516     connFaultInfo.moduleType = MODULE_TYPE_CONNECT;
517     connFaultInfo.linkType = connType;
518     connFaultInfo.errorCode = errCode;
519     if (strcpy_s(connFaultInfo.callerPackName, PKG_NAME_SIZE_MAX, pkgName) != EOK) {
520         COMM_LOGE(COMM_EVENT, "strcpy pkgName fail. pkgName=%{public}s", pkgName);
521         return SOFTBUS_STRCPY_ERR;
522     }
523     int32_t ret = SoftBusReportBusCenterFaultEvt(&connFaultInfo);
524     if (ret != SOFTBUS_OK) {
525         COMM_LOGE(COMM_EVENT, "report conn fault evt fail");
526         return ret;
527     }
528     return SOFTBUS_OK;
529 }
530 
SoftbusRecordConnResult(uint32_t pId,SoftBusConnType connType,SoftBusConnStatus status,uint64_t costTime,int32_t errCode)531 int32_t SoftbusRecordConnResult(uint32_t pId, SoftBusConnType connType, SoftBusConnStatus status,
532                                 uint64_t costTime, int32_t errCode)
533 {
534     COMM_LOGD(COMM_EVENT,
535         "record conn duration. connType=%{public}d, status=%{public}d, costTime=%{public}" PRIu64,
536         connType, status, costTime);
537     if (connType < SOFTBUS_HISYSEVT_CONN_TYPE_BR || connType >= SOFTBUS_HISYSEVT_CONN_TYPE_BUTT ||
538         status > SOFTBUS_EVT_CONN_FAIL) {
539         COMM_LOGE(COMM_EVENT, "param is invalid");
540         return SOFTBUS_INVALID_PARAM;
541     }
542     COMM_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_pIdOfNameLock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_EVENT,
543         "pId lock fail!");
544     PIdOfPkgNameNode *pIdNode = GetPkgNameByPId(pId);
545     char pkgName[PKG_NAME_SIZE_MAX] = DEFAULT_PACKAGE_NAME;
546     if (pIdNode != NULL) {
547         COMM_LOGI(COMM_EVENT, "get pkg name by pId is NULL");
548         errno_t errnoRet = strcpy_s(pkgName, PKG_NAME_SIZE_MAX, pIdNode->pkgName);
549         if (errnoRet != EOK) {
550             COMM_LOGE(COMM_EVENT, "strcpy pkgName fail");
551             SoftBusMutexUnlock(&g_pIdOfNameLock);
552             return SOFTBUS_STRCPY_ERR;
553         }
554     }
555     SoftBusMutexUnlock(&g_pIdOfNameLock);
556     COMM_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_connResApiLock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_EVENT,
557         "conn res fail!");
558     ConnResultApiRecordNode *connResultNode = GetRecordNodeByPkgName(pkgName);
559     if (connResultNode == NULL) {
560         int32_t ret = AddConnResultApiRecordNode(&connResultNode, pkgName);
561         if (ret != SOFTBUS_OK) {
562             COMM_LOGE(COMM_EVENT, "add conn result api record node fail");
563             SoftBusMutexUnlock(&g_connResApiLock);
564             return ret;
565         }
566     }
567     ConnResultRecord *record = &connResultNode->connResultRecord[connType];
568     ConnResultRecordCount(record, costTime);
569     if (status == SOFTBUS_EVT_CONN_SUCC) {
570         SoftBusMutexUnlock(&g_connResApiLock);
571         return SOFTBUS_OK;
572     }
573     record->mConnFailTime += costTime;
574     record->mConnFailCount++;
575     SoftBusMutexUnlock(&g_connResApiLock);
576     errCode = GetErrorCodeEx(errCode);
577     COMM_CHECK_AND_RETURN_RET_LOGE(SoftbusReportConnFault(connType, errCode, pkgName) == SOFTBUS_OK, SOFTBUS_STRCPY_ERR,
578                                    COMM_EVENT, "report conn fault event fail!");
579     return SOFTBUS_OK;
580 }
581 
SoftbusRecordProccessDuration(uint32_t pId,SoftBusConnType connType,SoftBusConnStatus status,ProcessStepTime * stepTime,int32_t errCode)582 int32_t SoftbusRecordProccessDuration(uint32_t pId, SoftBusConnType connType, SoftBusConnStatus status,
583                                       ProcessStepTime *stepTime, int32_t errCode)
584 {
585     COMM_LOGD(COMM_EVENT, "record process step duration");
586     if (stepTime == NULL || connType >= SOFTBUS_HISYSEVT_CONN_TYPE_BUTT || connType < SOFTBUS_HISYSEVT_CONN_TYPE_P2P) {
587         COMM_LOGE(COMM_EVENT, "param is invalid");
588         return SOFTBUS_INVALID_PARAM;
589     }
590     SoftbusRecordConnResult(pId, connType, status, stepTime->totalTime, errCode);
591     COMM_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_procStepLock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_EVENT,
592                                    "record g_procStepLock fail");
593     for (ProcessStep i = NEGOTIATION_STEP; i < STEP_BUTT; i++) {
594         uint64_t costTime = stepTime->connGroupTime;
595         switch (i) {
596             case NEGOTIATION_STEP:
597                 costTime = stepTime->negotiationTime;
598                 break;
599             case GROUP_CREATE_STEP:
600                 costTime = stepTime->groupCreateTime;
601                 break;
602             case CONN_GROUP_STEP:
603                 costTime = stepTime->connGroupTime;
604                 break;
605             case STEP_BUTT:
606                 break;
607         }
608         ProcessStepRecord *record = &g_processStep[connType][i];
609         record->mStepTotalTime += costTime;
610         record->mStepTotalCount++;
611         if (costTime > STANDARD_S) {
612             record->mStepCount1++;
613         }
614         if (costTime > STANDARD_A) {
615             record->mStepCount2++;
616         }
617         if (costTime > STANDARD_B) {
618             record->mStepCount3++;
619         }
620         if (costTime > STANDARD_C) {
621             record->mStepCount4++;
622         }
623         if (costTime > STANDARD_D) {
624             record->mStepCount5++;
625         }
626     }
627     if (SoftBusMutexUnlock(&g_procStepLock) != SOFTBUS_OK) {
628         COMM_LOGE(COMM_EVENT, "record process step unlock fail");
629     }
630     return SOFTBUS_OK;
631 }
632 
InitConnEvtMutexLock(void)633 static int32_t InitConnEvtMutexLock(void)
634 {
635     SoftBusMutexAttr mutexAttr = {SOFTBUS_MUTEX_RECURSIVE};
636     COMM_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexInit(&g_pIdOfNameLock, &mutexAttr) == SOFTBUS_OK, SOFTBUS_LOCK_ERR,
637                                    COMM_EVENT, "init pId of name lock fail");
638     int32_t nRet = SoftBusMutexInit(&g_connResApiLock, &mutexAttr);
639     if (nRet != SOFTBUS_OK) {
640         COMM_LOGE(COMM_EVENT, "init conn res api lock fail");
641         (void)SoftBusMutexDestroy(&g_pIdOfNameLock);
642     }
643     nRet = SoftBusMutexInit(&g_procStepLock, &mutexAttr);
644     if (nRet != SOFTBUS_OK) {
645         COMM_LOGE(COMM_EVENT, "init process step lock fail");
646         (void)SoftBusMutexDestroy(&g_pIdOfNameLock);
647         (void)SoftBusMutexDestroy(&g_connResApiLock);
648     }
649     return nRet;
650 }
651 
InitConnStatisticSysEvt(void)652 int32_t InitConnStatisticSysEvt(void)
653 {
654     ListInit(&g_pIdOfPkgName);
655     ListInit(&g_connResultApiRecord);
656     int32_t ret = InitConnEvtMutexLock();
657     if (ret != SOFTBUS_OK) {
658         COMM_LOGE(COMM_EVENT, "Conn Statistic Evt Lock Init Fail!");
659         return ret;
660     }
661     ClearConnResultRecord();
662     ClearProcessStep();
663     SetStatisticEvtReportFunc(SOFTBUS_STATISTIC_EVT_CONN_DURATION, SoftBusReportConnResultRecordEvt);
664     SetStatisticEvtReportFunc(SOFTBUS_STATISTIC_EVT_PROCESS_STEP_DURATION, SoftBusReportProcessStepRecordEvt);
665     return SOFTBUS_OK;
666 }
667 
DeinitConnStatisticSysEvt(void)668 void DeinitConnStatisticSysEvt(void)
669 {
670     ClearConnResultRecord();
671     ClearProcessStep();
672     SoftBusMutexDestroy(&g_pIdOfNameLock);
673     SoftBusMutexDestroy(&g_connResApiLock);
674     SoftBusMutexDestroy(&g_procStepLock);
675 }