1 /* 2 * SPDX-FileCopyrightText: Copyright (c) 2018-2020 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 3 * SPDX-License-Identifier: MIT 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be included in 13 * all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 #ifndef _RMAPI_H_ 24 #define _RMAPI_H_ 25 26 #include "core/core.h" 27 #include "nvsecurityinfo.h" 28 29 // 30 // Forward declarations 31 // 32 typedef struct _RM_API RM_API; 33 typedef struct RsServer RsServer; 34 typedef struct OBJGPU OBJGPU; 35 typedef struct RsResource RsResource; 36 typedef struct RsCpuMapping RsCpuMapping; 37 typedef struct CALL_CONTEXT CALL_CONTEXT; 38 typedef struct MEMORY_DESCRIPTOR MEMORY_DESCRIPTOR; 39 typedef struct RS_RES_FREE_PARAMS_INTERNAL RS_RES_FREE_PARAMS_INTERNAL; 40 typedef struct RS_LOCK_INFO RS_LOCK_INFO; 41 typedef NvU32 NV_ADDRESS_SPACE; 42 43 extern RsServer g_resServ; 44 45 /** 46 * Initialize RMAPI module. 47 * 48 * Must be called once and only once before any RMAPI functions can be called 49 */ 50 NV_STATUS rmapiInitialize(void); 51 52 /** 53 * Shutdown RMAPI module 54 * 55 * Must be called once and only once when a driver is shutting down and no more 56 * RMAPI functions will be called. 57 */ 58 void rmapiShutdown(void); 59 60 // Flags for rmapiLockAcquire 61 #define RMAPI_LOCK_FLAGS_NONE (0x00000000) // default no flags 62 #define RMAPI_LOCK_FLAGS_COND_ACQUIRE NVBIT(0) // conditional acquire; if lock is 63 // already held then return error 64 #define RMAPI_LOCK_FLAGS_READ NVBIT(1) // Acquire API lock for READ 65 #define RMAPI_LOCK_FLAGS_WRITE (0x00000000) // Acquire API lock for WRITE - Default 66 #define RMAPI_LOCK_FLAGS_LOW_PRIORITY NVBIT(2) // Deprioritize lock acquire 67 68 /** 69 * Acquire the RM API Lock 70 * 71 * The API lock is a sleeping mutex that is used to serialize access to RM APIs 72 * by (passive-level) RM clients. 73 * 74 * The API lock is not used to protect state accessed by DPC and ISRs. For DPC 75 * and ISRs that GPU lock is used instead. For state controlled by clients, this 76 * often requires taking both API and GPU locks in API paths 77 * 78 * @param[in] flags RM_LOCK_FLAGS_* 79 * @param[in] module RM_LOCK_MODULES_* 80 */ 81 NV_STATUS rmapiLockAcquire(NvU32 flags, NvU32 module); 82 83 /** 84 * Release RM API Lock 85 */ 86 void rmapiLockRelease(void); 87 88 /** 89 * Check if current thread owns the API lock 90 */ 91 NvBool rmapiLockIsOwner(void); 92 93 94 /** 95 * Type of RM API client interface 96 */ 97 typedef enum 98 { 99 RMAPI_EXTERNAL, // For clients external from RM TLS, locks, etc -- no default security attributes 100 RMAPI_EXTERNAL_KERNEL, // For clients external from TLS and locks but which still need default security attributes 101 RMAPI_MODS_LOCK_BYPASS, // Hack for MODS - skip RM locks but initialize TLS (bug 1808386) 102 RMAPI_API_LOCK_INTERNAL, // For clients that already have the TLS & API lock held -- security is RM internal 103 RMAPI_GPU_LOCK_INTERNAL, // For clients that have TLS, API lock, and GPU lock -- security is RM internal 104 RMAPI_STUBS, // All functions just return NV_ERR_NOT_SUPPORTED 105 RMAPI_TYPE_MAX 106 } RMAPI_TYPE; 107 108 /** 109 * Query interface that can be used to perform operations through the 110 * client-level RM API 111 */ 112 RM_API *rmapiGetInterface(RMAPI_TYPE rmapiType); 113 114 // Flags for RM_API::Alloc 115 #define RMAPI_ALLOC_FLAGS_NONE 0 116 #define RMAPI_ALLOC_FLAGS_SKIP_RPC NVBIT(0) 117 118 // Flags for RM_API::Free 119 #define RMAPI_FREE_FLAGS_NONE 0 120 121 /** 122 * Interface for performing operations through the RM API exposed to client 123 * drivers. Interface provides consistent view to the RM API while abstracting 124 * the individuals callers from specifying security attributes and/or from 125 * locking needs. For example, this interface can be used either before or after 126 * the API or GPU locks. 127 */ 128 struct _RM_API 129 { 130 // Allocate a resource with default security attributes and local pointers (no NvP64) 131 NV_STATUS (*Alloc)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hParent, 132 NvHandle *phObject, NvU32 hClass, void *pAllocParams); 133 134 // Allocate a resource with default security attributes and local pointers (no NvP64) 135 // and client assigned handle 136 NV_STATUS (*AllocWithHandle)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hParent, 137 NvHandle hObject, NvU32 hClass, void *pAllocParams); 138 139 // Allocate a resource 140 NV_STATUS (*AllocWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hParent, 141 NvHandle *phObject, NvU32 hClass, NvP64 pAllocParams, 142 NvU32 flags, NvP64 pRightsRequested, API_SECURITY_INFO *pSecInfo); 143 144 // Free a resource with default security attributes 145 NV_STATUS (*Free)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject); 146 147 // Free a resource 148 NV_STATUS (*FreeWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject, 149 NvU32 flags, API_SECURITY_INFO *pSecInfo); 150 151 // Disables all clients in the list, with default security attributes 152 NV_STATUS (*DisableClients)(struct _RM_API *pRmApi, NvHandle *phClientList, NvU32 numClients); 153 154 // Disables all clients in the list 155 NV_STATUS (*DisableClientsWithSecInfo)(struct _RM_API *pRmApi, NvHandle *phClientList, 156 NvU32 numClients, API_SECURITY_INFO *pSecInfo); 157 158 // Invoke a control with default security attributes and local pointers (no NvP64) 159 NV_STATUS (*Control)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject, NvU32 cmd, 160 void *pParams, NvU32 paramsSize); 161 162 // Invoke a control 163 NV_STATUS (*ControlWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject, NvU32 cmd, 164 NvP64 pParams, NvU32 paramsSize, NvU32 flags, API_SECURITY_INFO *pSecInfo); 165 166 // Prefetch a control parameters into the control call cache (0000, 0080 and 2080 classes only) 167 NV_STATUS (*ControlPrefetch)(struct _RM_API *pRmApi, NvU32 cmd); 168 169 // Dup an object with default security attributes 170 NV_STATUS (*DupObject)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hParent, NvHandle *phObject, 171 NvHandle hClientSrc, NvHandle hObjectSrc, NvU32 flags); 172 173 // Dup an object 174 NV_STATUS (*DupObjectWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hParent, 175 NvHandle *phObject, NvHandle hClientSrc, NvHandle hObjectSrc, NvU32 flags, 176 API_SECURITY_INFO *pSecInfo); 177 178 // Share an object with default security attributes 179 NV_STATUS (*Share)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject, 180 RS_SHARE_POLICY *pSharePolicy); 181 182 // Share an object 183 NV_STATUS (*ShareWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject, 184 RS_SHARE_POLICY *pSharePolicy, API_SECURITY_INFO *pSecInfo); 185 186 // Map memory with default security attributes and local pointers (no NvP64). Provides 187 // RM internal implementation for NvRmMapMemory(). 188 NV_STATUS (*MapToCpu)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemory, 189 NvU64 offset, NvU64 length, void **ppCpuVirtAddr, NvU32 flags); 190 191 // Map memory. Provides RM internal implementation for NvRmMapMemory(). 192 NV_STATUS (*MapToCpuWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemory, 193 NvU64 offset, NvU64 length, NvP64 *ppCpuVirtAddr, NvU32 flags, API_SECURITY_INFO *pSecInfo); 194 195 // Map memory v2. Pass in flags as a pointer for in/out access 196 NV_STATUS (*MapToCpuWithSecInfoV2)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemory, 197 NvU64 offset, NvU64 length, NvP64 *ppCpuVirtAddr, NvU32 *flags, API_SECURITY_INFO *pSecInfo); 198 199 // Unmap memory with default security attributes and local pointers (no NvP64) 200 NV_STATUS (*UnmapFromCpu)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemory, void *pLinearAddress, 201 NvU32 flags, NvU32 ProcessId); 202 203 // Unmap memory 204 NV_STATUS (*UnmapFromCpuWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemory, 205 NvP64 pLinearAddress, NvU32 flags, NvU32 ProcessId, API_SECURITY_INFO *pSecInfo); 206 207 // Map dma memory with default security attributes. Provides RM internal implementation for NvRmMapMemoryDma(). 208 NV_STATUS (*Map)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemCtx, NvHandle hMemory, 209 NvU64 offset, NvU64 length, NvU32 flags, NvU64 *pDmaOffset); 210 211 // Map dma memory. Provides RM internal implementation for NvRmMapMemoryDma(). 212 NV_STATUS (*MapWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemCtx, NvHandle hMemory, 213 NvU64 offset, NvU64 length, NvU32 flags, NvU64 *pDmaOffset, API_SECURITY_INFO *pSecInfo); 214 215 // Unmap dma memory with default security attributes 216 NV_STATUS (*Unmap)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemCtx, NvHandle hMemory, 217 NvU32 flags, NvU64 dmaOffset); 218 219 // Unmap dma memory 220 NV_STATUS (*UnmapWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemCtx, NvHandle hMemory, 221 NvU32 flags, NvU64 dmaOffset, API_SECURITY_INFO *pSecInfo); 222 223 API_SECURITY_INFO defaultSecInfo; 224 NvBool bHasDefaultSecInfo; 225 NvBool bTlsInternal; 226 NvBool bApiLockInternal; 227 NvBool bRmSemaInternal; 228 NvBool bGpuLockInternal; 229 void *pPrivateContext; 230 }; 231 232 // Called before any RM resource is freed 233 NV_STATUS rmapiFreeResourcePrologue(RS_RES_FREE_PARAMS_INTERNAL *pRmFreeParams); 234 235 // Mark for deletion the client resources given a GPU mask 236 void rmapiSetDelPendingClientResourcesFromGpuMask(NvU32 gpuMask); 237 238 // Delete the marked client resources 239 void rmapiDelPendingClients(void); 240 void rmapiDelPendingDevices(NvU32 gpuMask); 241 void rmapiReportLeakedDevices(NvU32 gpuMask); 242 243 // 244 // Given a value, retrieves an array of client handles corresponding to clients 245 // with matching pOSInfo fields. The array is allocated dynamically, and is 246 // expected to be freed by the caller. 247 // 248 NV_STATUS rmapiGetClientHandlesFromOSInfo(void*, NvHandle**, NvU32*); 249 250 // 251 // Base mapping routines for use by RsResource subclasses 252 // 253 NV_STATUS rmapiMapGpuCommon(RsResource *, CALL_CONTEXT *, RsCpuMapping *, OBJGPU *, NvU32, NvU32); 254 NV_STATUS rmapiValidateKernelMapping(RS_PRIV_LEVEL privLevel, NvU32 flags, NvBool *pbKernel); 255 NV_STATUS rmapiGetEffectiveAddrSpace(OBJGPU *pGpu, MEMORY_DESCRIPTOR *pMemDesc, NvU32 flags, NV_ADDRESS_SPACE *pAddrSpace); 256 257 /** 258 * Deprecated RM API interfaces. Use RM_API instead. 259 */ 260 NV_STATUS RmUnmapMemoryDma(NvHandle, NvHandle, NvHandle, NvHandle, MEMORY_DESCRIPTOR*, NvU32, NvU64); 261 NV_STATUS RmConfigGetEx (NvHandle, NvHandle, NvU32, NvP64, NvU32, NvBool); 262 NV_STATUS RmConfigSetEx (NvHandle, NvHandle, NvU32, NvP64, NvU32, NvBool); 263 264 /** 265 * Control cache API. 266 */ 267 NV_STATUS rmapiControlCacheInit(void); 268 NvBool rmapiControlIsCacheable(NvU32 flags, NvU32 accessRight, NvBool bAllowInternal); 269 NvBool rmapiCmdIsCacheable(NvU32 cmd, NvBool bAllowInternal); 270 NV_STATUS rmapiControlCacheGet(NvHandle hClient, NvHandle hObject, NvU32 cmd, 271 void* params, NvU32 paramsSize); 272 NV_STATUS rmapiControlCacheSet(NvHandle hClient, NvHandle hObject, NvU32 cmd, 273 void* params, NvU32 paramsSize); 274 NV_STATUS rmapiControlCacheSetGpuInstForObject(NvHandle hClient, NvHandle hObject, NvU32 gpuInst); 275 void rmapiControlCacheFreeAllCacheForGpu(NvU32 gpuInst); 276 void rmapiControlCacheSetMode(NvU32 mode); 277 NvU32 rmapiControlCacheGetMode(void); 278 void rmapiControlCacheFree(void); 279 void rmapiControlCacheFreeClientEntry(NvHandle hClient); 280 void rmapiControlCacheFreeObjectEntry(NvHandle hClient, NvHandle hObject); 281 282 typedef struct _RM_API_CONTEXT { 283 NvU32 gpuMask; 284 } RM_API_CONTEXT; 285 286 // 287 // Handler to do stuff that is required before invoking a RM API 288 // 289 NV_STATUS 290 rmapiPrologue 291 ( 292 RM_API *pRmApi, 293 RM_API_CONTEXT *pContext 294 ); 295 296 // 297 // Handler to do stuff that is required after invoking a RM API 298 // 299 void 300 rmapiEpilogue 301 ( 302 RM_API *pRmApi, 303 RM_API_CONTEXT *pContext 304 ); 305 306 void 307 rmapiInitLockInfo 308 ( 309 RM_API *pRmApi, 310 NvHandle hClient, 311 RS_LOCK_INFO *pLockInfo 312 ); 313 314 // 315 // RM locking modules: 24-bit group bitmask, 8-bit subgroup id 316 // 317 // Lock acquires are tagged with a RM_LOCK_MODULE_* in order to partition 318 // the acquires into groups, which allows read-only locks to be 319 // enabled / disabled on a per-group basis (via apiLockMask and gpuLockMask 320 // in OBJSYS.) 321 // 322 // The groups are further partitioned into subgroups, which 323 // are used for lock profiling data collection. 324 // 325 #define RM_LOCK_MODULE_VAL(grp, subgrp) ((((grp) & 0xffffff) << 8) | ((subgrp) & 0xff)) 326 #define RM_LOCK_MODULE_GRP(val) (((val) >> 8) & 0xffffff) 327 // Grp SubGrp 328 #define RM_LOCK_MODULES_NONE RM_LOCK_MODULE_VAL(0x000000, 0x00) 329 330 #define RM_LOCK_MODULES_WORKITEM RM_LOCK_MODULE_VAL(0x000001, 0x00) 331 332 #define RM_LOCK_MODULES_CLIENT RM_LOCK_MODULE_VAL(0x000002, 0x00) 333 334 #define RM_LOCK_MODULES_GPU_OPS RM_LOCK_MODULE_VAL(0x000004, 0x00) 335 336 #define RM_LOCK_MODULES_OSAPI RM_LOCK_MODULE_VAL(0x000010, 0x00) 337 #define RM_LOCK_MODULES_STATE_CONFIG RM_LOCK_MODULE_VAL(0x000010, 0x01) 338 #define RM_LOCK_MODULES_EVENT RM_LOCK_MODULE_VAL(0x000010, 0x02) 339 #define RM_LOCK_MODULES_VBIOS RM_LOCK_MODULE_VAL(0x000010, 0x03) 340 341 #define RM_LOCK_MODULES_MEM RM_LOCK_MODULE_VAL(0x000020, 0x00) 342 #define RM_LOCK_MODULES_MEM_FLA RM_LOCK_MODULE_VAL(0x000020, 0x01) 343 #define RM_LOCK_MODULES_MEM_PMA RM_LOCK_MODULE_VAL(0x000020, 0x02) 344 345 #define RM_LOCK_MODULES_POWER RM_LOCK_MODULE_VAL(0x000040, 0x00) 346 #define RM_LOCK_MODULES_ACPI RM_LOCK_MODULE_VAL(0x000040, 0x01) 347 #define RM_LOCK_MODULES_DYN_POWER RM_LOCK_MODULE_VAL(0x000040, 0x02) 348 349 #define RM_LOCK_MODULES_HYPERVISOR RM_LOCK_MODULE_VAL(0x000080, 0x00) 350 #define RM_LOCK_MODULES_VGPU RM_LOCK_MODULE_VAL(0x000080, 0x01) 351 #define RM_LOCK_MODULES_RPC RM_LOCK_MODULE_VAL(0x000080, 0x02) 352 353 #define RM_LOCK_MODULES_DIAG RM_LOCK_MODULE_VAL(0x000100, 0x00) 354 #define RM_LOCK_MODULES_RC RM_LOCK_MODULE_VAL(0x000100, 0x01) 355 356 #define RM_LOCK_MODULES_SLI RM_LOCK_MODULE_VAL(0x000200, 0x00) 357 #define RM_LOCK_MODULES_P2P RM_LOCK_MODULE_VAL(0x000200, 0x01) 358 #define RM_LOCK_MODULES_NVLINK RM_LOCK_MODULE_VAL(0x000200, 0x02) 359 360 #define RM_LOCK_MODULES_HOTPLUG RM_LOCK_MODULE_VAL(0x000400, 0x00) 361 #define RM_LOCK_MODULES_DISP RM_LOCK_MODULE_VAL(0x000400, 0x01) 362 #define RM_LOCK_MODULES_KERNEL_RM_EVENTS RM_LOCK_MODULE_VAL(0x000400, 0x02) 363 364 #define RM_LOCK_MODULES_GPU RM_LOCK_MODULE_VAL(0x000800, 0x00) 365 #define RM_LOCK_MODULES_GR RM_LOCK_MODULE_VAL(0x000800, 0x01) 366 #define RM_LOCK_MODULES_FB RM_LOCK_MODULE_VAL(0x000800, 0x02) 367 #define RM_LOCK_MODULES_FIFO RM_LOCK_MODULE_VAL(0x000800, 0x03) 368 #define RM_LOCK_MODULES_TMR RM_LOCK_MODULE_VAL(0x000800, 0x04) 369 370 #define RM_LOCK_MODULES_I2C RM_LOCK_MODULE_VAL(0x001000, 0x00) 371 #define RM_LOCK_MODULES_PFM_REQ_HNDLR RM_LOCK_MODULE_VAL(0x001000, 0x01) 372 #define RM_LOCK_MODULES_SEC2 RM_LOCK_MODULE_VAL(0x001000, 0x02) 373 #define RM_LOCK_MODULES_THERM RM_LOCK_MODULE_VAL(0x001000, 0x03) 374 #define RM_LOCK_MODULES_INFOROM RM_LOCK_MODULE_VAL(0x001000, 0x04) 375 376 #define RM_LOCK_MODULES_ISR RM_LOCK_MODULE_VAL(0x002000, 0x00) 377 #define RM_LOCK_MODULES_DPC RM_LOCK_MODULE_VAL(0x002000, 0x01) 378 379 #define RM_LOCK_MODULES_INIT RM_LOCK_MODULE_VAL(0x004000, 0x00) 380 #define RM_LOCK_MODULES_STATE_LOAD RM_LOCK_MODULE_VAL(0x004000, 0x01) 381 382 #define RM_LOCK_MODULES_STATE_UNLOAD RM_LOCK_MODULE_VAL(0x008000, 0x00) 383 #define RM_LOCK_MODULES_DESTROY RM_LOCK_MODULE_VAL(0x008000, 0x01) 384 385 // 386 // ResServ lock flag translation 387 // 388 #define RM_LOCK_FLAGS_NONE 0 389 #define RM_LOCK_FLAGS_NO_API_LOCK RS_LOCK_FLAGS_NO_TOP_LOCK 390 #define RM_LOCK_FLAGS_NO_CLIENT_LOCK RS_LOCK_FLAGS_NO_CLIENT_LOCK 391 #define RM_LOCK_FLAGS_NO_GPUS_LOCK RS_LOCK_FLAGS_NO_CUSTOM_LOCK_1 392 #define RM_LOCK_FLAGS_GPU_GROUP_LOCK RS_LOCK_FLAGS_NO_CUSTOM_LOCK_2 393 #define RM_LOCK_FLAGS_RM_SEMA RS_LOCK_FLAGS_NO_CUSTOM_LOCK_3 394 395 // 396 // ResServ lock state translation 397 // 398 #define RM_LOCK_STATES_NONE 0 399 #define RM_LOCK_STATES_API_LOCK_ACQUIRED RS_LOCK_STATE_TOP_LOCK_ACQUIRED 400 #define RM_LOCK_STATES_GPUS_LOCK_ACQUIRED RS_LOCK_STATE_CUSTOM_LOCK_1_ACQUIRED 401 #define RM_LOCK_STATES_GPU_GROUP_LOCK_ACQUIRED RS_LOCK_STATE_CUSTOM_LOCK_2_ACQUIRED 402 #define RM_LOCK_STATES_ALLOW_RECURSIVE_LOCKS RS_LOCK_STATE_ALLOW_RECURSIVE_RES_LOCK 403 #define RM_LOCK_STATES_CLIENT_LOCK_ACQUIRED RS_LOCK_STATE_CLIENT_LOCK_ACQUIRED 404 #define RM_LOCK_STATES_RM_SEMA_ACQUIRED RS_LOCK_STATE_CUSTOM_LOCK_3_ACQUIRED 405 406 // 407 // ResServ lock release translation 408 // 409 #define RM_LOCK_RELEASE_API_LOCK RS_LOCK_RELEASE_TOP_LOCK 410 #define RM_LOCK_RELEASE_CLIENT_LOCK RS_LOCK_RELEASE_CLIENT_LOCK 411 #define RM_LOCK_RELEASE_GPUS_LOCK RS_LOCK_RELEASE_CUSTOM_LOCK_1 412 #define RM_LOCK_RELEASE_GPU_GROUP_LOCK RS_LOCK_RELEASE_CUSTOM_LOCK_2 413 #define RM_LOCK_RELEASE_RM_SEMA RS_LOCK_RELEASE_CUSTOM_LOCK_3 414 415 #endif // _RMAPI_H_ 416