1 /*
2 * Copyright (c) 2019-2022, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mos_util_debug.cpp
24 //! \brief Common OS debug across different platform
25 //! \details Common OS debug across different platform
26 //!
27
28 #include "mos_util_debug.h"
29
30 #if MOS_MESSAGES_ENABLED
31 #include "media_user_setting.h"
32
33 //!
34 //! \brief DDI dump file name template
35 //!
36 #define DDILogPathTemplate "%s\\ddi_dump_%d.%s"
37
38 const char * const MosUtilDebug::m_mosLogLevelName[MOS_MESSAGE_LVL_COUNT] = {
39 "", // DISABLED
40 "CRITICAL",
41 "NORMAL ",
42 "VERBOSE ",
43 "ENTER ",
44 "EXIT ",
45 "ENTER ", // ENTER VERBOSE
46 "EXIT ", // EXIT VERBOSE
47 };
48
49 const char * const MosUtilDebug::m_mosComponentName[MOS_COMPONENT_COUNT] = {
50 "[MOS]: ",
51 "[MHW]: ",
52 "[CODEC]:",
53 "[VP]: ",
54 "[CP]: ",
55 MOS_COMPONENT_NAME_DDI_STRING,
56 "[CM]: ",
57 "[CPLIB]:",
58 "[SCAL]: ",
59 "[MMC]: ",
60 "[MCPY]: "
61 };
62
63 const char* MosUtilDebug::m_pcComponentUserFeatureKeys[MOS_COMPONENT_COUNT][3] = {
64 {
65 __MOS_USER_FEATURE_KEY_MESSAGE_OS_TAG,
66 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_OS,
67 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_OS_TAG
68 },
69
70 {
71 __MOS_USER_FEATURE_KEY_MESSAGE_MHW_TAG,
72 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_MHW,
73 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_MHW_TAG
74 },
75
76 {
77 __MOS_USER_FEATURE_KEY_MESSAGE_CODEC_TAG,
78 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_CODEC,
79 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_CODEC_TAG
80 },
81
82 {
83 __MOS_USER_FEATURE_KEY_MESSAGE_VP_TAG,
84 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_VP,
85 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_VP_TAG
86 },
87
88 {
89 __MOS_USER_FEATURE_KEY_MESSAGE_CP_TAG,
90 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_CP,
91 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_CP_TAG
92 },
93
94 {
95 __MOS_USER_FEATURE_KEY_MESSAGE_DDI_TAG,
96 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_DDI,
97 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_DDI_TAG
98 },
99
100 {
101 __MOS_USER_FEATURE_KEY_MESSAGE_CM_TAG,
102 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_CM,
103 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_CM_TAG
104 },
105
106 {// CPLIB
107 __MOS_USER_FEATURE_KEY_MESSAGE_CP_TAG,
108 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_CP,
109 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_CP_TAG
110 },
111
112 {
113 __MOS_USER_FEATURE_KEY_MESSAGE_SCALABILITY_TAG,
114 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_SCALABILITY,
115 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_SCALABILITY_TAG
116 },
117
118 {
119 __MOS_USER_FEATURE_KEY_MESSAGE_MMC_TAG,
120 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_MMC,
121 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_MMC_TAG
122 },
123
124 {
125 __MOS_USER_FEATURE_KEY_MESSAGE_MCPY_TAG,
126 __MOS_USER_FEATURE_KEY_BY_SUB_COMPONENT_MCPY,
127 __MOS_USER_FEATURE_KEY_SUB_COMPONENT_MCPY_TAG
128 }
129 };
130
131 const uint8_t MosUtilDebug::m_subComponentCount[MOS_COMPONENT_COUNT] = {
132 MOS_SUBCOMP_COUNT,
133 MOS_HW_SUBCOMP_COUNT,
134 MOS_CODEC_SUBCOMP_COUNT,
135 MOS_VP_SUBCOMP_COUNT,
136 MOS_CP_SUBCOMP_COUNT,
137 MOS_DDI_SUBCOMP_COUNT,
138 MOS_CM_SUBCOMP_COUNT
139 };
140
141 MOS_MESSAGE_PARAMS MosUtilDebug::m_mosMsgParams = {};
142
MosSetSubCompMessageLevel(MOS_COMPONENT_ID compID,uint8_t subCompID,MOS_MESSAGE_LEVEL msgLevel)143 void MosUtilDebug::MosSetSubCompMessageLevel(MOS_COMPONENT_ID compID, uint8_t subCompID, MOS_MESSAGE_LEVEL msgLevel)
144 {
145 if (compID >= MOS_COMPONENT_COUNT)
146 {
147 MOS_OS_ASSERTMESSAGE("Invalid component %d.", compID);
148 return;
149 }
150
151 if (subCompID >= MOS_MAX_SUBCOMPONENT_COUNT)
152 {
153 MOS_OS_ASSERTMESSAGE("Invalid sub-component %d.", subCompID);
154 return;
155 }
156
157 if (msgLevel >= MOS_MESSAGE_LVL_COUNT)
158 {
159 MOS_OS_ASSERTMESSAGE("Invalid msg level %d.", msgLevel);
160 return;
161 }
162
163 m_mosMsgParams.components[compID].subComponents[subCompID].uiMessageLevel = msgLevel;
164 }
165
MosSetCompMessageLevel(MOS_COMPONENT_ID compID,MOS_MESSAGE_LEVEL msgLevel)166 void MosUtilDebug::MosSetCompMessageLevel(MOS_COMPONENT_ID compID, MOS_MESSAGE_LEVEL msgLevel)
167 {
168 if (compID >= MOS_COMPONENT_COUNT)
169 {
170 MOS_OS_ASSERTMESSAGE("Invalid component %d.", compID);
171 return;
172 }
173
174 if (msgLevel >= MOS_MESSAGE_LVL_COUNT)
175 {
176 MOS_OS_ASSERTMESSAGE("Invalid msg level %d.", msgLevel);
177 return;
178 }
179 m_mosMsgParams.components[compID].component.uiMessageLevel = msgLevel;
180 }
181
MosSetCompMessageLevelAll(MOS_MESSAGE_LEVEL msgLevel)182 void MosUtilDebug::MosSetCompMessageLevelAll(MOS_MESSAGE_LEVEL msgLevel)
183 {
184 if (msgLevel >= MOS_MESSAGE_LVL_COUNT)
185 {
186 MOS_OS_ASSERTMESSAGE("Invalid msg level %d.", msgLevel);
187 return;
188 }
189
190 uint32_t i = 0;
191
192 for(i = 0; i < MOS_COMPONENT_COUNT; i++)
193 {
194 MosSetCompMessageLevel((MOS_COMPONENT_ID)i, msgLevel);
195 }
196 }
197
MosSubCompAssertEnableDisable(MOS_COMPONENT_ID compID,uint8_t subCompID,int32_t bEnable)198 void MosUtilDebug::MosSubCompAssertEnableDisable(MOS_COMPONENT_ID compID, uint8_t subCompID, int32_t bEnable)
199 {
200 if (compID >= MOS_COMPONENT_COUNT)
201 {
202 MOS_OS_ASSERTMESSAGE("Invalid component %d.", compID);
203 return;
204 }
205
206 if (subCompID >= MOS_MAX_SUBCOMPONENT_COUNT)
207 {
208 MOS_OS_ASSERTMESSAGE("Invalid sub-component %d.", subCompID);
209 return;
210 }
211
212 m_mosMsgParams.components[compID].subComponents[subCompID].bAssertEnabled = bEnable;
213 }
214
MosCompAssertEnableDisable(MOS_COMPONENT_ID compID,int32_t bEnable)215 void MosUtilDebug::MosCompAssertEnableDisable(MOS_COMPONENT_ID compID, int32_t bEnable)
216 {
217 if (compID >= MOS_COMPONENT_COUNT)
218 {
219 MOS_OS_ASSERTMESSAGE("Invalid component %d.", compID);
220 return;
221 }
222
223 m_mosMsgParams.components[compID].component.bAssertEnabled = bEnable;
224 }
225
MosMessageInitComponent(MOS_COMPONENT_ID compID,MediaUserSettingSharedPtr userSettingPtr)226 void MosUtilDebug::MosMessageInitComponent(MOS_COMPONENT_ID compID, MediaUserSettingSharedPtr userSettingPtr)
227 {
228 uint32_t uiCompUserFeatureSetting = 0;
229 uint64_t uiSubCompUserFeatureSetting = 0;
230 uint8_t i = 0;
231 const char *messageKey = nullptr;
232 const char *bySubComponentsKey = nullptr;
233 const char *subComponentsKey = nullptr;
234 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
235
236 if (compID >= MOS_COMPONENT_COUNT )
237 {
238 MOS_OS_ASSERTMESSAGE("Invalid component %d.", compID);
239 return;
240 }
241
242 messageKey = m_pcComponentUserFeatureKeys[compID][0];
243 bySubComponentsKey = m_pcComponentUserFeatureKeys[compID][1];
244 subComponentsKey = m_pcComponentUserFeatureKeys[compID][2];
245
246 eStatus = ReadUserSetting(
247 userSettingPtr,
248 uiCompUserFeatureSetting,
249 messageKey,
250 MediaUserSetting::Group::Device);
251 // If the user feature key was not found, create it with the default value.
252 if (eStatus != MOS_STATUS_SUCCESS)
253 {
254 ReportUserSetting(
255 userSettingPtr,
256 messageKey,
257 uiCompUserFeatureSetting,
258 MediaUserSetting::Group::Device);
259 }
260
261 // Extract the 3-bit message level and 1-bit assert flag setting for this component.
262 MosSetCompMessageLevel(compID, (MOS_MESSAGE_LEVEL) (uiCompUserFeatureSetting & 0x7));
263 MosCompAssertEnableDisable(compID, (uiCompUserFeatureSetting >> 3) & 0x1);
264
265 // Check if sub-components should be set seperately.
266 eStatus = ReadUserSetting(
267 userSettingPtr,
268 m_mosMsgParams.components[compID].bBySubComponent,
269 bySubComponentsKey,
270 MediaUserSetting::Group::Device);
271
272 // If the user feature key was not found, create it with default (0) value.
273 if (eStatus != MOS_STATUS_SUCCESS)
274 {
275 ReportUserSetting(
276 userSettingPtr,
277 bySubComponentsKey,
278 m_mosMsgParams.components[compID].bBySubComponent,
279 MediaUserSetting::Group::Device);
280 }
281
282 // Set sub components:
283 if (m_mosMsgParams.components[compID].bBySubComponent)
284 {
285 // Check if sub-components should be set seperately.
286 eStatus = ReadUserSetting(
287 userSettingPtr,
288 uiSubCompUserFeatureSetting,
289 subComponentsKey,
290 MediaUserSetting::Group::Device);
291
292 // If the user feature key was not found, create it with default (0) value.
293 if (eStatus != MOS_STATUS_SUCCESS)
294 {
295 ReportUserSetting(
296 userSettingPtr,
297 subComponentsKey,
298 uiSubCompUserFeatureSetting,
299 MediaUserSetting::Group::Device);
300 }
301
302 for(i = 0; i < m_subComponentCount[compID]; i++)
303 {
304 // Extract the 3-bit message level and 1-bit assert flag setting for each sub-comp
305 // from the user feature key and populate to the MOS message params structure
306 MosSetSubCompMessageLevel(compID, i, (MOS_MESSAGE_LEVEL)(uiSubCompUserFeatureSetting & 0x7));
307 MosSubCompAssertEnableDisable(compID, i, (uiSubCompUserFeatureSetting >> 3) & 0x1);
308
309 uiSubCompUserFeatureSetting = (uiSubCompUserFeatureSetting >> 4);
310 }
311 }
312 }
313
MosHLTInit(MediaUserSettingSharedPtr userSettingPtr)314 MOS_STATUS MosUtilDebug::MosHLTInit(MediaUserSettingSharedPtr userSettingPtr)
315 {
316 uint32_t nPID = 0;
317 char hltFileName[MOS_MAX_HLT_FILENAME_LEN] = {0};
318 char fileNamePrefix[MOS_MAX_HLT_FILENAME_LEN];
319 int32_t bUseHybridLogTrace = false;
320 int32_t bEnableFlush = false;
321 int32_t bEnableMemoryFootPrint = false;
322 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
323
324 if (m_mosMsgParams.uiCounter != 0 )
325 {
326 MOS_OS_NORMALMESSAGE("HLT settings already set.");
327 return MOS_STATUS_UNKNOWN;
328 }
329
330
331 eStatus = ReadUserSetting(
332 userSettingPtr,
333 bEnableFlush,
334 __MOS_USER_FEATURE_KEY_FLUSH_LOG_FILE_BEFORE_SUBMISSION,
335 MediaUserSetting::Group::Device);
336
337
338 ReportUserSetting(
339 userSettingPtr,
340 __MOS_USER_FEATURE_KEY_FLUSH_LOG_FILE_BEFORE_SUBMISSION,
341 bEnableFlush,
342 MediaUserSetting::Group::Device);
343
344 if (!bEnableFlush)
345 {
346 MOS_OS_NORMALMESSAGE("HLT flush is not enabled.");
347 }
348
349 m_mosMsgParams.bUseHybridLogTrace = false;
350 m_mosMsgParams.pLogFile = nullptr;
351 m_mosMsgParams.pTraceFile = nullptr;
352 m_mosMsgParams.bEnableFlush = bEnableFlush;
353
354 // disable memory foot print
355 eStatus = ReadUserSetting(
356 userSettingPtr,
357 bEnableMemoryFootPrint,
358 __MOS_USER_FEATURE_KEY_ENABLE_MEMORY_FOOT_PRINT,
359 MediaUserSetting::Group::Device);
360
361 ReportUserSetting(
362 userSettingPtr,
363 __MOS_USER_FEATURE_KEY_ENABLE_MEMORY_FOOT_PRINT,
364 bEnableMemoryFootPrint,
365 MediaUserSetting::Group::Device);
366
367 if (bEnableMemoryFootPrint)
368 {
369 MOS_OS_NORMALMESSAGE("Mos memory foot print is enabled.");
370 }
371
372 m_mosMsgParams.bEnableMemoryFootPrint = bEnableMemoryFootPrint;
373
374 // Check if HLT should be enabled.
375 eStatus = ReadUserSetting(
376 userSettingPtr,
377 bUseHybridLogTrace,
378 __MOS_USER_FEATURE_KEY_MESSAGE_HLT_ENABLED,
379 MediaUserSetting::Group::Device);
380 // If the user feature key was not found, create it with the default value.
381 if (eStatus != MOS_STATUS_SUCCESS)
382 {
383 ReportUserSetting(
384 userSettingPtr,
385 __MOS_USER_FEATURE_KEY_MESSAGE_HLT_ENABLED,
386 bUseHybridLogTrace,
387 MediaUserSetting::Group::Device);
388 }
389
390 bUseHybridLogTrace = (MosUtilities::m_mosUltFlag && *MosUtilities::m_mosUltFlag) ? 1 : bUseHybridLogTrace;
391
392 // Dumping memory mapped regions to trace file disabled for now
393 // Need to add new user feature key or derive from the above key.
394 m_mosMsgParams.bEnableMaps = 0;
395
396 if (!bUseHybridLogTrace)
397 {
398 MOS_OS_NORMALMESSAGE("HLT not enabled.");
399 return MOS_STATUS_SUCCESS; //[SH]: Check this.
400 }
401
402 nPID = (MosUtilities::m_mosUltFlag && *MosUtilities::m_mosUltFlag) ? 0 : MosUtilities::MosGetPid();
403
404 // Get logfile directory.
405 MosLogFileNamePrefix(fileNamePrefix, userSettingPtr);
406 MosUtilities::MosSecureStringPrint(hltFileName, MOS_MAX_HLT_FILENAME_LEN, MOS_MAX_HLT_FILENAME_LEN - 1, MOS_LOG_PATH_TEMPLATE, fileNamePrefix, nPID, MosUtilities::MosGetCurrentThreadId(), "log");
407
408 #if defined(LINUX) || defined(ANDROID)
409 eStatus = MosUtilities::MosCreateDirectory(fileNamePrefix);
410 if (MOS_FAILED(eStatus))
411 {
412 MOS_OS_NORMALMESSAGE("Failed to create output directory. Status = %d", eStatus);
413 }
414 #endif
415
416 eStatus = MosUtilities::MosSecureFileOpen(&m_mosMsgParams.pLogFile, hltFileName, "w");
417
418 if (MOS_FAILED(eStatus))
419 {
420 MOS_OS_NORMALMESSAGE("Failed to open log file '%s'.", hltFileName);
421 m_mosMsgParams.pLogFile = nullptr;
422 }
423
424 if(m_mosMsgParams.pLogFile == nullptr)
425 {
426 return MOS_STATUS_HLT_INIT_FAILED;
427 }
428
429 // Only if logfile init succeeded, bUseHybridLogTrace is set.
430 m_mosMsgParams.bUseHybridLogTrace = true;
431
432 // Output preface information
433 MosHltpPreface(m_mosMsgParams.pLogFile);
434 MOS_OS_NORMALMESSAGE("HLT initialized successfuly (%s).", hltFileName);
435
436 //[SH]: Trace and log are enabled with the same key right now. This can be changed to enable/disable them independently.
437 MosUtilities::MosSecureStringPrint(hltFileName, MOS_MAX_HLT_FILENAME_LEN, MOS_MAX_HLT_FILENAME_LEN - 1, MOS_LOG_PATH_TEMPLATE, fileNamePrefix, nPID, MosUtilities::MosGetCurrentThreadId(), "hlt");
438
439 eStatus = MosUtilities::MosSecureFileOpen(&m_mosMsgParams.pTraceFile, hltFileName, "w");
440
441 if (MOS_FAILED(eStatus))
442 {
443 MOS_OS_NORMALMESSAGE("Failed to open trace file '%s'.", hltFileName);
444 }
445
446 return MOS_STATUS_SUCCESS;
447 }
448
MosMessageInit(MediaUserSettingSharedPtr userSettingPtr)449 void MosUtilDebug::MosMessageInit(MediaUserSettingSharedPtr userSettingPtr)
450 {
451 uint8_t i = 0;
452 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
453
454 if(m_mosMsgParams.uiCounter == 0) // first time only
455 {
456 eStatus = ReadUserSetting(
457 userSettingPtr,
458 m_mosMsgParams.bDisableAssert,
459 __MOS_USER_FEATURE_KEY_DISABLE_ASSERT,
460 MediaUserSetting::Group::Device);
461 // If the user feature key was not found, create it with default value.
462 if (eStatus != MOS_STATUS_SUCCESS)
463 {
464 ReportUserSetting(
465 userSettingPtr,
466 __MOS_USER_FEATURE_KEY_DISABLE_ASSERT,
467 m_mosMsgParams.bDisableAssert,
468 MediaUserSetting::Group::Device);
469 }
470
471 // Set all sub component messages to critical level by default.
472 MosSetCompMessageLevelAll(MOS_MESSAGE_LVL_CRITICAL);
473
474 // Set print level and asserts for each component
475 for(i = 0; i < MOS_COMPONENT_COUNT; i++)
476 {
477 MosMessageInitComponent((MOS_COMPONENT_ID)i, userSettingPtr);
478 }
479
480 // Check if MOS messages are enabled
481 eStatus = ReadUserSetting(
482 userSettingPtr,
483 m_mosMsgParams.bUseOutputDebugString,
484 __MOS_USER_FEATURE_KEY_MESSAGE_PRINT_ENABLED,
485 MediaUserSetting::Group::Device);
486
487 // If the user feature key was not found, create it with default value.
488 if (eStatus != MOS_STATUS_SUCCESS)
489 {
490 eStatus = ReportUserSetting(
491 userSettingPtr,
492 __MOS_USER_FEATURE_KEY_MESSAGE_PRINT_ENABLED,
493 m_mosMsgParams.bUseOutputDebugString,
494 MediaUserSetting::Group::Device);
495 }
496
497 if (MosUtilities::m_mosUltFlag && (*MosUtilities::m_mosUltFlag))
498 {
499 MosSetCompMessageLevelAll(MOS_MESSAGE_LVL_DISABLED);
500 MosSetCompMessageLevel(MOS_COMPONENT_OS, MOS_MESSAGE_LVL_CRITICAL);
501 MosSetCompMessageLevel(MOS_COMPONENT_VP, MOS_MESSAGE_LVL_CRITICAL);
502 m_mosMsgParams.bUseOutputDebugString = 1;
503 m_mosMsgParams.components[MOS_COMPONENT_OS].bBySubComponent = 0;
504 MosCompAssertEnableDisable(MOS_COMPONENT_CM, 0);
505 MosCompAssertEnableDisable(MOS_COMPONENT_VP, 1);
506 }
507
508 MosHLTInit(userSettingPtr);
509
510 // all above action should not be covered by memninja since its destroy is behind memninja counter report to test result.
511 if (MosUtilities::m_mosMemAllocCounter &&
512 MosUtilities::m_mosMemAllocCounterGfx &&
513 MosUtilities::m_mosMemAllocFakeCounter)
514 {
515 *MosUtilities::m_mosMemAllocCounter = 0;
516 *MosUtilities::m_mosMemAllocFakeCounter = 0;
517 *MosUtilities::m_mosMemAllocCounterGfx = 0;
518 }
519 else
520 {
521 MOS_OS_ASSERTMESSAGE("MemNinja count pointers are nullptr");
522 }
523
524 MOS_OS_VERBOSEMESSAGE("MemNinja leak detection begin");
525 }
526
527 // uiCounter's thread safety depends on global_lock in VPG_Initialize
528 m_mosMsgParams.uiCounter++; // Will be zero initially since it is part of a global structure.
529
530 }
531
MosHLTClose()532 void MosUtilDebug::MosHLTClose()
533 {
534 if(m_mosMsgParams.pTraceFile != nullptr)
535 {
536 fclose(m_mosMsgParams.pTraceFile);
537 m_mosMsgParams.pTraceFile = nullptr;
538
539 MOS_OS_NORMALMESSAGE("Trace file is closed.");
540 }
541
542 if(m_mosMsgParams.pLogFile != nullptr)
543 {
544 MOS_OS_NORMALMESSAGE("Log file is closing, total services %d.",
545 m_mosMsgParams.uiCounter);
546
547 fclose(m_mosMsgParams.pLogFile);
548 m_mosMsgParams.pLogFile = nullptr;
549 }
550 }
551
MosMessageClose()552 void MosUtilDebug::MosMessageClose()
553 {
554 // uiCounter's thread safety depends on global_lock in VPG_Terminate
555 if(m_mosMsgParams.uiCounter == 1)
556 {
557 MosHLTClose();
558 MosUtilities::MosZeroMemory(&m_mosMsgParams, sizeof(MOS_MESSAGE_PARAMS));
559 }
560 else
561 {
562 m_mosMsgParams.uiCounter--;
563 }
564 }
565
MosHLTFlush()566 void MosUtilDebug::MosHLTFlush()
567 {
568 if (!m_mosMsgParams.bEnableFlush)
569 {
570 return;
571 }
572
573 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
574 if (m_mosMsgParams.pLogFile != nullptr)
575 {
576 #if COMMON_DLL_SEPARATION_SUPPORT
577 // Every DLL has its own C Runtime (CRT),
578 // and fflush is not safe across dlls.
579 // When common dll separation is enabled, We should call back into common dll for all DDI dlls.
580 MosUtilities::MosFlushToFileInCommon(m_mosMsgParams.pLogFile);
581 #else
582 fflush(m_mosMsgParams.pLogFile);
583 #endif
584 }
585 if (m_mosMsgParams.pTraceFile != nullptr)
586 {
587 #if COMMON_DLL_SEPARATION_SUPPORT
588 // Every DLL has its own C Runtime (CRT),
589 // and fflush is not safe across dlls.
590 // When common dll separation is enabled, We should call back into common dll for all DDI dlls.
591 MosUtilities::MosFlushToFileInCommon(m_mosMsgParams.pTraceFile);
592 #else
593 fflush(m_mosMsgParams.pTraceFile);
594 #endif
595 }
596 }
597
EnableMemoryFootPrint()598 bool MosUtilDebug::EnableMemoryFootPrint()
599 {
600 return m_mosMsgParams.bEnableMemoryFootPrint;
601 }
602
MosMessage(MOS_MESSAGE_LEVEL level,MOS_COMPONENT_ID compID,uint8_t subCompID,const PCCHAR functionName,int32_t lineNum,const PCCHAR message,...)603 void MosUtilDebug::MosMessage(
604 MOS_MESSAGE_LEVEL level,
605 MOS_COMPONENT_ID compID,
606 uint8_t subCompID,
607 const PCCHAR functionName,
608 int32_t lineNum,
609 const PCCHAR message,
610 ...)
611 {
612 va_list var_args;
613 va_start(var_args, message);
614 MosMessageInternal(level, compID, subCompID, functionName, lineNum, message, var_args);
615 va_end(var_args);
616 return;
617 }
618
MosShouldPrintMessage(MOS_MESSAGE_LEVEL level,MOS_COMPONENT_ID compID,uint8_t subCompID,const char * const message)619 int32_t MosUtilDebug::MosShouldPrintMessage(
620 MOS_MESSAGE_LEVEL level,
621 MOS_COMPONENT_ID compID,
622 uint8_t subCompID,
623 const char * const message)
624 {
625 if (message == nullptr)
626 {
627 return false;
628 }
629
630 if (compID >= MOS_COMPONENT_COUNT ||
631 subCompID >= MOS_MAX_SUBCOMPONENT_COUNT ||
632 level >= MOS_MESSAGE_LVL_COUNT)
633 {
634 MOS_OS_ASSERTMESSAGE("Invalid compoent ID %d, subCompID %d, and msg level %d.", compID, subCompID, level);
635 return false;
636 }
637
638 // If trace is enabled, return true, otherwise continue checking if log is enabled
639 if (MosUtilities::MosShouldTraceEventMsg(level, compID))
640 {
641 return true;
642 }
643
644 // Check if message level set for comp (and if needed for subcomp) is equal or greater than requested level
645 if (m_mosMsgParams.components[compID].component.uiMessageLevel < level)
646 {
647 return false;
648 }
649
650 if (m_mosMsgParams.components[compID].bBySubComponent &&
651 m_mosMsgParams.components[compID].subComponents[subCompID].uiMessageLevel < level)
652 {
653 return false;
654 }
655
656 return true;
657
658 }
659
660 #if MOS_ASSERT_ENABLED
661
MosShouldAssert(MOS_COMPONENT_ID compID,uint8_t subCompID)662 int32_t MosUtilDebug::MosShouldAssert(MOS_COMPONENT_ID compID, uint8_t subCompID)
663 {
664 if (m_mosMsgParams.bDisableAssert)
665 {
666 return false;
667 }
668
669 if (compID >= MOS_COMPONENT_COUNT ||
670 subCompID >= MOS_MAX_SUBCOMPONENT_COUNT)
671 {
672 MOS_OS_ASSERTMESSAGE("Invalid compoent ID %d, subCompID %d", compID, subCompID);
673 return false;
674 }
675
676 if (!m_mosMsgParams.components[compID].component.bAssertEnabled)
677 {
678 return false;
679 }
680
681 if (m_mosMsgParams.components[compID].bBySubComponent &&
682 !m_mosMsgParams.components[compID].subComponents[subCompID].bAssertEnabled)
683 {
684 return false;
685 }
686
687 return true;
688
689 }
690 #endif // MOS_ASSERT_ENABLED
691
692 #endif // MOS_MESSAGES_ENABLED
693