/* * Copyright (c) 2021, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ //! //! \file mos_oca_specific.cpp //! \brief Linux specfic OCA class //! #include "mos_os.h" #include "mos_os_specific.h" #include "mos_oca_interface_specific.h" #include "mos_util_debug.h" #include "mos_utilities.h" #include //! //! \def MOS_OCA_CHK_NULL_RETURN(_ptr) //! Check if _ptr == nullptr. If so, assert, return an error and update LastErrorStatus. //! Should only be used by interface functions in MosOcaInterface. //! #define MOS_OCA_CHK_NULL_RETURN(mosCtx, _ptr, func, line) \ { \ if ((_ptr) == nullptr) \ { \ MosOcaInterfaceSpecific::OnOcaError(mosCtx, MOS_STATUS_NULL_POINTER, func, line); \ return MOS_STATUS_NULL_POINTER; \ } \ } //! //! \def MOS_OCA_CHK_STATUS_RETURN(_stmt) //! Check if MOS_STATUS_SUCCESS != _stmt. If so, assert, return an error and update LastErrorStatus. //! Should only be used by interface functions in MosOcaInterface. //! #define MOS_OCA_CHK_STATUS_RETURN(mosCtx, _stmt, func, line) \ { \ MOS_STATUS stmtStatus = (MOS_STATUS)(_stmt); \ if (stmtStatus != MOS_STATUS_SUCCESS) \ { \ MosOcaInterfaceSpecific::OnOcaError(mosCtx, stmtStatus, func, line); \ return stmtStatus; \ } \ } /****************************************************************************************************/ /* MosOcaInterfaceSpecific */ /****************************************************************************************************/ MOS_STATUS MosOcaInterfaceSpecific::s_ocaStatus = MOS_STATUS_SUCCESS; uint32_t MosOcaInterfaceSpecific::s_lineNumForOcaErr = 0; bool MosOcaInterfaceSpecific::s_bOcaStatusExistInReg = false; int32_t MosOcaInterfaceSpecific::s_refCount = 0; bool MosOcaInterfaceSpecific::s_isDestroyed = false; //! //! \brief Get the idle oca buffer, which is neither used by hw nor locked, and lock it for edit. //! \param [in] pMosContext //! pointer to MOS_INTERFACE //! \param [in] CurrentGpuContextHandle //! Gpu context handle //! \return MOS_OCA_BUFFER_HANDLE //! return the handle for oca buffer //! MOS_OCA_BUFFER_HANDLE MosOcaInterfaceSpecific::LockOcaBufAvailable(PMOS_CONTEXT pMosContext, uint32_t CurrentGpuContextHandle) { if (nullptr == m_ocaMutex) { MosOcaInterfaceSpecific::OnOcaError(pMosContext, MOS_STATUS_NULL_POINTER, __FUNCTION__, __LINE__); return MOS_OCA_INVALID_BUFFER_HANDLE; } MosOcaAutoLock autoLock(m_ocaMutex); for (int i = m_indexOfNextOcaBufContext; i < MAX_NUM_OF_OCA_BUF_CONTEXT; ++i) { if (m_ocaBufContextList[i].inUse) { continue; } m_ocaBufContextList[i].inUse = true; m_ocaBufContextList[i].logSection.resInfo.maxResInfoCount = m_config.maxResInfoCount; m_ocaBufContextList[i].logSection.resInfo.maxBufferResInfoCount = m_config.maxBufferResInfoCount; m_indexOfNextOcaBufContext = (i + 1) % MAX_NUM_OF_OCA_BUF_CONTEXT; return i; } for (int i = 0; i < m_indexOfNextOcaBufContext; ++i) { if (m_ocaBufContextList[i].inUse) { continue; } m_ocaBufContextList[i].inUse = true; m_ocaBufContextList[i].logSection.resInfo.maxResInfoCount = m_config.maxResInfoCount; m_ocaBufContextList[i].logSection.resInfo.maxBufferResInfoCount = m_config.maxBufferResInfoCount; m_indexOfNextOcaBufContext = (i + 1) % MAX_NUM_OF_OCA_BUF_CONTEXT; return i; } MosOcaInterfaceSpecific::OnOcaError(pMosContext, MOS_STATUS_INVALID_PARAMETER, __FUNCTION__, __LINE__); return MOS_OCA_INVALID_BUFFER_HANDLE; } //! //! \brief Unlock the oca buffer when edit complete. //! \param [in] ocaBufHandle //! Oca buffer handle. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS MosOcaInterfaceSpecific::UnlockOcaBuf(MOS_OCA_BUFFER_HANDLE ocaBufHandle) { if (ocaBufHandle >= MAX_NUM_OF_OCA_BUF_CONTEXT) { return MOS_STATUS_INVALID_PARAMETER; } m_ocaBufContextList[ocaBufHandle].logSection.offset = 0; m_ocaBufContextList[ocaBufHandle].logSection.base = nullptr; m_ocaBufContextList[ocaBufHandle].inUse = false; m_ocaBufContextList[ocaBufHandle].is1stLevelBBStarted = false; return MOS_STATUS_SUCCESS; } MOS_STATUS MosOcaInterfaceSpecific::UnlockOcaBufferWithDelay(MOS_OCA_BUFFER_HANDLE ocaBufHandle) { if (ocaBufHandle >= MAX_NUM_OF_OCA_BUF_CONTEXT) { return MOS_STATUS_INVALID_PARAMETER; } MosOcaAutoLock lock(m_mutexForOcaBufPool); m_PendingOcaBuffersToUnlock.push_back(ocaBufHandle); return MOS_STATUS_SUCCESS; } void MosOcaInterfaceSpecific::UnlockPendingOcaBuffers(PMOS_CONTEXT mosCtx, struct MOS_OCA_EXEC_LIST_INFO *info, int count) { MosOcaAutoLock lock(m_mutexForOcaBufPool); if(m_PendingOcaBuffersToUnlock.size() > 1) { MOS_OS_NORMALMESSAGE("size of pending oca buffer > 1"); } for (auto it = m_PendingOcaBuffersToUnlock.begin(); it != m_PendingOcaBuffersToUnlock.end(); ++it) { // Other information to log section, which is only captured after BB end, can be added here. if(mosCtx != nullptr && info != nullptr && count > 0) { AddExecListInfoToLogSection(*it, mosCtx, info, count); } UnlockOcaBuf(*it); } m_PendingOcaBuffersToUnlock.clear(); } //! //! \brief Oca operation which should be called at the beginning of 1st level batch buffer start. //! \param [out] gpuVaOcaBuffer //! The gfx virtual address of oca buffer, which should be set to GPR11 by LRI at the //! beginning of 1st level batch buffer no matter return value is MOS_STATUS_SUCCESS or not. //! \param [in] ocaBufHandle //! Oca buffer handle. //! \param [in] pMosContext //! Pointer to MOS_CONTEXT. //! \param [in] pMosResource //! Pointer to the MOS_RESOURCE. //! \param [in] offsetOf1stLevelBB //! Offset for current BB in pMosResource. //! \param [in] bUseSizeOfResource //! If true, use size of pMosResource for batch buffer, else use sizeOf1stLevelBB. //! \param [in] sizeOf1stLevelBB //! Size of BB. Ignore if bUseSizeOfResource == true. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS MosOcaInterfaceSpecific::On1stLevelBBStart(uint64_t &gpuVaOcaBuffer, MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT pMosContext, void *pMosResource, uint32_t offsetOf1stLevelBB, bool bUseSizeOfResource, uint32_t sizeOf1stLevelBB) { // The GPR11 need to be reset to 0 to disable UMD_OCA for current workload if any error happened. gpuVaOcaBuffer = 0; if (!m_isOcaEnabled) { return MOS_STATUS_SUCCESS; } PMOS_RESOURCE pOsResource = (PMOS_RESOURCE)pMosResource; if (ocaBufHandle >= MAX_NUM_OF_OCA_BUF_CONTEXT) { MosOcaInterfaceSpecific::OnOcaError(pMosContext, MOS_STATUS_INVALID_PARAMETER, __FUNCTION__, __LINE__); return MOS_STATUS_INVALID_PARAMETER; } m_ocaBufContextList[ocaBufHandle].is1stLevelBBStarted = true; InitLogSection(ocaBufHandle, pOsResource); return MOS_STATUS_SUCCESS; } //! //! \brief Oca operation which should be called before adding batch buffer end command for 1st //! level batch buffer. //! \param [in] ocaBufHandle //! Oca buffer handle. //! \param [in] mosCtx //! DDI device context. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS MosOcaInterfaceSpecific::On1stLevelBBEnd(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT mosCtx) { if (!m_isOcaEnabled) { return MOS_STATUS_SUCCESS; } if (ocaBufHandle >= MAX_NUM_OF_OCA_BUF_CONTEXT) { MosOcaInterfaceSpecific::OnOcaError(mosCtx, MOS_STATUS_INVALID_PARAMETER, __FUNCTION__, __LINE__); return MOS_STATUS_INVALID_PARAMETER; } if (!m_ocaBufContextList[ocaBufHandle].is1stLevelBBStarted) { MOS_OS_ASSERTMESSAGE("On1stLevelBBEnd is called without On1stLevelBBStart being called!"); return MOS_STATUS_INVALID_PARAMETER; } AddResourceInfoToLogSection(ocaBufHandle, mosCtx); return MOS_STATUS_SUCCESS; } //! //! \brief Oca operation which should be called before sending start sub level batch buffer command. //! \param [in] ocaBufHandle //! Oca buffer handle. //! \param [in] pMosContext //! Pointer to MOS_CONTEXT. //! \param [in] pMosResource //! Pointer to the MOS_RESOURCE. //! \param [in] offsetOfSubLevelBB //! Offset for current BB in pMosResource. //! \param [in] bUseSizeOfResource //! If true, use size of pMosResource for batch buffer, else use sizeOfSubLevelBB. //! \param [in] sizeOfSubLevelBB //! Size of BB. Ignore if bUseSizeOfResource == true. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS MosOcaInterfaceSpecific::OnSubLevelBBStart(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT pMosContext, void *pMosResource, uint32_t offsetOfSubLevelBB, bool bUseSizeOfResource, uint32_t sizeOfSubLevelBB) { return MOS_STATUS_UNIMPLEMENTED; } //! //! \brief Oca operation which should be called when indirect states being added. //! \param [in] ocaBufHandle //! Oca buffer handle. //! \param [in] pMosContext //! Pointer to MOS_CONTEXT. //! \param [in] pMosResource //! Pointer to the MOS_RESOURCE. //! \param [in] offsetOfIndirectState //! Offset for current state in pMosResource. //! \param [in] bUseSizeOfResource //! If true, use size of pMosResource for indirect state, else use sizeOfIndirectState. //! \param [in] sizeOfIndirectState //! Size of indirect state. Ignore if bUseSizeOfResource == true. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS MosOcaInterfaceSpecific::OnIndirectState(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT pMosContext, void *pMosResource, uint32_t offsetOfIndirectState, bool bUseSizeOfResource, uint32_t sizeOfIndirectState) { return MOS_STATUS_UNIMPLEMENTED; } //! //! \brief Oca operation which should be called before adding dispatch states, //! e.g. VEB_DI_IECP_STATE and MEDIA_OBJECT_WALKER. //! \param [out] offsetInIndirectStateHeap //! The start offset of current dispatch in indirect state heap, which should be set to low 32 bits //! of GPR12 by LRI before dispatch commands being added. //! OCA_HEAP_INVALID_OFFSET means no need to configure GPR12, otherwise the register need be configured //! no matter return value being MOS_STATUS_SUCCESS or not. //! \param [in] ocaBufHandle //! Oca buffer handle. //! \param [in] mosCtx //! DDI device context. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS MosOcaInterfaceSpecific::OnDispatch(uint32_t &offsetInIndirectStateHeap, MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT mosCtx) { return MOS_STATUS_UNIMPLEMENTED; } //! //! \brief Add string to oca log section //! \param [in] ocaBufHandle //! Oca buffer handle. //! \param [in] mosCtx //! DDI device context. //! \param [in] str //! string to be added. //! \param [in] maxCount //! size of the buffer pointed by str. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS MosOcaInterfaceSpecific::TraceMessage(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT mosCtx, const char *str, uint32_t maxCount) { if (!m_isOcaEnabled) { return MOS_STATUS_SUCCESS; } if (nullptr == str || maxCount <= 0 || maxCount > MOS_OCA_MAX_STRING_LEN) { return MOS_STATUS_INVALID_PARAMETER; } if (!IsLogSectionEnabled(ocaBufHandle)) { return MOS_STATUS_SUCCESS; } uint32_t len = strnlen(str, maxCount); MOS_OCA_LOG_HEADER header = {MOS_OCA_LOG_TYPE_STRING, sizeof(MOS_OCA_LOG_HEADER), len}; return DumpDataBlock(ocaBufHandle, &header, (void *)str); } //! //! \brief Add resource to dump list. //! \param [in] ocaBufHandle //! Oca buffer handle. //! \param [in] mosCtx //! DDI device context. //! \param [in] resource //! Reference to MOS_RESOURCE. //! \param [in] hwCmdType //! Hw command Type. //! \param [in] locationInCmd //! Location in command. //! \param [in] offsetInRes //! Offset in resource. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS MosOcaInterfaceSpecific::AddResourceToDumpList(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT mosCtx, MOS_RESOURCE &resource, MOS_HW_COMMAND hwCmdType, uint32_t locationInCmd, uint32_t offsetInRes) { uint32_t i = 0; MOS_MEMCOMP_STATE resMmcMode = {}; if (!m_isOcaEnabled || !m_isInitialized) { return MOS_STATUS_SUCCESS; } if (!m_ocaBufContextList[ocaBufHandle].is1stLevelBBStarted) { MOS_OS_ASSERTMESSAGE("AddResourceToDumpList is called before oca buffer initialized!"); MosOcaInterfaceSpecific::OnOcaError(mosCtx, MOS_STATUS_UNINITIALIZED, __FUNCTION__, __LINE__); return MOS_STATUS_UNINITIALIZED; } if (nullptr == m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList) { MOS_OS_NORMALMESSAGE("OCA resource info dump not enabled."); return MOS_STATUS_SUCCESS; } if (nullptr == resource.pGmmResInfo || Mos_ResourceIsNull(&resource)) { return MOS_STATUS_SUCCESS; } if (hwCmdType >= MOS_HW_COMMAND_MAX || MOS_HW_COMMAND_MAX > 64) { MosOcaInterfaceSpecific::OnOcaError(mosCtx, MOS_STATUS_UNINITIALIZED, __FUNCTION__, __LINE__); return MOS_STATUS_INVALID_PARAMETER; } for (i = 0; i < m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCount; ++i) { if (m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].allocationHandle == resource.bo->handle) { if (offsetInRes > m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].offsetInRes) { // Only update resource info for the largest offsetInRes case. m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].hwCmdType = (uint32_t)hwCmdType; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].offsetInRes = offsetInRes; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].locationInCmd = locationInCmd; } return MOS_STATUS_SUCCESS; } } if (m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCount >= m_ocaBufContextList[ocaBufHandle].logSection.resInfo.maxResInfoCount) { // Not reture error but record the resource count skipped. ++m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCountSkipped; MOS_OS_NORMALMESSAGE("The resource is skipped to be dumpped to oca buffer."); return MOS_STATUS_SUCCESS; } MosStreamState steamState = {}; steamState.osDeviceContext = mosCtx->m_osDeviceContext; if (MOS_FAILED(MosInterface::GetMemoryCompressionMode(&steamState, &resource, resMmcMode))) { resMmcMode = MOS_MEMCOMP_DISABLED; } m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].gfxAddress = resource.bo->offset64; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].sizeAllocation = resource.pGmmResInfo->GetSizeAllocation(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].sizeSurface = resource.pGmmResInfo->GetSizeSurface(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].sizeSurfacePhy = resource.pGmmResInfo->GetSizeSurface(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].sizeMainSurface = resource.pGmmResInfo->GetSizeMainSurface(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].allocationHandle = resource.bo->handle; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].hwCmdType = (uint32_t)hwCmdType; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].locationInCmd = locationInCmd; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].offsetInRes = offsetInRes; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].pitch = (uint32_t)resource.pGmmResInfo->GetRenderPitch(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].width = (uint32_t)resource.pGmmResInfo->GetBaseWidth(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].height = (uint32_t)resource.pGmmResInfo->GetBaseHeight(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].format = (uint32_t)resource.Format; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].gmmFormat = (uint32_t)resource.pGmmResInfo->GetResourceFormat(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].gmmTileMode = (uint32_t)resource.pGmmResInfo->GmmGetTileMode(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].gmmClient = (uint32_t)resource.pGmmResInfo->GetClientType(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].gmmResUsageType = (uint32_t)resource.pGmmResInfo->GetCachePolicyUsage(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].mmcMode = (uint32_t)resMmcMode; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].mmcHint = (uint32_t)resource.pGmmResInfo->GetMmcHint(0); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].auxYOffset = resource.pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_Y_CCS); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].auxUVOffset = resource.pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_UV_CCS); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].auxCCSOffset = resource.pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].auxCCOffset = resource.pGmmResInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CC); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].flags.isLocalOnly = resource.pGmmResInfo->GetResFlags().Info.LocalOnly; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].flags.isNonLocalOnly = resource.pGmmResInfo->GetResFlags().Info.NonLocalOnly; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].flags.isNotLockable = resource.pGmmResInfo->GetResFlags().Info.NotLockable; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].flags.isShared = resource.pGmmResInfo->GetResFlags().Info.Shared; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].flags.isCameraCapture = resource.pGmmResInfo->GetResFlags().Gpu.CameraCapture; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList[i].flags.isRenderTarget = resource.pGmmResInfo->GetResFlags().Gpu.RenderTarget; ++m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCount; return MOS_STATUS_SUCCESS; } //! //! \brief Add buffer resource to dump list. //! \param [in] ocaBufHandle //! Oca buffer handle. //! \param [in] mosCtx //! DDI device context. //! \param [in] resource //! Reference to MOS_RESOURCE. //! \param [in] hwCmdType //! Hw command Type. //! \param [in] locationInCmd //! Location in command. //! \param [in] offsetInRes //! Offset in resource. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS MosOcaInterfaceSpecific::AddBufferResourceToDumpList(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT mosCtx, MOS_RESOURCE &resource, MOS_HW_COMMAND hwCmdType, uint32_t locationInCmd, uint32_t offsetInRes) { uint32_t i = 0; if (!m_isOcaEnabled || !m_isInitialized) { return MOS_STATUS_SUCCESS; } if (!m_ocaBufContextList[ocaBufHandle].is1stLevelBBStarted) { MOS_OS_ASSERTMESSAGE("AddBufferResourceToDumpList is called before oca buffer initialized!"); MosOcaInterfaceSpecific::OnOcaError(mosCtx, MOS_STATUS_UNINITIALIZED, __FUNCTION__, __LINE__); return MOS_STATUS_UNINITIALIZED; } if (nullptr == m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList) { MOS_OS_NORMALMESSAGE("OCA resource info dump not enabled."); return MOS_STATUS_SUCCESS; } if (nullptr == resource.pGmmResInfo || Mos_ResourceIsNull(&resource)) { return MOS_STATUS_SUCCESS; } if (hwCmdType >= MOS_HW_COMMAND_MAX || MOS_HW_COMMAND_MAX > 64) { MosOcaInterfaceSpecific::OnOcaError(mosCtx, MOS_STATUS_UNINITIALIZED, __FUNCTION__, __LINE__); return MOS_STATUS_INVALID_PARAMETER; } for (i = 0; i < m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResCount; ++i) { if (m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].allocationHandle == resource.bo->handle) { m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].hwCmdType = (uint32_t)hwCmdType; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].locationInCmd = locationInCmd; return MOS_STATUS_SUCCESS; } } if (m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResCount >= m_ocaBufContextList[ocaBufHandle].logSection.resInfo.maxBufferResInfoCount) { // Not reture error but record the resource count skipped. ++m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCountSkipped; MOS_OS_NORMALMESSAGE("The resource is skipped to be dumpped to oca buffer."); return MOS_STATUS_SUCCESS; } m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].gfxAddress = resource.bo->offset64; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].sizeAllocation = resource.pGmmResInfo->GetSizeAllocation(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].allocationHandle = resource.bo->handle; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].hwCmdType = (uint32_t)hwCmdType; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].locationInCmd = locationInCmd; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].size = (uint32_t)resource.pGmmResInfo->GetBaseWidth(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].gmmFormat = (uint32_t)resource.pGmmResInfo->GetResourceFormat(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].gmmResUsageType = (uint32_t)resource.pGmmResInfo->GetCachePolicyUsage(); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].flags.isLocalOnly = resource.pGmmResInfo->GetResFlags().Info.LocalOnly; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].flags.isNonLocalOnly = resource.pGmmResInfo->GetResFlags().Info.NonLocalOnly; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].flags.isNotLockable = resource.pGmmResInfo->GetResFlags().Info.NotLockable; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList[i].flags.isRenderTarget = resource.pGmmResInfo->GetResFlags().Gpu.RenderTarget; ++m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResCount; return MOS_STATUS_SUCCESS; } void MosOcaInterfaceSpecific::AddResourceInfoToLogSection(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT mosCtx) { if (!m_ocaBufContextList[ocaBufHandle].is1stLevelBBStarted) { return; } if (0 == m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCount) { return; } if (!IsLogSectionEnabled(ocaBufHandle)) { return; } MOS_OCA_LOG_HEADER_RESOURCE_INFO header = {}; header.header.type = MOS_OCA_LOG_TYPE_RESOURCE_INFO; header.header.headerSize = sizeof(MOS_OCA_LOG_HEADER_RESOURCE_INFO); header.header.dataSize = m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCount * sizeof(MOS_OCA_RESOURCE_INFO); header.resCount = m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCount; header.resCountSkipped = m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCountSkipped; MOS_STATUS status = DumpDataBlock(ocaBufHandle, (PMOS_OCA_LOG_HEADER)&header, m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resInfoList); if (MOS_FAILED(status)) { MosOcaInterfaceSpecific::OnOcaError(mosCtx, status, __FUNCTION__, __LINE__); } m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCount = 0; if (m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResCount > 0) { header = {}; header.header.type = MOS_OCA_LOG_TYPE_BUFFER_RESOURCE_INFO; header.header.headerSize = sizeof(MOS_OCA_LOG_HEADER_RESOURCE_INFO); header.header.dataSize = m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResCount * sizeof(MOS_OCA_BUFFER_RESOURCE_INFO); header.resCount = m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResCount; header.resCountSkipped = m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCountSkipped; status = DumpDataBlock(ocaBufHandle, (PMOS_OCA_LOG_HEADER)&header, m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResInfoList); if (MOS_FAILED(status)) { MosOcaInterfaceSpecific::OnOcaError(mosCtx, status, __FUNCTION__, __LINE__); } m_ocaBufContextList[ocaBufHandle].logSection.resInfo.bufferResCount = 0; } m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCountSkipped = 0; return; } void MosOcaInterfaceSpecific::AddExecListInfoToLogSection(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT mosCtx, struct MOS_OCA_EXEC_LIST_INFO *info, int count) { if (!m_ocaBufContextList[ocaBufHandle].is1stLevelBBStarted) { return; } if (info == nullptr || 0 == count) { return; } if (!IsLogSectionEnabled(ocaBufHandle)) { return; } MOS_OCA_LOG_HEADER_EXEC_LIST_INFO header = {}; header.header.type = MOS_OCA_LOG_TYPE_EXEC_LIST_INFO; header.header.headerSize = sizeof(MOS_OCA_LOG_HEADER_EXEC_LIST_INFO); header.header.dataSize = count * sizeof(struct MOS_OCA_EXEC_LIST_INFO); header.count = count; MOS_STATUS status = DumpDataBlock(ocaBufHandle, (PMOS_OCA_LOG_HEADER)&header, info); if (MOS_FAILED(status)) { MosOcaInterfaceSpecific::OnOcaError(mosCtx, status, __FUNCTION__, __LINE__); } return; } //! //! \brief Add data block to oca log section. //! \param [in] ocaBufHandle //! Oca buffer handle. //! \param [in] mosCtx //! DDI device context. //! \param [in] pHeader //! Log header. It can be extended by user. The acutal size of header is pHeader->headerSize. //! \param [in] pData //! Data block without log header. The acutal size of data block is pHeader->dataSize. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if successful, otherwise failed //! MOS_STATUS MosOcaInterfaceSpecific::DumpDataBlock(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_CONTEXT mosCtx, PMOS_OCA_LOG_HEADER pHeader, void *pData) { if (!m_isOcaEnabled) { return MOS_STATUS_SUCCESS; } if (ocaBufHandle >= MAX_NUM_OF_OCA_BUF_CONTEXT || nullptr == pHeader) { return MOS_STATUS_INVALID_PARAMETER; } if (!IsLogSectionEnabled(ocaBufHandle)) { return MOS_STATUS_SUCCESS; } MOS_OCA_CHK_STATUS_RETURN(mosCtx, DumpDataBlock(ocaBufHandle, pHeader, pData), __FUNCTION__, __LINE__); return MOS_STATUS_SUCCESS; } MOS_STATUS MosOcaInterfaceSpecific::DumpDataBlock(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_OCA_LOG_HEADER pHeader, void *pData) { if (pHeader->headerSize < sizeof(MOS_OCA_LOG_HEADER) || pHeader->type >= MOS_OCA_LOG_TYPE_COUNT || pHeader->type <= MOS_OCA_LOG_TYPE_INVALID || (pHeader->dataSize > 0 && nullptr == pData) || (pHeader->dataSize == 0 && pData)) { return MOS_STATUS_INVALID_PARAMETER; } uint32_t copySize = pHeader->headerSize + pHeader->dataSize; if (m_ocaBufContextList[ocaBufHandle].logSection.offset + copySize > m_ocaLogSectionSizeLimit) { return MOS_STATUS_NOT_ENOUGH_BUFFER; } MOS_OS_CHK_STATUS_RETURN(InsertData(ocaBufHandle, (uint8_t *)pHeader, pHeader->headerSize)); if (pHeader->dataSize > 0) { MOS_OS_CHK_STATUS_RETURN(InsertData(ocaBufHandle, (uint8_t *)pData, pHeader->dataSize)); } return MOS_STATUS_SUCCESS; } MOS_STATUS MosOcaInterfaceSpecific::InsertData(MOS_OCA_BUFFER_HANDLE ocaBufHandle, uint8_t *p, uint32_t size) { if (nullptr == p || 0 == size) { return MOS_STATUS_INVALID_PARAMETER; } uint32_t sizeCpy = std::min(m_ocaLogSectionSizeLimit - m_ocaBufContextList[ocaBufHandle].logSection.offset, size); MOS_OS_CHK_STATUS_RETURN(MOS_SecureMemcpy((uint8_t *)m_ocaBufContextList[ocaBufHandle].logSection.base + m_ocaBufContextList[ocaBufHandle].logSection.offset, sizeCpy, p, sizeCpy)); m_ocaBufContextList[ocaBufHandle].logSection.offset += sizeCpy; return MOS_STATUS_SUCCESS; } uint32_t MosOcaInterfaceSpecific::IncreaseSize(uint32_t cmdBufSize) { return cmdBufSize + OCA_LOG_SECTION_SIZE_MAX; } void MosOcaInterfaceSpecific::InitOcaLogSection(MOS_LINUX_BO *bo) { if (bo == nullptr || bo->virt == nullptr || bo->size <= OCA_LOG_SECTION_SIZE_MAX) { return; } OCA_LOG_SECTION_HEADER *header = (OCA_LOG_SECTION_HEADER *)((uint64_t)bo->virt + bo->size - OCA_LOG_SECTION_SIZE_MAX); header->magicNum = OCA_LOG_SECTION_MAGIC_NUMBER; } void MosOcaInterfaceSpecific::InitLogSection(MOS_OCA_BUFFER_HANDLE ocaBufHandle, PMOS_RESOURCE resCmdBuf) { if (resCmdBuf == nullptr || resCmdBuf->bo == nullptr || resCmdBuf->bo->virt == nullptr) { return; } MOS_LINUX_BO *boCmdBuf = resCmdBuf->bo; if (boCmdBuf->size <= OCA_LOG_SECTION_SIZE_MAX) { MOS_OS_NORMALMESSAGE("1st level BB size is not larger than OCA_LOG_SECTION_SIZE_MAX."); return; } uint64_t *logSectionBase = (uint64_t*)((char *)boCmdBuf->virt + boCmdBuf->size - OCA_LOG_SECTION_SIZE_MAX); OCA_LOG_SECTION_HEADER *header = (OCA_LOG_SECTION_HEADER *)logSectionBase; if (OCA_LOG_SECTION_MAGIC_NUMBER != header->magicNum) { MOS_OS_NORMALMESSAGE("Log section not exists in current 1st level BB."); return; } m_ocaBufContextList[ocaBufHandle].logSection.base = logSectionBase; // Reserve an uint64 for magic number; m_ocaBufContextList[ocaBufHandle].logSection.offset = sizeof(OCA_LOG_SECTION_HEADER); m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCount = 0; m_ocaBufContextList[ocaBufHandle].logSection.resInfo.resCountSkipped = 0; } bool MosOcaInterfaceSpecific::IsLogSectionEnabled(MOS_OCA_BUFFER_HANDLE ocaBufHandle) { return nullptr != m_ocaBufContextList[ocaBufHandle].logSection.base; } //! //! \brief Oca Error Handler. //! \param [in] mosCtx //! DDI device context. //! \param [in] status //! status for error. //! \param [in] functionName //! The failure function name. //! \param [in] lineNumber //! The line number where the failure happened. //! void MosOcaInterfaceSpecific::OnOcaError(PMOS_CONTEXT mosCtx, MOS_STATUS status, const char *functionName, uint32_t lineNumber) { if (MOS_SUCCEEDED(status)) { return; } MOS_OS_ASSERTMESSAGE("%s failed at line %d with status = %d!", functionName, lineNumber, status); MOS_TraceEventExt(EVENT_OCA_ERROR, EVENT_TYPE_INFO, &status, sizeof(uint32_t), nullptr, 0); if (MOS_SUCCEEDED(s_ocaStatus)) { MediaUserSettingSharedPtr userSettingPtr = nullptr; s_ocaStatus = status; s_lineNumForOcaErr = lineNumber; userSettingPtr = MosInterface::MosGetUserSettingInstance(mosCtx); ReportUserSetting( userSettingPtr, __MEDIA_USER_FEATURE_VALUE_OCA_STATUS, status, MediaUserSetting::Group::Device); ReportUserSetting( userSettingPtr, __MEDIA_USER_FEATURE_VALUE_OCA_ERROR_HINT, lineNumber, MediaUserSetting::Group::Device); } } //! //! \brief Initialize oca error handler related items. //! void MosOcaInterfaceSpecific::InitOcaErrorHandler(PMOS_CONTEXT mosCtx) { if (!s_bOcaStatusExistInReg) { s_bOcaStatusExistInReg = true; // "Oca Status" should already be added into reg for MOS_FAILED(s_ocaStatus) case by OnOcaError. if (MOS_SUCCEEDED(s_ocaStatus)) { MediaUserSettingSharedPtr userSettingPtr = nullptr; userSettingPtr = MosInterface::MosGetUserSettingInstance(mosCtx); ReportUserSetting( userSettingPtr, __MEDIA_USER_FEATURE_VALUE_OCA_STATUS, s_ocaStatus, MediaUserSetting::Group::Device); } } } //! //! \brief Oca Interface Initialize. //! void MosOcaInterfaceSpecific::Initialize(PMOS_CONTEXT mosContext) { MosOcaInterfaceSpecific::InitOcaErrorHandler(mosContext); if (m_isInitialized == false) { MediaUserSettingSharedPtr userSettingPtr = MosInterface::MosGetUserSettingInstance(mosContext); // read isOcaEnabled from reg key int32_t value = 0; ReadUserSetting( userSettingPtr, value, __MEDIA_USER_FEATURE_VALUE_ENABLE_UMD_OCA, MediaUserSetting::Group::Device); m_isOcaEnabled = value; if (!m_isOcaEnabled) { return; } char *user_ctx_env = getenv("INTEL_DISABLE_DUMP_EXEC_LIST_INFO"); if (nullptr != user_ctx_env) { uint8_t user_ctx_env_value = (bool)atoi(user_ctx_env); if (user_ctx_env_value == 1) { m_ocaDumpExecListInfoEnabled = false; } } m_config.maxResInfoCount = OCA_MAX_RESOURCE_INFO_COUNT_MAX; m_resInfoPool = MOS_NewArray(MOS_OCA_RESOURCE_INFO, m_config.maxResInfoCount * MAX_NUM_OF_OCA_BUF_CONTEXT); if (nullptr == m_resInfoPool) { return; } MosUtilities::MosZeroMemory(m_resInfoPool, sizeof(MOS_OCA_RESOURCE_INFO)*m_config.maxResInfoCount * MAX_NUM_OF_OCA_BUF_CONTEXT); for (int i = 0; i < MAX_NUM_OF_OCA_BUF_CONTEXT; ++i) { m_ocaBufContextList[i].logSection.resInfo.resInfoList = m_resInfoPool + i * m_config.maxResInfoCount; } m_config.maxBufferResInfoCount = OCA_MAX_BUFFER_RESOURCE_INFO_COUNT_MAX; m_bufferResInfoPool = MOS_NewArray(MOS_OCA_BUFFER_RESOURCE_INFO, m_config.maxBufferResInfoCount * MAX_NUM_OF_OCA_BUF_CONTEXT); if (nullptr == m_bufferResInfoPool) { MOS_DeleteArray(m_resInfoPool); return; } MosUtilities::MosZeroMemory(m_bufferResInfoPool, sizeof(MOS_OCA_BUFFER_RESOURCE_INFO) * m_config.maxBufferResInfoCount * MAX_NUM_OF_OCA_BUF_CONTEXT); for (int i = 0; i < MAX_NUM_OF_OCA_BUF_CONTEXT; ++i) { m_ocaBufContextList[i].logSection.resInfo.bufferResInfoList = m_bufferResInfoPool + i * m_config.maxBufferResInfoCount; } if (nullptr != m_ocaMutex) { return; } m_ocaMutex = MosUtilities::MosCreateMutex(); if (nullptr == m_ocaMutex) { MOS_DeleteArray(m_bufferResInfoPool); MOS_DeleteArray(m_resInfoPool); return; } m_mutexForOcaBufPool = MosUtilities::MosCreateMutex(); if (nullptr == m_mutexForOcaBufPool) { MOS_DeleteArray(m_bufferResInfoPool); MOS_DeleteArray(m_resInfoPool); MosUtilities::MosDestroyMutex(m_ocaMutex); m_ocaMutex = nullptr; return; } m_isInitialized = true; } } MosOcaInterface& MosOcaInterfaceSpecific::GetInstance() { static MosOcaInterfaceSpecific instance; return instance; } MosOcaInterfaceSpecific::MosOcaInterfaceSpecific() { } MosOcaInterfaceSpecific::MosOcaInterfaceSpecific(MosOcaInterfaceSpecific&) { } MosOcaInterfaceSpecific& MosOcaInterfaceSpecific::operator= (MosOcaInterfaceSpecific&) { return *this; } MosOcaInterfaceSpecific::~MosOcaInterfaceSpecific() { Uninitialize(); s_isDestroyed = true; } //! //! \brief Oca Interface uninitialize. //! void MosOcaInterfaceSpecific::Uninitialize() { if (m_isInitialized == true) { if (m_PendingOcaBuffersToUnlock.size() > 0) { MOS_OS_ASSERTMESSAGE("%d Oca Buffers in pending list!", m_PendingOcaBuffersToUnlock.size()); UnlockPendingOcaBuffers(nullptr, nullptr, 0); } if (nullptr != m_mutexForOcaBufPool) { MosUtilities::MosDestroyMutex(m_mutexForOcaBufPool); m_mutexForOcaBufPool = nullptr; } if (nullptr != m_ocaMutex) { MosUtilities::MosDestroyMutex(m_ocaMutex); m_ocaMutex = nullptr; } if (m_resInfoPool != nullptr) { MOS_DeleteArray(m_resInfoPool); m_resInfoPool = nullptr; for (int i = 0; i < MAX_NUM_OF_OCA_BUF_CONTEXT; ++i) { m_ocaBufContextList[i].logSection.resInfo.resInfoList = nullptr; } } if(m_bufferResInfoPool != nullptr) { MOS_DeleteArray(m_bufferResInfoPool); m_bufferResInfoPool = nullptr; for (int i = 0; i < MAX_NUM_OF_OCA_BUF_CONTEXT; ++i) { m_ocaBufContextList[i].logSection.resInfo.bufferResInfoList = nullptr; } } m_hOcaMap.clear(); m_isInitialized = false; s_bOcaStatusExistInReg = false; s_isDestroyed = false; m_ocaDumpExecListInfoEnabled = true; } } //! //! \brief Oca Interface Initialize. //! void MosOcaInterfaceSpecific::InitInterface(PMOS_CONTEXT mosContext) { if (MosUtilities::MosAtomicIncrement(&s_refCount) == 1) { MosOcaInterfaceSpecific &ins = (MosOcaInterfaceSpecific &)MosOcaInterfaceSpecific::GetInstance(); ins.Initialize(mosContext); } return; } //! //! \brief Oca Interface uninitialize. //! void MosOcaInterfaceSpecific::UninitInterface() { if (MosUtilities::MosAtomicDecrement(&s_refCount) == 0) { if(!s_isDestroyed) { MosOcaInterfaceSpecific &ins = (MosOcaInterfaceSpecific &)MosOcaInterfaceSpecific::GetInstance(); ins.Uninitialize(); } } return; } //! //! \brief Insert OCA buffer handle into m_hOcaMap //! \param [in] key //! The key of m_hOcaMap. //! \param [in] handle //! Oca buffer handle. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if insert successfully, otherwise insert failed. //! MOS_STATUS MosOcaInterfaceSpecific::InsertOcaBufHandleMap(uint32_t *key, MOS_OCA_BUFFER_HANDLE handle) { MOS_OS_CHK_NULL_RETURN(m_ocaMutex); MOS_OS_CHK_NULL_RETURN(key); MosOcaAutoLock autoLock(m_ocaMutex); auto success = m_hOcaMap.emplace(key, handle); if (!success.second) { // Should never come to here. MOS_OS_ASSERTMESSAGE("OcaBufHandle has already been assigned to current cmdBuffer!"); return MOS_STATUS_UNKNOWN; } return MOS_STATUS_SUCCESS; } //! //! \brief Remove OCA buffer handle from m_hOcaMap //! \param [in] key //! The key of m_hOcaMap. //! \return MOS_STATUS //! Return MOS_STATUS_SUCCESS if erase successfully, otherwise erase failed. //! MOS_STATUS MosOcaInterfaceSpecific::RemoveOcaBufHandleFromMap(uint32_t *key) { MOS_OS_CHK_NULL_RETURN(m_ocaMutex); MosOcaAutoLock autoLock(m_ocaMutex); auto it = m_hOcaMap.find(key); if (it != m_hOcaMap.end()) { m_hOcaMap.erase(it); } return MOS_STATUS_SUCCESS; } //! //! \brief Get OCA buffer handle from m_hOcaMap //! \param [in] key //! The key of m_hOcaMap. //! \return MOS_OCA_BUFFER_HANDLE //! Return oca buffer handle. //! MOS_OCA_BUFFER_HANDLE MosOcaInterfaceSpecific::GetOcaBufHandleFromMap(uint32_t *key) { if (nullptr == m_ocaMutex) { MOS_OS_ASSERTMESSAGE("m_ocaMutex is nullptr."); return MOS_OCA_INVALID_BUFFER_HANDLE; } MosOcaAutoLock autoLock(m_ocaMutex); auto it = m_hOcaMap.find(key); if (it == m_hOcaMap.end()) { // May come here for workloads not enabling UMD_OCA. return MOS_OCA_INVALID_BUFFER_HANDLE; } if (it->second >= MAX_NUM_OF_OCA_BUF_CONTEXT) { MOS_OS_ASSERTMESSAGE("Get invalid OcaBufHandle: %d!", it->second); return MOS_OCA_INVALID_BUFFER_HANDLE; } return it->second; }