1 /*
2 * Copyright (c) 2023, 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_utilities_inner.cpp
24 //! \brief Common OS service across different platform, mos only
25 //! \details Common OS service across different platform, mos only
26 //!
27
28 #include "mos_os.h"
29
30 bool MosUtilities::m_enableAddressDump = false;
31
MosUtilitiesInit(MediaUserSettingSharedPtr userSettingPtr)32 MOS_STATUS MosUtilities::MosUtilitiesInit(MediaUserSettingSharedPtr userSettingPtr)
33 {
34 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
35 MOS_OS_FUNCTION_ENTER;
36
37 eStatus = MosOsUtilitiesInit(userSettingPtr);
38
39 #if (_DEBUG || _RELEASE_INTERNAL)
40 //Initialize MOS simulate random alloc memorflag
41 #if COMMON_DLL_SEPARATION_SUPPORT
42 MosInitAllocFailSimulateFlagInCommon(userSettingPtr);
43 #else
44 MosInitAllocMemoryFailSimulateFlag(userSettingPtr);
45 #endif
46
47 eStatus = ReadUserSettingForDebug(
48 userSettingPtr,
49 MosUtilities::m_enableAddressDump,
50 "Resource Addr Dump Enable",
51 MediaUserSetting::Group::Device);
52 #endif
53
54 return eStatus;
55 }
56
MosUtilitiesClose(MediaUserSettingSharedPtr userSettingPtr)57 MOS_STATUS MosUtilities::MosUtilitiesClose(MediaUserSettingSharedPtr userSettingPtr)
58 {
59 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
60
61 MOS_OS_FUNCTION_ENTER;
62
63 // MOS_OS_Utilitlies_Close must be called right before end of function
64 // Because Memninja will calc mem leak here.
65 // Any memory allocation release after MosOsUtilitiesClose() will be treated as mem leak.
66 eStatus = MosOsUtilitiesClose(userSettingPtr);
67
68 #if (_DEBUG || _RELEASE_INTERNAL)
69 //Reset Simulate Alloc Memory Fail flags
70 #if COMMON_DLL_SEPARATION_SUPPORT
71 MosInitAllocFailSimulateFlagInCommon(userSettingPtr);
72 #else
73 MosInitAllocMemoryFailSimulateFlag(userSettingPtr);
74 #endif
75 #endif
76
77 return eStatus;
78 }
79
80 /*****************************************************************************
81 |
82 | USER FEATURE Functions
83 |
84 *****************************************************************************/
85
MosUserFeatureOpen(MOS_USER_FEATURE_TYPE KeyType,const char * pSubKey,uint32_t dwAccess,void ** pUFKey,MOS_USER_FEATURE_KEY_PATH_INFO * ufInfo)86 MOS_STATUS MosUtilities::MosUserFeatureOpen(
87 MOS_USER_FEATURE_TYPE KeyType,
88 const char *pSubKey,
89 uint32_t dwAccess,
90 void **pUFKey,
91 MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo)
92 {
93 MOS_STATUS eStatus;
94 void *RootKey = 0;
95
96 MOS_OS_ASSERT(pSubKey);
97 MOS_OS_ASSERT(pUFKey);
98
99 if (KeyType == MOS_USER_FEATURE_TYPE_USER)
100 {
101 RootKey = (void *)UFKEY_INTERNAL;
102 }
103 else if (KeyType == MOS_USER_FEATURE_TYPE_SYSTEM)
104 {
105 RootKey = (void *)UFKEY_EXTERNAL;
106 }
107 else
108 {
109 MOS_OS_ASSERTMESSAGE("Invalid Key Type %d.", KeyType);
110 return MOS_STATUS_UNKNOWN;
111 }
112
113 if ((eStatus = MosUserFeatureOpenKey(
114 RootKey,
115 pSubKey,
116 0,
117 dwAccess,
118 pUFKey,
119 ufInfo)) != MOS_STATUS_SUCCESS)
120 {
121 MOS_OS_NORMALMESSAGE("Unable to open user feature key %s.", pSubKey);
122 }
123
124 return eStatus;
125 }
126
MosUserFeatureEnableNotification(PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,PMOS_USER_FEATURE_NOTIFY_DATA pNotification,MOS_CONTEXT_HANDLE mosCtx)127 MOS_STATUS MosUtilities::MosUserFeatureEnableNotification(
128 PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,
129 PMOS_USER_FEATURE_NOTIFY_DATA pNotification,
130 MOS_CONTEXT_HANDLE mosCtx)
131 {
132 PMOS_USER_FEATURE_NOTIFY_DATA_COMMON pNotifyCommon;
133 int32_t bResult;
134 MOS_STATUS eStatus;
135 MOS_UNUSED(pOsUserFeatureInterface);
136
137 //---------------------------------------
138 MOS_OS_ASSERT(pNotification);
139 MOS_OS_ASSERT(pNotification->NotifyType != MOS_USER_FEATURE_NOTIFY_TYPE_INVALID);
140 MOS_OS_ASSERT(pNotification->pPath);
141 //---------------------------------------
142
143 MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo = Mos_GetDeviceUfPathInfo((PMOS_CONTEXT)mosCtx);
144
145 // Reset the triggered flag
146 pNotification->bTriggered = false;
147
148 if (pNotification->pHandle == nullptr)
149 {
150 // Allocate private data as well
151 pNotification->pHandle = MOS_AllocAndZeroMemory(sizeof(MOS_USER_FEATURE_NOTIFY_DATA));
152 if (pNotification->pHandle == nullptr)
153 {
154 MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
155 return MOS_STATUS_NO_SPACE;
156 }
157 }
158 pNotifyCommon = (PMOS_USER_FEATURE_NOTIFY_DATA_COMMON)pNotification->pHandle;
159
160 // Open User Feature for Reading
161 if (pNotifyCommon->UFKey == 0)
162 {
163 if ((eStatus = MosUserFeatureOpen(
164 pNotification->Type,
165 pNotification->pPath,
166 KEY_READ,
167 &pNotifyCommon->UFKey,
168 ufInfo)) != MOS_STATUS_SUCCESS)
169 {
170 MOS_OS_ASSERTMESSAGE("Failed to open user feature for reading.");
171 return MOS_STATUS_USER_FEATURE_KEY_OPEN_FAILED;
172 }
173 }
174
175 // Create Event for notification
176 if (pNotifyCommon->hEvent == nullptr)
177 {
178 pNotifyCommon->hEvent = MosCreateEventEx(
179 nullptr,
180 nullptr,
181 0);
182 if (pNotifyCommon->hEvent == nullptr)
183 {
184 MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
185 return MOS_STATUS_NO_SPACE;
186 }
187 }
188
189 // Unregister wait event if already registered
190 if (pNotifyCommon->hWaitEvent)
191 {
192 if ((bResult = MosUnregisterWaitEx(pNotifyCommon->hWaitEvent)) == false)
193 {
194 MOS_OS_ASSERTMESSAGE("Unable to unregiser wait event.");
195 return MOS_STATUS_EVENT_WAIT_UNREGISTER_FAILED;
196 }
197 pNotifyCommon->hWaitEvent = nullptr;
198 }
199
200 // Register a Callback
201 if ((eStatus = MosUserFeatureNotifyChangeKeyValue(
202 pNotifyCommon->UFKey,
203 false,
204 pNotifyCommon->hEvent,
205 true)) != MOS_STATUS_SUCCESS)
206 {
207 MOS_OS_ASSERTMESSAGE("Unable to setup user feature key notification.");
208 return MOS_STATUS_UNKNOWN;
209 }
210
211 // Create a wait object
212 if ((bResult = MosUserFeatureWaitForSingleObject(
213 &pNotifyCommon->hWaitEvent,
214 pNotifyCommon->hEvent,
215 (void *)MosUserFeatureCallback,
216 pNotification)) == false)
217 {
218 MOS_OS_ASSERTMESSAGE("Failed to create a wait object.");
219 return MOS_STATUS_EVENT_WAIT_REGISTER_FAILED;
220 }
221
222 return MOS_STATUS_SUCCESS;
223 }
224
MosUserFeatureDisableNotification(PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,PMOS_USER_FEATURE_NOTIFY_DATA pNotification)225 MOS_STATUS MosUtilities::MosUserFeatureDisableNotification(
226 PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,
227 PMOS_USER_FEATURE_NOTIFY_DATA pNotification)
228 {
229 PMOS_USER_FEATURE_NOTIFY_DATA_COMMON pNotifyDataCommon;
230 int32_t bResult;
231 MOS_STATUS eStatus;
232 MOS_UNUSED(pOsUserFeatureInterface);
233
234 //---------------------------------------
235 MOS_OS_ASSERT(pNotification);
236 //---------------------------------------
237
238 if (pNotification->pHandle)
239 {
240 pNotifyDataCommon = (PMOS_USER_FEATURE_NOTIFY_DATA_COMMON)
241 pNotification->pHandle;
242
243 if (pNotifyDataCommon->hWaitEvent)
244 {
245 if ((bResult = MosUnregisterWaitEx(pNotifyDataCommon->hWaitEvent)) == false)
246 {
247 MOS_OS_ASSERTMESSAGE("Unable to unregiser wait event.");
248 return MOS_STATUS_EVENT_WAIT_UNREGISTER_FAILED;
249 }
250 }
251 if (pNotifyDataCommon->UFKey)
252 {
253 if ((eStatus = MosUserFeatureCloseKey(pNotifyDataCommon->UFKey)) != MOS_STATUS_SUCCESS)
254 {
255 MOS_OS_ASSERTMESSAGE("User feature key close failed.");
256 return eStatus;
257 }
258 }
259 if (pNotifyDataCommon->hEvent)
260 {
261 MosCloseHandle(pNotifyDataCommon->hEvent);
262 }
263
264 // Free Notify Data Memory
265 MOS_FreeMemory(pNotifyDataCommon);
266 pNotification->pHandle = nullptr;
267 }
268 return MOS_STATUS_SUCCESS;
269 }
270
GetRegAccessDataType(MOS_USER_FEATURE_VALUE_TYPE type)271 const uint32_t MosUtilities::GetRegAccessDataType(MOS_USER_FEATURE_VALUE_TYPE type)
272 {
273 switch (type)
274 {
275 case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
276 case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
277 case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
278 case MOS_USER_FEATURE_VALUE_TYPE_INT32:
279 return UF_DWORD;
280 case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
281 case MOS_USER_FEATURE_VALUE_TYPE_INT64:
282 return UF_QWORD;
283 case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
284 case MOS_USER_FEATURE_VALUE_TYPE_STRING:
285 return UF_SZ;
286 default:
287 return UF_NONE;
288 }
289 }
290
StrToMediaUserSettingValue(std::string & strValue,MOS_USER_FEATURE_VALUE_TYPE type,MediaUserSetting::Value & dstValue)291 MOS_STATUS MosUtilities::StrToMediaUserSettingValue(
292 std::string &strValue,
293 MOS_USER_FEATURE_VALUE_TYPE type,
294 MediaUserSetting::Value &dstValue)
295 {
296 uint32_t base = 10;
297 if (strValue.size() > 2 && strValue.at(0) == '0' && (strValue.at(0) == 'x' || strValue.at(0) == 'X')) // 0x or 0X
298 {
299 base = 16;
300 }
301 switch (type)
302 {
303 case MOS_USER_FEATURE_VALUE_TYPE_BOOL: {
304 bool value = (std::stoul(strValue, nullptr, base) != 0) ? true : false;
305 dstValue = value;
306 break;
307 }
308 case MOS_USER_FEATURE_VALUE_TYPE_FLOAT: {
309 float value = std::stof(strValue, nullptr);
310 dstValue = value;
311 break;
312 }
313 case MOS_USER_FEATURE_VALUE_TYPE_UINT32: {
314 uint32_t value = std::stoul(strValue, nullptr, base);
315 dstValue = value;
316 break;
317 }
318 case MOS_USER_FEATURE_VALUE_TYPE_INT32: {
319 int32_t value = std::stoi(strValue, nullptr, base);
320 dstValue = value;
321 break;
322 }
323 case MOS_USER_FEATURE_VALUE_TYPE_UINT64: {
324 uint64_t value = std::stoull(strValue, nullptr, base);
325 dstValue = value;
326 break;
327 }
328 case MOS_USER_FEATURE_VALUE_TYPE_INT64: {
329 int64_t value = std::stoll(strValue, nullptr, base);
330 dstValue = value;
331 break;
332 }
333 case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
334 case MOS_USER_FEATURE_VALUE_TYPE_STRING: {
335 dstValue = strValue;
336 break;
337 }
338 default:
339 MOS_OS_NORMALMESSAGE("Invalid data type");
340 return MOS_STATUS_UNKNOWN;
341 }
342 return MOS_STATUS_SUCCESS;
343 }
344
DataToMediaUserSettingValue(uint8_t * data,size_t dataSize,MediaUserSetting::Value & dstValue,MOS_USER_FEATURE_VALUE_TYPE type)345 MOS_STATUS MosUtilities::DataToMediaUserSettingValue(
346 uint8_t *data,
347 size_t dataSize,
348 MediaUserSetting::Value &dstValue,
349 MOS_USER_FEATURE_VALUE_TYPE type)
350 {
351 MOS_STATUS status = MOS_STATUS_SUCCESS;
352 MOS_OS_CHK_NULL_RETURN(data);
353
354 auto sizeIsValid = [&](size_t requiredSize) -> bool {
355 if (requiredSize > dataSize)
356 {
357 status = MOS_STATUS_INVALID_PARAMETER;
358 return false;
359 }
360 return true;
361 };
362
363 switch (type)
364 {
365 case MOS_USER_FEATURE_VALUE_TYPE_BOOL: {
366 if (sizeIsValid(sizeof(uint8_t)))
367 {
368 dstValue = (*data > 0) ? true : false;
369 }
370 break;
371 }
372 case MOS_USER_FEATURE_VALUE_TYPE_FLOAT: {
373 if (sizeIsValid(sizeof(float)))
374 {
375 dstValue = *((float *)data);
376 }
377 break;
378 }
379 case MOS_USER_FEATURE_VALUE_TYPE_UINT32: {
380 if (sizeIsValid(sizeof(uint32_t)))
381 {
382 dstValue = *((uint32_t *)data);
383 }
384 break;
385 }
386 case MOS_USER_FEATURE_VALUE_TYPE_INT32: {
387 if (sizeIsValid(sizeof(int32_t)))
388 {
389 dstValue = *((int32_t *)data);
390 }
391 break;
392 }
393 case MOS_USER_FEATURE_VALUE_TYPE_UINT64: {
394 if (sizeIsValid(sizeof(uint64_t)))
395 {
396 dstValue = *((uint64_t *)data);
397 }
398 break;
399 }
400 case MOS_USER_FEATURE_VALUE_TYPE_INT64: {
401 if (sizeIsValid(sizeof(int64_t)))
402 {
403 dstValue = *((int64_t *)data);
404 }
405 break;
406 }
407 default:
408 MOS_OS_NORMALMESSAGE("Invalid data type");
409 return MOS_STATUS_UNKNOWN;
410 }
411 return status;
412 }
413
414 /*****************************************************************************
415 |
416 | Export Functions
417 |
418 *****************************************************************************/
MosSetUltFlag(uint8_t ultFlag)419 MOS_FUNC_EXPORT void MosUtilities::MosSetUltFlag(uint8_t ultFlag)
420 {
421 if (MosUtilities::m_mosUltFlag != nullptr)
422 {
423 *MosUtilities::m_mosUltFlag = ultFlag;
424 }
425 }
MosGetMemNinjaCounter()426 MOS_FUNC_EXPORT int32_t MosUtilities::MosGetMemNinjaCounter()
427 {
428 return m_mosMemAllocCounterNoUserFeature;
429 }
430
MosGetMemNinjaCounterGfx()431 MOS_FUNC_EXPORT int32_t MosUtilities::MosGetMemNinjaCounterGfx()
432 {
433 return m_mosMemAllocCounterNoUserFeatureGfx;
434 }
435
436 #ifdef __cplusplus
437 extern "C" {
438 #endif
439
MOS_GetMemNinjaCounter()440 MOS_FUNC_EXPORT int32_t MOS_GetMemNinjaCounter()
441 {
442 return MosUtilities::MosGetMemNinjaCounter();
443 }
444
MOS_GetMemNinjaCounterGfx()445 MOS_FUNC_EXPORT int32_t MOS_GetMemNinjaCounterGfx()
446 {
447 return MosUtilities::MosGetMemNinjaCounterGfx();
448 }
449
MOS_SetUltFlag(uint8_t ultFlag)450 MOS_FUNC_EXPORT void MOS_SetUltFlag(uint8_t ultFlag)
451 {
452 MosUtilities::MosSetUltFlag(ultFlag);
453 }
454
455 #ifdef __cplusplus
456 }
457 #endif