1 /*
2 * Copyright (c) 2022 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 * distributed under the License is distributed 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 #include "legacy/softbus_hidumper_util.h"
16
17 #include <stdio.h>
18 #include <string.h>
19 #include <securec.h>
20 #include <time.h>
21
22 #include "auth_interface.h"
23 #include "cJSON.h"
24 #include "comm_log.h"
25 #include "lnn_map.h"
26 #include "message_handler.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_adapter_thread.h"
29 #include "softbus_def.h"
30 #include "softbus_error_code.h"
31 #include "softbus_event.h"
32 #include "stats_event.h"
33 #include "hisysevent_manager_c.h"
34 #include "wifi_direct_types.h"
35
36 #define BIZ_SCENE_NAME "BIZ_SCENE"
37 #define BIZ_STAGE_NAME "BIZ_STAGE"
38 #define STAGE_RES_NAME "STAGE_RES"
39 #define DISC_TYPE_NAME "DISC_TYPE"
40 #define ERROR_CODE_NAME "ERROR_CODE"
41 #define FIRST_DISCOVERY_TIME_NAME "FIRST_DISCOVERY_TIME"
42 #define ONLINE_NUM_NAME "ONLINE_NUM"
43 #define AUTH_COST_TIME_NAME "AUTH_COST_TIME"
44 #define AUTH_LINK_TYPE_NAME "AUTH_LINK_TYPE"
45 #define LINK_TYPE_NAME "LINK_TYPE"
46 #define SESSION_NAME "SESSION_NAME"
47 #define SOCKET_KEY_NAME "SOCKET_NAME"
48 #define TIME_CONSUMING_NAME "COST_TIME"
49 #define BT_FLOW_NAME "BT_FLOW"
50 #define CALLER_PID_NAME "CALLER_PID"
51 #define BOOT_LINK_TYPE "BOOT_LINK_TYPE"
52 #define IS_RENEGOTIATE "IS_RENEGOTIATE"
53 #define IS_REUSE "IS_REUSE"
54 #define NEGOTIATE_TIME "NEGOTIATE_TIME"
55 #define LINK_TIME "LINK_TIME"
56 #define MIN_BW_NAME "MIN_BW"
57 #define METHOD_ID_NAME "METHOD_ID"
58 #define PERMISSION_NAME "PERMISSION_NAME"
59 #define MODULE_NAME_DISC "disc"
60 #define MODULE_NAME_TRANS "trans"
61 #define MODULE_NAME_CONN "conn"
62 #define MODULE_NAME_AUTH "auth"
63 #define MODULE_NAME_HML "hml"
64
65 #define QUERY_EVENT_FULL_QUERY_PARAM (-1)
66 #define MAX_NUM_OF_EVENT_RESULT 100
67 #define DAY_MINUTE (24 * 60)
68 #define SEVEN_DAY_MINUTE (7 * DAY_MINUTE)
69 #define DAY_TIME (24 * 60 * 60 * 1000)
70 #define MINUTE_TIME (60 * 1000)
71 #define TIME_THOUSANDS_FACTOR (1000L)
72 #define WAIT_QUERY_TIME (1000L)
73 #define RATE_HUNDRED 100
74 #define MSG_STATISTIC_QUERY_REPORT 0
75
76 #define QUERY_RULES_MAX_NUM 10
77 #define MAX_LENGTH_OF_EVENT_DOMAIN 17
78 #define MAX_LENGTH_OF_EVENT_NAME 33
79 #define MAX_LENGTH_OF_SUCCESS_RATE 100
80
81 typedef void (*HandleMessageFunc)(SoftBusMessage* msg);
82
83 typedef enum {
84 SOFTBUS_DISCOVERY_STATS_TYPE,
85 SOFTBUS_CONNECTION_STATS_TYPE,
86 SOFTBUS_BUSCENTER_STATS_TYPE,
87 SOFTBUS_TRANSPORT_STATS_TYPE,
88 STATS_UNUSE_BUTT,
89 } SoftBusStatsType;
90
91 typedef struct {
92 HiSysEventQueryRule queryRules[QUERY_RULES_MAX_NUM];
93 HiSysEventQueryCallback callback;
94 int32_t eventSize;
95 int32_t dataSize;
96 } HiSysEventQueryParam;
97
98 typedef struct {
99 int64_t delayTimeFirstDiscovery[MEDIUM_BUTT + 1];
100 int32_t delayNumFirstDiscovery[MEDIUM_BUTT + 1];
101 } DiscStatsInfo;
102
103 typedef struct {
104 int32_t connFailTotal;
105 int32_t connSuccessTotal;
106 int32_t linkTypeTotal[CONNECT_TYPE_MAX];
107 int32_t linkTypeSuccessTotal[CONNECT_TYPE_MAX];
108 int64_t delayTimeLinkType[CONNECT_TYPE_MAX];
109 int32_t delayNumLinkType[CONNECT_TYPE_MAX];
110 } ConnStatsInfo;
111
112 typedef struct {
113 int32_t linkTotal[STATISTIC_BOOT_LINK_TYPE_NUM][STATISTIC_LINK_TYPE_NUM];
114 int32_t successTotal[STATISTIC_BOOT_LINK_TYPE_NUM][STATISTIC_LINK_TYPE_NUM];
115 int32_t negotiateTotal[STATISTIC_BOOT_LINK_TYPE_NUM][STATISTIC_LINK_TYPE_NUM];
116 uint64_t linkTimeConsuming[STATISTIC_BOOT_LINK_TYPE_NUM][STATISTIC_LINK_TYPE_NUM];
117 uint64_t negotiateTimeCosuming[STATISTIC_BOOT_LINK_TYPE_NUM][STATISTIC_LINK_TYPE_NUM];
118 } ConnHmlInfo;
119
120 typedef struct {
121 int32_t authFailTotal;
122 int32_t authSuccessTotal;
123 int32_t authLinkTypeTotal[AUTH_LINK_TYPE_MAX];
124 int32_t authLinkTypeSuccessTotal[AUTH_LINK_TYPE_MAX];
125 int64_t delayTimeAuth[AUTH_LINK_TYPE_MAX];
126 int32_t delayNumAuth[AUTH_LINK_TYPE_MAX];
127 int32_t onlineDevMaxNum;
128 int32_t joinLnnNum;
129 int32_t leaveLnnNum;
130 } LnnStatsInfo;
131
132 typedef struct {
133 int32_t total;
134 int32_t successTotal;
135 int32_t delayNum;
136 int64_t delay;
137 } TransStatsSuccessRateDetail;
138
139 typedef struct {
140 int32_t scene;
141 int32_t stage;
142 int32_t stageRes;
143 char *socketName;
144 int32_t linkType;
145 int32_t delay;
146 } TransStatsPara;
147
148 typedef struct {
149 int32_t openSessionFailTotal;
150 int32_t openSessionSuccessTotal;
151 int32_t delayTimeTotal;
152 int32_t delayNum;
153 int32_t btFlowTotal;
154 int32_t currentParaSessionNum;
155 int32_t maxParaSessionNum;
156 int32_t laneScoreOverTimes;
157 int32_t activityFailTotal;
158 int32_t activitySuccessTotal;
159 int32_t detectionTimes;
160 Map sessionNameLinkTypeMap;
161 } TransStatsInfo;
162
163 static bool g_isDumperInit = false;
164
165 static bool g_isDiscQueryEnd = false;
166 static bool g_isConnQueryEnd = false;
167 static bool g_isLnnQueryEnd = false;
168 static bool g_isTransQueryEnd = false;
169 static bool g_isAlarmQueryEnd = false;
170
171 static SoftBusMutex g_statsQueryLock = {0};
172 static SoftBusMutex g_alarmQueryLock = {0};
173 static SoftBusMutex g_discOnQueryLock = {0};
174 static SoftBusMutex g_connOnQueryLock = {0};
175 static SoftBusMutex g_lnnOnQueryLock = {0};
176 static SoftBusMutex g_transOnQueryLock = {0};
177 static SoftBusMutex g_alarmOnQueryLock = {0};
178
179 static SoftBusMutex g_transMapLock = {0};
180 static bool g_isTransMapInit = false;
181 static DiscStatsInfo g_discStatsInfo = {{0}, {0}};
182 static ConnStatsInfo g_connStatsInfo = {0, 0, {0}, {0}, {0}, {0}};
183 static ConnHmlInfo g_connHmlStatsInfo = {{0}, {0}, {0}, {0}, {0}};
184 static LnnStatsInfo g_lnnStatsInfo = {0, 0, {0}, {0}, {0}, {0}, 0, 0, 0};
185 static TransStatsInfo g_transStatsInfo = {0};
186 static SoftBusAlarmEvtResult g_alarmEvtResult = {0};
187
188 static HiSysEventQueryParam g_queryStatsParam[STATS_UNUSE_BUTT];
189 static HiSysEventQueryParam g_queryAlarmParam[ALARM_UNUSE_BUTT];
190
TransMapInit(void)191 static bool TransMapInit(void)
192 {
193 if (SoftBusMutexInit(&g_transMapLock, NULL) != SOFTBUS_OK) {
194 COMM_LOGE(COMM_DFX, "transMap mutex init fail");
195 return false;
196 }
197 LnnMapInit(&g_transStatsInfo.sessionNameLinkTypeMap);
198 g_isTransMapInit = true;
199 return true;
200 }
201
TransMapLock(void)202 static int32_t TransMapLock(void)
203 {
204 if (!g_isTransMapInit) {
205 if (!TransMapInit()) {
206 return SOFTBUS_LOCK_ERR;
207 }
208 }
209 return SoftBusMutexLock(&g_transMapLock);
210 }
211
TransMapUnlock(void)212 static void TransMapUnlock(void)
213 {
214 if (!g_isTransMapInit) {
215 (void)TransMapInit();
216 return;
217 }
218 (void)SoftBusMutexUnlock(&g_transMapLock);
219 }
220
GetInt32ValueByRecord(HiSysEventRecordC * record,char * name)221 static int32_t GetInt32ValueByRecord(HiSysEventRecordC* record, char* name)
222 {
223 int64_t value;
224 int32_t res = OH_HiSysEvent_GetParamInt64Value(record, name, &value);
225 if (res != SOFTBUS_OK) {
226 return SOFTBUS_HISYSEVENT_GET_VALUE_ERR;
227 }
228 return (int32_t)value;
229 }
230
GetUint64ValueByRecord(HiSysEventRecordC * record,char * name)231 static uint64_t GetUint64ValueByRecord(HiSysEventRecordC* record, char* name)
232 {
233 uint64_t value;
234 int32_t res = OH_HiSysEvent_GetParamUint64Value(record, name, &value);
235 if (res != SOFTBUS_OK) {
236 return SOFTBUS_HISYSEVENT_GET_VALUE_ERR;
237 }
238 return value;
239 }
240
GetStringValueByRecord(HiSysEventRecordC * record,char * name)241 static char* GetStringValueByRecord(HiSysEventRecordC* record, char* name)
242 {
243 char* value;
244 int32_t res = OH_HiSysEvent_GetParamStringValue(record, name, &value);
245 if (res != SOFTBUS_OK) {
246 return NULL;
247 }
248 return value;
249 }
250
GetLocalTime(char * time,uint64_t timestamp)251 static void GetLocalTime(char* time, uint64_t timestamp)
252 {
253 time_t t = (time_t)timestamp;
254 struct tm* tmInfo = NULL;
255 tmInfo = localtime(&t);
256 if (tmInfo == NULL) {
257 return;
258 }
259 (void)strftime(time, SOFTBUS_ALARM_TIME_LEN, "%Y-%m-%d %H:%M:%S", tmInfo);
260 }
261
OnQueryDisc(HiSysEventRecordC srcRecord[],size_t size)262 static void OnQueryDisc(HiSysEventRecordC srcRecord[], size_t size)
263 {
264 COMM_LOGI(COMM_DFX, "OnQueryDisc start");
265 if (SoftBusMutexLock(&g_discOnQueryLock) != SOFTBUS_OK) {
266 COMM_LOGE(COMM_DFX, "disc query lock fail");
267 return;
268 }
269
270 for (size_t i = 0; i < size; i++) {
271 int32_t scene = GetInt32ValueByRecord(&srcRecord[i], BIZ_SCENE_NAME);
272 int32_t stage = GetInt32ValueByRecord(&srcRecord[i], BIZ_STAGE_NAME);
273 int32_t stageRes = GetInt32ValueByRecord(&srcRecord[i], STAGE_RES_NAME);
274 int32_t discFirstTime = GetInt32ValueByRecord(&srcRecord[i], FIRST_DISCOVERY_TIME_NAME);
275 if (scene != EVENT_SCENE_DISC || stage != EVENT_STAGE_DEVICE_FOUND
276 || stageRes != EVENT_STAGE_RESULT_OK || discFirstTime == SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
277 continue;
278 }
279
280 int32_t discType = GetInt32ValueByRecord(&srcRecord[i], DISC_TYPE_NAME);
281 if (discType < AUTO + 1 || discType >= MEDIUM_BUTT + 1) {
282 discType = SOFTBUS_ZERO;
283 }
284 g_discStatsInfo.delayTimeFirstDiscovery[discType] += discFirstTime;
285 g_discStatsInfo.delayNumFirstDiscovery[discType]++;
286 }
287 (void)SoftBusMutexUnlock(&g_discOnQueryLock);
288 }
289
OnCompleteDisc(int32_t reason,int32_t total)290 static void OnCompleteDisc(int32_t reason, int32_t total)
291 {
292 COMM_LOGI(COMM_DFX, "OnCompleteDisc start, reason=%{public}d, total=%{public}d", reason, total);
293 g_isDiscQueryEnd = true;
294 }
295
ConnStatsLinkType(int32_t linkTypePara,int32_t connDelayTime,bool success,int32_t reuse)296 static void ConnStatsLinkType(int32_t linkTypePara, int32_t connDelayTime, bool success, int32_t reuse)
297 {
298 int32_t linkType = linkTypePara;
299 if (linkType < CONNECT_TCP || linkType >= CONNECT_TYPE_MAX) {
300 linkType = SOFTBUS_ZERO;
301 }
302 g_connStatsInfo.linkTypeTotal[linkType]++;
303 if (!success) {
304 return;
305 }
306 g_connStatsInfo.linkTypeSuccessTotal[linkType]++;
307 if (connDelayTime != SOFTBUS_HISYSEVENT_GET_VALUE_ERR && reuse == 0) {
308 g_connStatsInfo.delayTimeLinkType[linkType] += connDelayTime;
309 g_connStatsInfo.delayNumLinkType[linkType]++;
310 }
311 }
312
FillConnHmlInfo(HiSysEventRecordC * record)313 static void FillConnHmlInfo(HiSysEventRecordC* record)
314 {
315 int32_t isReuse = GetInt32ValueByRecord(record, IS_REUSE);
316 if (isReuse == 1) {
317 return;
318 }
319 int32_t linkType = GetInt32ValueByRecord(record, LINK_TYPE_NAME);
320 int32_t wifiDirectLinkType = 0;
321 if (linkType == CONNECT_P2P) {
322 wifiDirectLinkType = STATISTIC_P2P;
323 } else if (linkType == CONNECT_HML) {
324 wifiDirectLinkType = STATISTIC_HML;
325 } else if (linkType == CONNECT_TRIGGER_HML) {
326 wifiDirectLinkType = STATISTIC_TRIGGER_HML;
327 }
328 int32_t bootLinkType = GetInt32ValueByRecord(record, BOOT_LINK_TYPE);
329 int32_t isRenegotiate = GetInt32ValueByRecord(record, IS_RENEGOTIATE);
330 if (isRenegotiate == 1) {
331 bootLinkType = STATISTIC_RENEGOTIATE;
332 }
333 if (bootLinkType >= STATISTIC_BOOT_LINK_TYPE_NUM || bootLinkType < STATISTIC_NONE) {
334 return;
335 }
336 g_connHmlStatsInfo.linkTotal[bootLinkType][wifiDirectLinkType]++;
337 int32_t stageRes = GetInt32ValueByRecord(record, STAGE_RES_NAME);
338 if (stageRes == EVENT_STAGE_RESULT_OK) {
339 g_connHmlStatsInfo.successTotal[bootLinkType][wifiDirectLinkType]++;
340 g_connHmlStatsInfo.linkTimeConsuming[bootLinkType][wifiDirectLinkType] +=
341 GetUint64ValueByRecord(record, LINK_TIME);
342 uint64_t negotiateTime = GetUint64ValueByRecord(record, NEGOTIATE_TIME);
343 if (negotiateTime > 0) {
344 g_connHmlStatsInfo.negotiateTotal[bootLinkType][wifiDirectLinkType]++;
345 g_connHmlStatsInfo.negotiateTimeCosuming[bootLinkType][wifiDirectLinkType] += negotiateTime;
346 }
347 }
348 }
349
OnQueryConn(HiSysEventRecordC srcRecord[],size_t size)350 static void OnQueryConn(HiSysEventRecordC srcRecord[], size_t size)
351 {
352 COMM_LOGI(COMM_DFX, "OnQueryConn start");
353 if (SoftBusMutexLock(&g_connOnQueryLock) != SOFTBUS_OK) {
354 COMM_LOGE(COMM_DFX, "conn query lock fail");
355 return;
356 }
357
358 for (size_t i = 0; i < size; i++) {
359 int32_t scene = GetInt32ValueByRecord(&srcRecord[i], BIZ_SCENE_NAME);
360 int32_t stage = GetInt32ValueByRecord(&srcRecord[i], BIZ_STAGE_NAME);
361 int32_t stageRes = GetInt32ValueByRecord(&srcRecord[i], STAGE_RES_NAME);
362 int32_t isReuse = GetInt32ValueByRecord(&srcRecord[i], IS_REUSE);
363 if (scene != EVENT_SCENE_CONNECT || stage != EVENT_STAGE_CONNECT_END ||
364 stageRes == SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
365 continue;
366 }
367
368 int32_t linkType = GetInt32ValueByRecord(&srcRecord[i], LINK_TYPE_NAME);
369 if (linkType == CONNECT_P2P || linkType == CONNECT_HML || linkType == CONNECT_TRIGGER_HML) {
370 FillConnHmlInfo(&srcRecord[i]);
371 }
372 int32_t connDelayTime = GetInt32ValueByRecord(&srcRecord[i], TIME_CONSUMING_NAME);
373 if (stageRes == EVENT_STAGE_RESULT_OK) {
374 g_connStatsInfo.connSuccessTotal++;
375 ConnStatsLinkType(linkType, connDelayTime, true, isReuse);
376 }
377 if (stageRes == EVENT_STAGE_RESULT_FAILED) {
378 g_connStatsInfo.connFailTotal++;
379 ConnStatsLinkType(linkType, connDelayTime, false, isReuse);
380 }
381 }
382 (void)SoftBusMutexUnlock(&g_connOnQueryLock);
383 }
384
OnCompleteConn(int32_t reason,int32_t total)385 static void OnCompleteConn(int32_t reason, int32_t total)
386 {
387 COMM_LOGI(COMM_DFX, "OnCompleteConn start, reason=%{public}d, total=%{public}d", reason, total);
388 g_isConnQueryEnd = true;
389 }
390
LnnStatsAuthLinkType(int32_t authLinkTypePara,int32_t authDelayTime,bool success)391 static void LnnStatsAuthLinkType(int32_t authLinkTypePara, int32_t authDelayTime, bool success)
392 {
393 int32_t authLinkType = authLinkTypePara;
394 if (authLinkType < AUTH_LINK_TYPE_WIFI || authLinkType >= AUTH_LINK_TYPE_MAX) {
395 authLinkType = SOFTBUS_ZERO;
396 }
397 g_lnnStatsInfo.authLinkTypeTotal[authLinkType]++;
398 if (!success) {
399 return;
400 }
401 g_lnnStatsInfo.authLinkTypeSuccessTotal[authLinkType]++;
402 if (authDelayTime != SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
403 g_lnnStatsInfo.delayTimeAuth[authLinkType] += authDelayTime;
404 g_lnnStatsInfo.delayNumAuth[authLinkType]++;
405 }
406 }
407
LnnStats(int32_t scene,int32_t stage,int32_t stageRes,int32_t authLinkType,int32_t authDelayTime)408 static void LnnStats(int32_t scene, int32_t stage, int32_t stageRes, int32_t authLinkType, int32_t authDelayTime)
409 {
410 if (scene == EVENT_SCENE_JOIN_LNN && stage == EVENT_STAGE_AUTH && stageRes == EVENT_STAGE_RESULT_OK) {
411 g_lnnStatsInfo.authSuccessTotal++;
412 LnnStatsAuthLinkType(authLinkType, authDelayTime, true);
413 return;
414 }
415
416 if (scene == EVENT_SCENE_JOIN_LNN && stage == EVENT_STAGE_AUTH && stageRes == EVENT_STAGE_RESULT_FAILED) {
417 g_lnnStatsInfo.authFailTotal++;
418 LnnStatsAuthLinkType(authLinkType, authDelayTime, false);
419 return;
420 }
421
422 if (scene == EVENT_SCENE_JOIN_LNN && stage == EVENT_STAGE_JOIN_LNN_END && stageRes == EVENT_STAGE_RESULT_OK) {
423 g_lnnStatsInfo.joinLnnNum++;
424 return;
425 }
426
427 if (scene == EVENT_SCENE_LEAVE_LNN && stage == EVENT_STAGE_LEAVE_LNN && stageRes == EVENT_STAGE_RESULT_OK) {
428 g_lnnStatsInfo.leaveLnnNum++;
429 return;
430 }
431 }
432
OnQueryLnn(HiSysEventRecordC srcRecord[],size_t size)433 static void OnQueryLnn(HiSysEventRecordC srcRecord[], size_t size)
434 {
435 COMM_LOGI(COMM_DFX, "OnQueryLnn start");
436 if (SoftBusMutexLock(&g_lnnOnQueryLock) != SOFTBUS_OK) {
437 COMM_LOGE(COMM_DFX, "lnn query lock fail");
438 return;
439 }
440
441 for (size_t i = 0; i < size; i++) {
442 int32_t scene = GetInt32ValueByRecord(&srcRecord[i], BIZ_SCENE_NAME);
443 int32_t stage = GetInt32ValueByRecord(&srcRecord[i], BIZ_STAGE_NAME);
444 int32_t stageRes = GetInt32ValueByRecord(&srcRecord[i], STAGE_RES_NAME);
445 if (scene == SOFTBUS_HISYSEVENT_GET_VALUE_ERR || stage == SOFTBUS_HISYSEVENT_GET_VALUE_ERR ||
446 stageRes == SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
447 continue;
448 }
449
450 int32_t authLinkType = GetInt32ValueByRecord(&srcRecord[i], AUTH_LINK_TYPE_NAME);
451 int32_t authDelayTime = GetInt32ValueByRecord(&srcRecord[i], AUTH_COST_TIME_NAME);
452 LnnStats(scene, stage, stageRes, authLinkType, authDelayTime);
453
454 int32_t onlineNum = GetInt32ValueByRecord(&srcRecord[i], ONLINE_NUM_NAME);
455 if (onlineNum != SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
456 int32_t onlineMaxNum = g_lnnStatsInfo.onlineDevMaxNum;
457 g_lnnStatsInfo.onlineDevMaxNum = (onlineMaxNum > onlineNum) ? onlineMaxNum : onlineNum;
458 }
459 }
460 (void)SoftBusMutexUnlock(&g_lnnOnQueryLock);
461 }
462
OnCompleteLnn(int32_t reason,int32_t total)463 static void OnCompleteLnn(int32_t reason, int32_t total)
464 {
465 COMM_LOGI(COMM_DFX, "OnCompleteLnn start, reason=%{public}d, total=%{public}d", reason, total);
466 g_isLnnQueryEnd = true;
467 }
468
UpdateTransSuccessDetail(TransStatsSuccessRateDetail * res,int32_t delay)469 static void UpdateTransSuccessDetail(TransStatsSuccessRateDetail *res, int32_t delay)
470 {
471 res->successTotal++;
472 if (delay < SOFTBUS_ZERO || delay > MINUTE_TIME) {
473 return;
474 }
475 res->delayNum++;
476 res->delay += delay;
477 }
478
TransStatsSuccessDetail(bool success,const char * socketName,int32_t linkTypePara,int32_t delay)479 static void TransStatsSuccessDetail(bool success, const char *socketName, int32_t linkTypePara, int32_t delay)
480 {
481 int linkType = linkTypePara;
482 if (linkType < CONNECT_TCP || linkType >= CONNECT_TYPE_MAX) {
483 linkType = SOFTBUS_ZERO;
484 }
485
486 char keyStr[SESSION_NAME_SIZE_MAX + 3] = {0};
487 int32_t ret = sprintf_s(keyStr, sizeof(keyStr), "%s-%d", socketName, linkType);
488 if (ret <= 0) {
489 COMM_LOGE(COMM_DFX, "generate key fail");
490 return;
491 }
492 if (TransMapLock() != SOFTBUS_OK) {
493 COMM_LOGE(COMM_DFX, "lock TransMap fail");
494 return;
495 }
496 TransStatsSuccessRateDetail *data =
497 (TransStatsSuccessRateDetail *)LnnMapGet(&g_transStatsInfo.sessionNameLinkTypeMap, keyStr);
498 if (data == NULL) {
499 TransStatsSuccessRateDetail newResult;
500 newResult.successTotal = 0;
501 newResult.total = 1;
502 newResult.delay = 0;
503 newResult.delayNum = 0;
504 if (success) {
505 UpdateTransSuccessDetail(&newResult, delay);
506 }
507 if (LnnMapSet(&g_transStatsInfo.sessionNameLinkTypeMap, keyStr, (const void *)&newResult,
508 sizeof(TransStatsSuccessRateDetail)) != SOFTBUS_OK) {
509 COMM_LOGE(COMM_DFX, "insert fail. keyStr=%{public}s", keyStr);
510 }
511 TransMapUnlock();
512 return;
513 }
514 data->total++;
515 if (success) {
516 UpdateTransSuccessDetail(data, delay);
517 }
518 TransMapUnlock();
519 }
520
TransStats(TransStatsPara * transStatsPara)521 static void TransStats(TransStatsPara *transStatsPara)
522 {
523 int32_t scene = transStatsPara->scene;
524 int32_t stage = transStatsPara->stage;
525 int32_t stageRes = transStatsPara->stageRes;
526 const char *socketName = transStatsPara->socketName;
527 int32_t linkType = transStatsPara->linkType;
528 int32_t delay = transStatsPara->delay;
529 if (scene == EVENT_SCENE_OPEN_CHANNEL && stage == EVENT_STAGE_OPEN_CHANNEL_END
530 && stageRes == EVENT_STAGE_RESULT_OK) {
531 TransStatsSuccessDetail(true, socketName, linkType, delay);
532 g_transStatsInfo.openSessionSuccessTotal++;
533 g_transStatsInfo.currentParaSessionNum++;
534 return;
535 }
536
537 if (scene == EVENT_SCENE_OPEN_CHANNEL && stage == EVENT_STAGE_OPEN_CHANNEL_END
538 && stageRes == EVENT_STAGE_RESULT_FAILED) {
539 TransStatsSuccessDetail(false, socketName, linkType, delay);
540 g_transStatsInfo.openSessionFailTotal++;
541 return;
542 }
543
544 if (scene == EVENT_SCENE_ACTIVATION && stage == SOFTBUS_DEFAULT_STAGE && stageRes == EVENT_STAGE_RESULT_OK) {
545 g_transStatsInfo.activitySuccessTotal++;
546 return;
547 }
548
549 if (scene == EVENT_SCENE_ACTIVATION && stage == SOFTBUS_DEFAULT_STAGE && stageRes == EVENT_STAGE_RESULT_FAILED) {
550 g_transStatsInfo.activityFailTotal++;
551 return;
552 }
553
554 if (scene == EVENT_SCENE_LANE_SCORE && stage == SOFTBUS_DEFAULT_STAGE && stageRes == EVENT_STAGE_RESULT_OK) {
555 g_transStatsInfo.laneScoreOverTimes++;
556 return;
557 }
558
559 if (scene == EVENT_SCENE_DETECTION && stage == SOFTBUS_DEFAULT_STAGE && stageRes == EVENT_STAGE_RESULT_OK) {
560 g_transStatsInfo.detectionTimes++;
561 return;
562 }
563 }
564
OnQueryTrans(HiSysEventRecordC srcRecord[],size_t size)565 static void OnQueryTrans(HiSysEventRecordC srcRecord[], size_t size)
566 {
567 COMM_LOGI(COMM_DFX, "OnQueryTrans start");
568 if (SoftBusMutexLock(&g_transOnQueryLock) != SOFTBUS_OK) {
569 COMM_LOGE(COMM_DFX, "trans query lock fail");
570 return;
571 }
572
573 for (size_t i = 0; i < size; i++) {
574 int32_t scene = GetInt32ValueByRecord(&srcRecord[i], BIZ_SCENE_NAME);
575 int32_t stage = GetInt32ValueByRecord(&srcRecord[i], BIZ_STAGE_NAME);
576 int32_t stageRes = GetInt32ValueByRecord(&srcRecord[i], STAGE_RES_NAME);
577 if (scene == SOFTBUS_HISYSEVENT_GET_VALUE_ERR || stage == SOFTBUS_HISYSEVENT_GET_VALUE_ERR ||
578 stageRes == SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
579 continue;
580 }
581
582 int32_t timeConsuming = GetInt32ValueByRecord(&srcRecord[i], TIME_CONSUMING_NAME);
583 if (timeConsuming != SOFTBUS_HISYSEVENT_GET_VALUE_ERR && stageRes == EVENT_STAGE_RESULT_OK &&
584 scene == EVENT_SCENE_OPEN_CHANNEL) {
585 g_transStatsInfo.delayTimeTotal += timeConsuming;
586 g_transStatsInfo.delayNum++;
587 }
588 char* socketName = GetStringValueByRecord(&srcRecord[i], SOCKET_KEY_NAME);
589 int32_t linkType = GetInt32ValueByRecord(&srcRecord[i], LINK_TYPE_NAME);
590 TransStatsPara transStatsPara = {
591 .scene = scene,
592 .stage = stage,
593 .stageRes = stageRes,
594 .socketName = socketName,
595 .linkType = linkType,
596 .delay = timeConsuming
597 };
598 TransStats(&transStatsPara);
599 cJSON_free(socketName);
600 if (scene == EVENT_SCENE_CLOSE_CHANNEL_ACTIVE && stage == EVENT_STAGE_CLOSE_CHANNEL &&
601 stageRes == EVENT_STAGE_RESULT_OK && g_transStatsInfo.currentParaSessionNum > 0) {
602 g_transStatsInfo.currentParaSessionNum--;
603 }
604 int32_t maxParaSessionNum = g_transStatsInfo.maxParaSessionNum;
605 g_transStatsInfo.maxParaSessionNum = (maxParaSessionNum > g_transStatsInfo.currentParaSessionNum) ?
606 maxParaSessionNum : g_transStatsInfo.currentParaSessionNum;
607
608 int32_t btFlow = GetInt32ValueByRecord(&srcRecord[i], BT_FLOW_NAME);
609 if (btFlow != SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
610 g_transStatsInfo.btFlowTotal += btFlow;
611 }
612 }
613 (void)SoftBusMutexUnlock(&g_transOnQueryLock);
614 }
615
OnCompleteTrans(int32_t reason,int32_t total)616 static void OnCompleteTrans(int32_t reason, int32_t total)
617 {
618 COMM_LOGI(COMM_DFX, "OnCompleteTrans start, reason=%{public}d, total=%{public}d", reason, total);
619 g_isTransQueryEnd = true;
620 }
621
OnQueryAlarm(HiSysEventRecordC srcRecord[],size_t size)622 static void OnQueryAlarm(HiSysEventRecordC srcRecord[], size_t size)
623 {
624 COMM_LOGI(COMM_DFX, "OnQueryAlarm start");
625 if (SoftBusMutexLock(&g_alarmOnQueryLock) != SOFTBUS_OK) {
626 COMM_LOGE(COMM_DFX, "alarm query lock fail");
627 return;
628 }
629 g_alarmEvtResult.recordSize = size;
630
631 for (size_t i = 0; i < size; i++) {
632 AlarmRecord* record = &g_alarmEvtResult.records[i];
633 int32_t scene = GetInt32ValueByRecord(&srcRecord[i], BIZ_SCENE_NAME);
634 if (scene != SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
635 record->type = scene;
636 }
637
638 int32_t callerPid = GetInt32ValueByRecord(&srcRecord[i], CALLER_PID_NAME);
639 if (callerPid != SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
640 record->callerPid = callerPid;
641 }
642
643 int32_t errorCode = GetInt32ValueByRecord(&srcRecord[i], ERROR_CODE_NAME);
644 if (errorCode != SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
645 record->errorCode = errorCode;
646 }
647
648 int32_t linkType = GetInt32ValueByRecord(&srcRecord[i], LINK_TYPE_NAME);
649 if (linkType != SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
650 record->linkType = linkType;
651 }
652
653 int32_t minBw = GetInt32ValueByRecord(&srcRecord[i], MIN_BW_NAME);
654 if (minBw != SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
655 record->minBw = minBw;
656 }
657
658 int32_t methodId = GetInt32ValueByRecord(&srcRecord[i], METHOD_ID_NAME);
659 if (methodId != SOFTBUS_HISYSEVENT_GET_VALUE_ERR) {
660 record->methodId = methodId;
661 }
662
663 char* permissionName = GetStringValueByRecord(&srcRecord[i], PERMISSION_NAME);
664 if (permissionName != NULL) {
665 record->permissionName = permissionName;
666 }
667
668 char* sessionName = GetStringValueByRecord(&srcRecord[i], SESSION_NAME);
669 if (sessionName != NULL) {
670 record->sessionName = sessionName;
671 }
672
673 GetLocalTime(record->time, srcRecord[i].time / TIME_THOUSANDS_FACTOR);
674 }
675 (void)SoftBusMutexUnlock(&g_alarmOnQueryLock);
676 }
677
OnCompleteAlarm(int32_t reason,int32_t total)678 static void OnCompleteAlarm(int32_t reason, int32_t total)
679 {
680 COMM_LOGI(COMM_DFX, "OnCompleteAlarm start, reason=%{public}d, total=%{public}d", reason, total);
681 g_isAlarmQueryEnd = true;
682 }
683
SoftBusEventQueryInfo(int time,HiSysEventQueryParam * queryParam)684 static void SoftBusEventQueryInfo(int time, HiSysEventQueryParam* queryParam)
685 {
686 HiSysEventQueryArg queryArg;
687 queryArg.endTime = (int64_t)SoftBusGetSysTimeMs();
688 queryArg.beginTime = queryArg.endTime - time * MINUTE_TIME;
689 queryArg.maxEvents = queryParam->dataSize;
690
691 int32_t ret = OH_HiSysEvent_Query(&queryArg, queryParam->queryRules, queryParam->eventSize, &queryParam->callback);
692 COMM_LOGD(COMM_DFX, "SoftBusHisEvtQuery result, reason=%{public}d", ret);
693 if (ret != SOFTBUS_OK) {
694 COMM_LOGW(COMM_DFX, "SoftBusHisEvtQuery failed, reason=%{public}d", ret);
695 }
696 }
697
GenerateTransSuccessRateString(MapIterator * it,char * res,uint64_t maxLen)698 static void GenerateTransSuccessRateString(MapIterator *it, char *res, uint64_t maxLen)
699 {
700 char sessionName[SESSION_NAME_SIZE_MAX] = {0};
701 const char *key = (const char *)it->node->key;
702 char *delimit = strrchr(key, '-');
703 if (strncpy_s(sessionName, SESSION_NAME_SIZE_MAX, key, delimit - key) != EOK) {
704 COMM_LOGE(COMM_DFX, "sessionName strncpy failed");
705 return;
706 }
707 int32_t linkType = atoi(delimit + 1);
708 TransStatsSuccessRateDetail *quantity = (TransStatsSuccessRateDetail *)it->node->value;
709 if (quantity == NULL) {
710 COMM_LOGE(COMM_DFX, "quantity is nullptr");
711 return;
712 }
713 float rate = 0;
714 if (quantity->total > 0) {
715 rate = 1.0 * quantity->successTotal / quantity->total * RATE_HUNDRED;
716 }
717 if (sprintf_s(res, maxLen, "%s,%d,%d,%d,%2.2f,%"PRId64",%d", sessionName, linkType, quantity->total,
718 quantity->successTotal, rate, quantity->delay, quantity->delayNum) <= 0) {
719 COMM_LOGE(COMM_DFX, "GenerateTransSuccessRateString sprintf_s fail");
720 return;
721 }
722 }
723
FillTransSuccessRateDetail(cJSON * transObj)724 static void FillTransSuccessRateDetail(cJSON *transObj)
725 {
726 if (transObj == NULL) {
727 COMM_LOGE(COMM_DFX, "trans json is add to root fail");
728 return;
729 }
730 if (TransMapLock() != SOFTBUS_OK) {
731 COMM_LOGE(COMM_DFX, "lock TransMap fail");
732 return;
733 }
734 MapIterator *it = LnnMapInitIterator(&g_transStatsInfo.sessionNameLinkTypeMap);
735 if (it == NULL) {
736 COMM_LOGI(COMM_DFX, "map is empty");
737 TransMapUnlock();
738 return;
739 }
740 while (LnnMapHasNext(it)) {
741 it = LnnMapNext(it);
742 if (it == NULL || it->node->value == NULL) {
743 break;
744 }
745 char detail[SESSION_NAME_SIZE_MAX + MAX_LENGTH_OF_SUCCESS_RATE] = {0};
746 GenerateTransSuccessRateString(it, detail, sizeof(detail));
747 cJSON_AddItemToArray(transObj, cJSON_CreateString(detail));
748 }
749 LnnMapDeinitIterator(it);
750 TransMapUnlock();
751 }
752
FillDiscSuccessRateDetail(cJSON * discObj)753 static void FillDiscSuccessRateDetail(cJSON *discObj)
754 {
755 if (discObj == NULL) {
756 COMM_LOGE(COMM_DFX, "disc json is add to root fail");
757 return;
758 }
759 for (int i = SOFTBUS_ZERO; i < MEDIUM_BUTT + 1; i++) {
760 char detail[MAX_LENGTH_OF_SUCCESS_RATE] = {0};
761 if (sprintf_s(detail, sizeof(detail), "%d,,,,%"PRId64",%d", i, g_discStatsInfo.delayTimeFirstDiscovery[i],
762 g_discStatsInfo.delayNumFirstDiscovery[i]) <= 0) {
763 COMM_LOGE(COMM_DFX, "FillDiscSuccessRateDetail sprintf_s fail");
764 return;
765 }
766 cJSON_AddItemToArray(discObj, cJSON_CreateString(detail));
767 }
768 }
769
FillConnSuccessRateDetail(cJSON * connObj)770 static void FillConnSuccessRateDetail(cJSON *connObj)
771 {
772 if (connObj == NULL) {
773 COMM_LOGE(COMM_DFX, "conn json is add to root fail");
774 return;
775 }
776 for (int i = SOFTBUS_ZERO; i < CONNECT_TYPE_MAX; i++) {
777 float rate = 0;
778 if (g_connStatsInfo.linkTypeTotal[i] > 0) {
779 rate = 1.0 * g_connStatsInfo.linkTypeSuccessTotal[i] / g_connStatsInfo.linkTypeTotal[i] * RATE_HUNDRED;
780 }
781 char detail[MAX_LENGTH_OF_SUCCESS_RATE] = {0};
782 if (sprintf_s(detail, sizeof(detail), "%d,%d,%d,%2.2f,%"PRId64",%d", i, g_connStatsInfo.linkTypeTotal[i],
783 g_connStatsInfo.linkTypeSuccessTotal[i], rate, g_connStatsInfo.delayTimeLinkType[i],
784 g_connStatsInfo.delayNumLinkType[i]) <= 0) {
785 COMM_LOGE(COMM_DFX, "FillConnSuccessRateDetail sprintf_s fail");
786 return;
787 }
788 cJSON_AddItemToArray(connObj, cJSON_CreateString(detail));
789 }
790 }
791
FillHmlDetail(cJSON * hmlObj)792 static void FillHmlDetail(cJSON *hmlObj)
793 {
794 if (hmlObj == NULL) {
795 COMM_LOGE(COMM_DFX, "hml json is null");
796 return;
797 }
798 for (int i = STATISTIC_NONE; i < STATISTIC_BOOT_LINK_TYPE_NUM; i++) {
799 for (int j = STATISTIC_P2P; j < STATISTIC_LINK_TYPE_NUM; j++) {
800 if (g_connHmlStatsInfo.linkTotal[i][j] == 0) {
801 continue;
802 }
803 char detail[MAX_LENGTH_OF_SUCCESS_RATE] = {0};
804 int32_t res = sprintf_s(detail, sizeof(detail), "%d,%d,%d,%d,%d,%"PRIu64",%"PRIu64, i, j,
805 g_connHmlStatsInfo.linkTotal[i][j], g_connHmlStatsInfo.successTotal[i][j],
806 g_connHmlStatsInfo.negotiateTotal[i][j], g_connHmlStatsInfo.linkTimeConsuming[i][j],
807 g_connHmlStatsInfo.negotiateTimeCosuming[i][j]);
808 if (res <= 0) {
809 COMM_LOGE(COMM_DFX, "FillHmlDetail sprintf_s fail");
810 return;
811 }
812 COMM_LOGI(COMM_DFX, "hml statistic : %{public}s", detail);
813 cJSON_AddItemToArray(hmlObj, cJSON_CreateString(detail));
814 }
815 }
816 }
817
FillAuthSuccessRateDetail(cJSON * authObj)818 static void FillAuthSuccessRateDetail(cJSON *authObj)
819 {
820 if (authObj == NULL) {
821 COMM_LOGE(COMM_DFX, "auth json is add to root fail");
822 return;
823 }
824 for (int i = SOFTBUS_ZERO; i < AUTH_LINK_TYPE_MAX; i++) {
825 float rate = 0;
826 if (g_lnnStatsInfo.authLinkTypeTotal[i] > 0) {
827 rate =
828 1.0 * g_lnnStatsInfo.authLinkTypeSuccessTotal[i] / g_lnnStatsInfo.authLinkTypeTotal[i] * RATE_HUNDRED;
829 }
830 char detail[MAX_LENGTH_OF_SUCCESS_RATE] = {0};
831 if (sprintf_s(detail, sizeof(detail), "%d,%d,%d,%2.2f,%"PRId64",%d", i, g_lnnStatsInfo.authLinkTypeTotal[i],
832 g_lnnStatsInfo.authLinkTypeSuccessTotal[i], rate, g_lnnStatsInfo.delayTimeAuth[i],
833 g_lnnStatsInfo.delayNumAuth[i]) <= 0) {
834 COMM_LOGE(COMM_DFX, "FillAuthSuccessRateDetailsprintf_s fail");
835 return;
836 }
837 cJSON_AddItemToArray(authObj, cJSON_CreateString(detail));
838 }
839 }
840
FillSuccessRateDetail(SoftBusStatsResult * result)841 static void FillSuccessRateDetail(SoftBusStatsResult *result)
842 {
843 cJSON *root_obj = cJSON_CreateObject();
844 if (root_obj == NULL) {
845 COMM_LOGE(COMM_DFX, "root_obj is null");
846 return;
847 }
848 cJSON *transObj = cJSON_AddArrayToObject(root_obj, MODULE_NAME_TRANS);
849 FillTransSuccessRateDetail(transObj);
850 cJSON *discObj = cJSON_AddArrayToObject(root_obj, MODULE_NAME_DISC);
851 FillDiscSuccessRateDetail(discObj);
852 cJSON *connObj = cJSON_AddArrayToObject(root_obj, MODULE_NAME_CONN);
853 FillConnSuccessRateDetail(connObj);
854 cJSON *authObj = cJSON_AddArrayToObject(root_obj, MODULE_NAME_AUTH);
855 FillAuthSuccessRateDetail(authObj);
856 cJSON *hmlObj = cJSON_AddArrayToObject(root_obj, MODULE_NAME_HML);
857 FillHmlDetail(hmlObj);
858 result->successRateDetail = cJSON_PrintUnformatted(root_obj);
859 cJSON_Delete(root_obj);
860 }
861
SoftBusFreeDumperQueryData(void)862 static void SoftBusFreeDumperQueryData(void)
863 {
864 if (memset_s(&g_discStatsInfo, sizeof(g_discStatsInfo), 0, sizeof(g_discStatsInfo)) != EOK) {
865 COMM_LOGE(COMM_DFX, "memset g_discStatsInfo fail!");
866 }
867 if (memset_s(&g_connStatsInfo, sizeof(g_connStatsInfo), 0, sizeof(g_connStatsInfo)) != EOK) {
868 COMM_LOGE(COMM_DFX, "memset g_connStatsInfo fail!");
869 }
870 if (memset_s(&g_connHmlStatsInfo, sizeof(g_connHmlStatsInfo), 0, sizeof(g_connHmlStatsInfo)) != EOK) {
871 COMM_LOGE(COMM_DFX, "memset g_connHmlStatsInfo fail!");
872 }
873 if (memset_s(&g_lnnStatsInfo, sizeof(g_lnnStatsInfo), 0, sizeof(g_lnnStatsInfo)) != EOK) {
874 COMM_LOGE(COMM_DFX, "memset g_lnnStatsInfo fail!");
875 }
876 if (TransMapLock() != SOFTBUS_OK) {
877 COMM_LOGE(COMM_DFX, "lock TransMap fail");
878 }
879 LnnMapDelete(&g_transStatsInfo.sessionNameLinkTypeMap);
880 TransMapUnlock();
881 if (memset_s(&g_transStatsInfo, sizeof(g_transStatsInfo), 0, sizeof(g_transStatsInfo)) != EOK) {
882 COMM_LOGE(COMM_DFX, "memset g_transStatsInfo fail!");
883 }
884
885 g_isDiscQueryEnd = false;
886 g_isConnQueryEnd = false;
887 g_isLnnQueryEnd = false;
888 g_isTransQueryEnd = false;
889 }
890
SoftBusProcessStatsQueryData(SoftBusStatsResult * result)891 static void SoftBusProcessStatsQueryData(SoftBusStatsResult* result)
892 {
893 FillSuccessRateDetail(result);
894 result->btFlow = g_transStatsInfo.btFlowTotal;
895 result->successRate = 0;
896 int32_t total = g_transStatsInfo.openSessionSuccessTotal + g_transStatsInfo.openSessionFailTotal;
897 if (total != 0) {
898 result->successRate = (1.0 * g_transStatsInfo.openSessionSuccessTotal) / total;
899 }
900
901 result->sessionSuccessDuration = 0;
902 if (g_transStatsInfo.delayNum != 0) {
903 result->sessionSuccessDuration = g_transStatsInfo.delayTimeTotal / g_transStatsInfo.delayNum;
904 }
905
906 result->activityRate = 0;
907 int32_t activityTotal = g_transStatsInfo.activityFailTotal + g_transStatsInfo.activitySuccessTotal;
908 if (activityTotal != 0) {
909 result->activityRate = (1.0 * g_transStatsInfo.activitySuccessTotal) / activityTotal;
910 }
911
912 result->deviceOnlineNum = g_lnnStatsInfo.onlineDevMaxNum;
913 result->deviceOnlineTimes = g_lnnStatsInfo.joinLnnNum;
914 result->deviceOfflineTimes = g_lnnStatsInfo.leaveLnnNum;
915 result->maxParaSessionNum = g_transStatsInfo.maxParaSessionNum;
916 result->laneScoreOverTimes = g_transStatsInfo.laneScoreOverTimes;
917 result->detectionTimes = g_transStatsInfo.detectionTimes;
918 SoftBusFreeDumperQueryData();
919 }
920
SoftBusProcessAlarmQueryData(SoftBusAlarmEvtResult * result)921 static void SoftBusProcessAlarmQueryData(SoftBusAlarmEvtResult* result)
922 {
923 result->recordSize = g_alarmEvtResult.recordSize;
924 result->records = g_alarmEvtResult.records;
925 g_isAlarmQueryEnd = false;
926 return;
927 }
928
MallocSoftBusStatsResult(unsigned int size)929 SoftBusStatsResult* MallocSoftBusStatsResult(unsigned int size)
930 {
931 SoftBusStatsResult *result = (SoftBusStatsResult *)SoftBusMalloc(size);
932 if (result != NULL) {
933 result->successRateDetail = NULL;
934 }
935 return result;
936 }
937
FreeSoftBusStatsResult(SoftBusStatsResult * result)938 void FreeSoftBusStatsResult(SoftBusStatsResult* result)
939 {
940 if (result != NULL && result->successRateDetail != NULL) {
941 cJSON_free(result->successRateDetail);
942 result->successRateDetail = NULL;
943 }
944 SoftBusFree(result);
945 }
946
SoftBusQueryStatsInfo(int time,SoftBusStatsResult * result)947 int32_t SoftBusQueryStatsInfo(int time, SoftBusStatsResult* result)
948 {
949 COMM_LOGI(COMM_DFX, "SoftBusQueryStatsInfo start");
950 COMM_CHECK_AND_RETURN_RET_LOGE(result != NULL, SOFTBUS_INVALID_PARAM,
951 COMM_DFX, "SoftBusQueryStatsInfo fail, result is null");
952 if (time <= SOFTBUS_ZERO || time > SEVEN_DAY_MINUTE) {
953 COMM_LOGE(COMM_DFX, "SoftBusQueryStatsInfo fail, time=%{public}d", time);
954 return SOFTBUS_INVALID_PARAM;
955 }
956 if (SoftBusMutexLock(&g_statsQueryLock) != SOFTBUS_OK) {
957 COMM_LOGE(COMM_DFX, "lock g_statsQueryLock fail");
958 return SOFTBUS_LOCK_ERR;
959 }
960 for (int i = 0; i < STATS_UNUSE_BUTT; i++) {
961 SoftBusEventQueryInfo(time, &g_queryStatsParam[i]);
962 }
963 while (!g_isDiscQueryEnd || !g_isConnQueryEnd || !g_isLnnQueryEnd || !g_isTransQueryEnd) {
964 SoftBusSleepMs(WAIT_QUERY_TIME);
965 }
966
967 SoftBusProcessStatsQueryData(result);
968 (void)SoftBusMutexUnlock(&g_statsQueryLock);
969 return SOFTBUS_OK;
970 }
971
SoftBusQueryAlarmInfo(int time,int type,SoftBusAlarmEvtResult * result)972 int32_t SoftBusQueryAlarmInfo(int time, int type, SoftBusAlarmEvtResult* result)
973 {
974 COMM_LOGI(COMM_DFX, "SoftBusQueryAlarmInfo start");
975 COMM_CHECK_AND_RETURN_RET_LOGE(result != NULL, SOFTBUS_INVALID_PARAM,
976 COMM_DFX, "QueryAlarmInfo fail, result is null");
977 if (time <= SOFTBUS_ZERO || time > SEVEN_DAY_MINUTE) {
978 COMM_LOGE(COMM_DFX, "QueryAlarmInfo fail, time=%{public}d", time);
979 return SOFTBUS_INVALID_PARAM;
980 }
981 if (type < SOFTBUS_MANAGEMENT_ALARM_TYPE || type >= ALARM_UNUSE_BUTT) {
982 COMM_LOGE(COMM_DFX, "QueryAlarmInfo fail, type=%{public}d", type);
983 return SOFTBUS_INVALID_PARAM;
984 }
985 if (SoftBusMutexLock(&g_alarmQueryLock) != SOFTBUS_OK) {
986 COMM_LOGE(COMM_DFX, "QueryAlarmInfo fail, lock fail");
987 return SOFTBUS_LOCK_ERR;
988 }
989 g_alarmEvtResult.recordSize = 0;
990 if (memset_s(g_alarmEvtResult.records, sizeof(AlarmRecord) * MAX_NUM_OF_EVENT_RESULT, 0,
991 sizeof(AlarmRecord) * MAX_NUM_OF_EVENT_RESULT) != EOK) {
992 COMM_LOGE(COMM_DFX, "memset g_alarmEvtResult records fail!");
993 (void)SoftBusMutexUnlock(&g_alarmQueryLock);
994 return SOFTBUS_MEM_ERR;
995 }
996 SoftBusEventQueryInfo(time, &g_queryAlarmParam[type]);
997 while (!g_isAlarmQueryEnd) {
998 SoftBusSleepMs(WAIT_QUERY_TIME);
999 }
1000
1001 SoftBusProcessAlarmQueryData(result);
1002 (void)SoftBusMutexUnlock(&g_alarmQueryLock);
1003 return SOFTBUS_OK;
1004 }
1005
InitDumperUtilMutexLock(void)1006 static int32_t InitDumperUtilMutexLock(void)
1007 {
1008 SoftBusMutexAttr mutexAttr = {SOFTBUS_MUTEX_RECURSIVE};
1009 int32_t ret = SoftBusMutexInit(&g_statsQueryLock, &mutexAttr);
1010 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_DFX, "init statistic lock fail");
1011
1012 ret = SoftBusMutexInit(&g_alarmQueryLock, &mutexAttr);
1013 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_DFX, "init alarm lock fail");
1014
1015 ret = SoftBusMutexInit(&g_discOnQueryLock, &mutexAttr);
1016 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_DFX, "init disc onQuery lock fail");
1017
1018 ret = SoftBusMutexInit(&g_connOnQueryLock, &mutexAttr);
1019 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_DFX, "init conn onQuery lock fail");
1020
1021 ret = SoftBusMutexInit(&g_lnnOnQueryLock, &mutexAttr);
1022 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_DFX, "init lnn onQuery lock fail");
1023
1024 ret = SoftBusMutexInit(&g_transOnQueryLock, &mutexAttr);
1025 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_DFX, "init trans onQuery lock fail");
1026
1027 ret = SoftBusMutexInit(&g_alarmOnQueryLock, &mutexAttr);
1028 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_DFX, "init alarm onQuery lock fail");
1029 return SOFTBUS_OK;
1030 }
1031
UpdateSysEventQueryParam(HiSysEventQueryParam * param,char * eventName)1032 static void UpdateSysEventQueryParam(HiSysEventQueryParam* param, char* eventName)
1033 {
1034 HiSysEventQueryRule* queryRule = ¶m->queryRules[SOFTBUS_ZERO];
1035 if (strcpy_s(queryRule->domain, MAX_LENGTH_OF_EVENT_DOMAIN, SOFTBUS_EVENT_DOMAIN) != EOK) {
1036 COMM_LOGE(COMM_DFX, "UpdateSysEventQueryParam copy domain fail");
1037 }
1038 if (strcpy_s(queryRule->eventList[SOFTBUS_ZERO], MAX_LENGTH_OF_EVENT_NAME, eventName) != EOK) {
1039 COMM_LOGE(COMM_DFX, "UpdateSysEventQueryParam copy domain fail");
1040 }
1041 queryRule->eventListSize = SOFTBUS_ONE;
1042 queryRule->condition = NULL;
1043 param->eventSize = SOFTBUS_ONE;
1044 }
1045
InitSoftBusQueryEventParam(void)1046 static void InitSoftBusQueryEventParam(void)
1047 {
1048 HiSysEventQueryParam* discParam = &g_queryStatsParam[SOFTBUS_DISCOVERY_STATS_TYPE];
1049 UpdateSysEventQueryParam(discParam, DISC_EVENT_NAME);
1050 discParam->callback.OnQuery = OnQueryDisc;
1051 discParam->callback.OnComplete = OnCompleteDisc;
1052 discParam->dataSize = QUERY_EVENT_FULL_QUERY_PARAM;
1053
1054 HiSysEventQueryParam* connParam = &g_queryStatsParam[SOFTBUS_CONNECTION_STATS_TYPE];
1055 UpdateSysEventQueryParam(connParam, CONN_EVENT_NAME);
1056 connParam->callback.OnQuery = OnQueryConn;
1057 connParam->callback.OnComplete = OnCompleteConn;
1058 connParam->dataSize = QUERY_EVENT_FULL_QUERY_PARAM;
1059
1060 HiSysEventQueryParam* lnnParam = &g_queryStatsParam[SOFTBUS_BUSCENTER_STATS_TYPE];
1061 UpdateSysEventQueryParam(lnnParam, LNN_EVENT_NAME);
1062 lnnParam->callback.OnQuery = OnQueryLnn;
1063 lnnParam->callback.OnComplete = OnCompleteLnn;
1064 lnnParam->dataSize = QUERY_EVENT_FULL_QUERY_PARAM;
1065
1066 HiSysEventQueryParam* transParam = &g_queryStatsParam[SOFTBUS_TRANSPORT_STATS_TYPE];
1067 UpdateSysEventQueryParam(transParam, TRANS_EVENT_NAME);
1068 transParam->callback.OnQuery = OnQueryTrans;
1069 transParam->callback.OnComplete = OnCompleteTrans;
1070 transParam->dataSize = QUERY_EVENT_FULL_QUERY_PARAM;
1071
1072 HiSysEventQueryParam* manageParam = &g_queryAlarmParam[SOFTBUS_MANAGEMENT_ALARM_TYPE];
1073 UpdateSysEventQueryParam(manageParam, MANAGE_ALARM_EVENT_NAME);
1074 manageParam->callback.OnQuery = OnQueryAlarm;
1075 manageParam->callback.OnComplete = OnCompleteAlarm;
1076 manageParam->dataSize = MAX_NUM_OF_EVENT_RESULT;
1077
1078 HiSysEventQueryParam* controlParam = &g_queryAlarmParam[SOFTBUS_CONTROL_ALARM_TYPE];
1079 UpdateSysEventQueryParam(controlParam, CONTROL_ALARM_EVENT_NAME);
1080 controlParam->callback.OnQuery = OnQueryAlarm;
1081 controlParam->callback.OnComplete = OnCompleteAlarm;
1082 controlParam->dataSize = MAX_NUM_OF_EVENT_RESULT;
1083 }
1084
DeinitDumperUtilMutexLock(void)1085 static void DeinitDumperUtilMutexLock(void)
1086 {
1087 SoftBusMutexDestroy(&g_statsQueryLock);
1088 SoftBusMutexDestroy(&g_alarmQueryLock);
1089 SoftBusMutexDestroy(&g_discOnQueryLock);
1090 SoftBusMutexDestroy(&g_connOnQueryLock);
1091 SoftBusMutexDestroy(&g_lnnOnQueryLock);
1092 SoftBusMutexDestroy(&g_transOnQueryLock);
1093 SoftBusMutexDestroy(&g_alarmOnQueryLock);
1094 }
1095
SoftBusHidumperUtilInit(void)1096 int32_t SoftBusHidumperUtilInit(void)
1097 {
1098 if (g_isDumperInit) {
1099 return SOFTBUS_OK;
1100 }
1101 if (InitDumperUtilMutexLock() != SOFTBUS_OK) {
1102 COMM_LOGE(COMM_DFX, "init dump util lock fail");
1103 DeinitDumperUtilMutexLock();
1104 return SOFTBUS_LOCK_ERR;
1105 }
1106
1107 g_alarmEvtResult.records = SoftBusMalloc(sizeof(AlarmRecord) * MAX_NUM_OF_EVENT_RESULT);
1108 if (g_alarmEvtResult.records == NULL) {
1109 COMM_LOGE(COMM_DFX, "init alarm record fail");
1110 DeinitDumperUtilMutexLock();
1111 return SOFTBUS_MALLOC_ERR;
1112 }
1113 InitSoftBusQueryEventParam();
1114 g_isDumperInit = true;
1115 return SOFTBUS_OK;
1116 }
1117
SoftBusHidumperUtilDeInit(void)1118 void SoftBusHidumperUtilDeInit(void)
1119 {
1120 if (!g_isDumperInit) {
1121 return;
1122 }
1123
1124 if (TransMapLock() != SOFTBUS_OK) {
1125 COMM_LOGE(COMM_DFX, "lock TransMap fail");
1126 }
1127 LnnMapDelete(&g_transStatsInfo.sessionNameLinkTypeMap);
1128 TransMapUnlock();
1129 SoftBusMutexDestroy(&g_transMapLock);
1130 g_isTransMapInit = false;
1131
1132 DeinitDumperUtilMutexLock();
1133 SoftBusFree(g_alarmEvtResult.records);
1134 g_isDumperInit = false;
1135 }
1136