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 #define RMAPI_ALLOC_FLAGS_SERIALIZED NVBIT(1) 118 119 // Flags for RM_API::Free 120 #define RMAPI_FREE_FLAGS_NONE 0 121 122 // Flags for RM_API RPC's 123 #define RMAPI_RPC_FLAGS_NONE 0 124 #define RMAPI_RPC_FLAGS_COPYOUT_ON_ERROR NVBIT(0) 125 #define RMAPI_RPC_FLAGS_SERIALIZED NVBIT(1) 126 127 /** 128 * Interface for performing operations through the RM API exposed to client 129 * drivers. Interface provides consistent view to the RM API while abstracting 130 * the individuals callers from specifying security attributes and/or from 131 * locking needs. For example, this interface can be used either before or after 132 * the API or GPU locks. 133 */ 134 struct _RM_API 135 { 136 // Allocate a resource with default security attributes and local pointers (no NvP64) 137 NV_STATUS (*Alloc)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hParent, 138 NvHandle *phObject, NvU32 hClass, void *pAllocParams, NvU32 paramsSize); 139 140 // Allocate a resource with default security attributes and local pointers (no NvP64) 141 // and client assigned handle 142 NV_STATUS (*AllocWithHandle)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hParent, 143 NvHandle hObject, NvU32 hClass, void *pAllocParams, NvU32 paramsSize); 144 145 // Allocate a resource 146 NV_STATUS (*AllocWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hParent, 147 NvHandle *phObject, NvU32 hClass, NvP64 pAllocParams, NvU32 paramsSize, 148 NvU32 flags, NvP64 pRightsRequested, API_SECURITY_INFO *pSecInfo); 149 150 // Free a resource with default security attributes 151 NV_STATUS (*Free)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject); 152 153 // Free a resource 154 NV_STATUS (*FreeWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject, 155 NvU32 flags, API_SECURITY_INFO *pSecInfo); 156 157 // Disables all clients in the list, with default security attributes 158 NV_STATUS (*DisableClients)(struct _RM_API *pRmApi, NvHandle *phClientList, NvU32 numClients); 159 160 // Disables all clients in the list 161 NV_STATUS (*DisableClientsWithSecInfo)(struct _RM_API *pRmApi, NvHandle *phClientList, 162 NvU32 numClients, API_SECURITY_INFO *pSecInfo); 163 164 // Invoke a control with default security attributes and local pointers (no NvP64) 165 NV_STATUS (*Control)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject, NvU32 cmd, 166 void *pParams, NvU32 paramsSize); 167 168 // Invoke a control 169 NV_STATUS (*ControlWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject, NvU32 cmd, 170 NvP64 pParams, NvU32 paramsSize, NvU32 flags, API_SECURITY_INFO *pSecInfo); 171 172 // Prefetch a control parameters into the control call cache (0000, 0080 and 2080 classes only) 173 NV_STATUS (*ControlPrefetch)(struct _RM_API *pRmApi, NvU32 cmd); 174 175 // Dup an object with default security attributes 176 NV_STATUS (*DupObject)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hParent, NvHandle *phObject, 177 NvHandle hClientSrc, NvHandle hObjectSrc, NvU32 flags); 178 179 // Dup an object 180 NV_STATUS (*DupObjectWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hParent, 181 NvHandle *phObject, NvHandle hClientSrc, NvHandle hObjectSrc, NvU32 flags, 182 API_SECURITY_INFO *pSecInfo); 183 184 // Share an object with default security attributes 185 NV_STATUS (*Share)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject, 186 RS_SHARE_POLICY *pSharePolicy); 187 188 // Share an object 189 NV_STATUS (*ShareWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hObject, 190 RS_SHARE_POLICY *pSharePolicy, API_SECURITY_INFO *pSecInfo); 191 192 // Map memory with default security attributes and local pointers (no NvP64). Provides 193 // RM internal implementation for NvRmMapMemory(). 194 NV_STATUS (*MapToCpu)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemory, 195 NvU64 offset, NvU64 length, void **ppCpuVirtAddr, NvU32 flags); 196 197 // Map memory. Provides RM internal implementation for NvRmMapMemory(). 198 NV_STATUS (*MapToCpuWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemory, 199 NvU64 offset, NvU64 length, NvP64 *ppCpuVirtAddr, NvU32 flags, API_SECURITY_INFO *pSecInfo); 200 201 // Map memory v2. Pass in flags as a pointer for in/out access 202 NV_STATUS (*MapToCpuWithSecInfoV2)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemory, 203 NvU64 offset, NvU64 length, NvP64 *ppCpuVirtAddr, NvU32 *flags, API_SECURITY_INFO *pSecInfo); 204 205 // Unmap memory with default security attributes and local pointers (no NvP64) 206 NV_STATUS (*UnmapFromCpu)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemory, void *pLinearAddress, 207 NvU32 flags, NvU32 ProcessId); 208 209 // Unmap memory 210 NV_STATUS (*UnmapFromCpuWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemory, 211 NvP64 pLinearAddress, NvU32 flags, NvU32 ProcessId, API_SECURITY_INFO *pSecInfo); 212 213 // Map dma memory with default security attributes. Provides RM internal implementation for NvRmMapMemoryDma(). 214 NV_STATUS (*Map)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemCtx, NvHandle hMemory, 215 NvU64 offset, NvU64 length, NvU32 flags, NvU64 *pDmaOffset); 216 217 // Map dma memory. Provides RM internal implementation for NvRmMapMemoryDma(). 218 NV_STATUS (*MapWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemCtx, NvHandle hMemory, 219 NvU64 offset, NvU64 length, NvU32 flags, NvU64 *pDmaOffset, API_SECURITY_INFO *pSecInfo); 220 221 // Unmap dma memory with default security attributes 222 NV_STATUS (*Unmap)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemCtx, NvHandle hMemory, 223 NvU32 flags, NvU64 dmaOffset); 224 225 // Unmap dma memory 226 NV_STATUS (*UnmapWithSecInfo)(struct _RM_API *pRmApi, NvHandle hClient, NvHandle hDevice, NvHandle hMemCtx, NvHandle hMemory, 227 NvU32 flags, NvU64 dmaOffset, API_SECURITY_INFO *pSecInfo); 228 229 API_SECURITY_INFO defaultSecInfo; 230 NvBool bHasDefaultSecInfo; 231 NvBool bTlsInternal; 232 NvBool bApiLockInternal; 233 NvBool bRmSemaInternal; 234 NvBool bGpuLockInternal; 235 void *pPrivateContext; 236 }; 237 238 // Called before any RM resource is freed 239 NV_STATUS rmapiFreeResourcePrologue(RS_RES_FREE_PARAMS_INTERNAL *pRmFreeParams); 240 241 // Mark for deletion the client resources given a GPU mask 242 void rmapiSetDelPendingClientResourcesFromGpuMask(NvU32 gpuMask); 243 244 // Delete the marked client resources 245 void rmapiDelPendingClients(void); 246 void rmapiDelPendingDevices(NvU32 gpuMask); 247 void rmapiReportLeakedDevices(NvU32 gpuMask); 248 249 // 250 // Given a value, retrieves an array of client handles corresponding to clients 251 // with matching pOSInfo fields. The array is allocated dynamically, and is 252 // expected to be freed by the caller. 253 // 254 NV_STATUS rmapiGetClientHandlesFromOSInfo(void*, NvHandle**, NvU32*); 255 256 // 257 // Base mapping routines for use by RsResource subclasses 258 // 259 NV_STATUS rmapiMapGpuCommon(RsResource *, CALL_CONTEXT *, RsCpuMapping *, OBJGPU *, NvU32, NvU32); 260 NV_STATUS rmapiValidateKernelMapping(RS_PRIV_LEVEL privLevel, NvU32 flags, NvBool *pbKernel); 261 NV_STATUS rmapiGetEffectiveAddrSpace(OBJGPU *pGpu, MEMORY_DESCRIPTOR *pMemDesc, NvU32 flags, NV_ADDRESS_SPACE *pAddrSpace); 262 263 /** 264 * Deprecated RM API interfaces. Use RM_API instead. 265 */ 266 NV_STATUS RmUnmapMemoryDma(NvHandle, NvHandle, NvHandle, NvHandle, MEMORY_DESCRIPTOR*, NvU32, NvU64); 267 NV_STATUS RmConfigGetEx (NvHandle, NvHandle, NvU32, NvP64, NvU32, NvBool); 268 NV_STATUS RmConfigSetEx (NvHandle, NvHandle, NvU32, NvP64, NvU32, NvBool); 269 270 /** 271 * Control cache API. 272 */ 273 NV_STATUS rmapiControlCacheInit(void); 274 NvBool rmapiControlIsCacheable(NvU32 flags, NvU32 accessRight, NvBool bAllowInternal); 275 NvBool rmapiCmdIsCacheable(NvU32 cmd, NvBool bAllowInternal); 276 NV_STATUS rmapiControlCacheGet(NvHandle hClient, NvHandle hObject, NvU32 cmd, 277 void* params, NvU32 paramsSize); 278 NV_STATUS rmapiControlCacheSet(NvHandle hClient, NvHandle hObject, NvU32 cmd, 279 void* params, NvU32 paramsSize); 280 NV_STATUS rmapiControlCacheSetGpuInstForObject(NvHandle hClient, NvHandle hObject, NvU32 gpuInst); 281 void rmapiControlCacheFreeAllCacheForGpu(NvU32 gpuInst); 282 void rmapiControlCacheSetMode(NvU32 mode); 283 NvU32 rmapiControlCacheGetMode(void); 284 void rmapiControlCacheFree(void); 285 void rmapiControlCacheFreeClientEntry(NvHandle hClient); 286 void rmapiControlCacheFreeObjectEntry(NvHandle hClient, NvHandle hObject); 287 288 typedef struct _RM_API_CONTEXT { 289 NvU32 gpuMask; 290 } RM_API_CONTEXT; 291 292 // 293 // Handler to do stuff that is required before invoking a RM API 294 // 295 NV_STATUS 296 rmapiPrologue 297 ( 298 RM_API *pRmApi, 299 RM_API_CONTEXT *pContext 300 ); 301 302 // 303 // Handler to do stuff that is required after invoking a RM API 304 // 305 void 306 rmapiEpilogue 307 ( 308 RM_API *pRmApi, 309 RM_API_CONTEXT *pContext 310 ); 311 312 void 313 rmapiInitLockInfo 314 ( 315 RM_API *pRmApi, 316 NvHandle hClient, 317 RS_LOCK_INFO *pLockInfo 318 ); 319 320 // 321 // RM locking modules: 24-bit group bitmask, 8-bit subgroup id 322 // 323 // Lock acquires are tagged with a RM_LOCK_MODULE_* in order to partition 324 // the acquires into groups, which allows read-only locks to be 325 // enabled / disabled on a per-group basis (via apiLockMask and gpuLockMask 326 // in OBJSYS.) 327 // 328 // The groups are further partitioned into subgroups, which 329 // are used for lock profiling data collection. 330 // 331 #define RM_LOCK_MODULE_VAL(grp, subgrp) ((((grp) & 0xffffff) << 8) | ((subgrp) & 0xff)) 332 #define RM_LOCK_MODULE_GRP(val) (((val) >> 8) & 0xffffff) 333 // Grp SubGrp 334 #define RM_LOCK_MODULES_NONE RM_LOCK_MODULE_VAL(0x000000, 0x00) 335 336 #define RM_LOCK_MODULES_WORKITEM RM_LOCK_MODULE_VAL(0x000001, 0x00) 337 338 #define RM_LOCK_MODULES_CLIENT RM_LOCK_MODULE_VAL(0x000002, 0x00) 339 340 #define RM_LOCK_MODULES_GPU_OPS RM_LOCK_MODULE_VAL(0x000004, 0x00) 341 342 #define RM_LOCK_MODULES_OSAPI RM_LOCK_MODULE_VAL(0x000010, 0x00) 343 #define RM_LOCK_MODULES_STATE_CONFIG RM_LOCK_MODULE_VAL(0x000010, 0x01) 344 #define RM_LOCK_MODULES_EVENT RM_LOCK_MODULE_VAL(0x000010, 0x02) 345 #define RM_LOCK_MODULES_VBIOS RM_LOCK_MODULE_VAL(0x000010, 0x03) 346 347 #define RM_LOCK_MODULES_MEM RM_LOCK_MODULE_VAL(0x000020, 0x00) 348 #define RM_LOCK_MODULES_MEM_FLA RM_LOCK_MODULE_VAL(0x000020, 0x01) 349 #define RM_LOCK_MODULES_MEM_PMA RM_LOCK_MODULE_VAL(0x000020, 0x02) 350 351 #define RM_LOCK_MODULES_POWER RM_LOCK_MODULE_VAL(0x000040, 0x00) 352 #define RM_LOCK_MODULES_ACPI RM_LOCK_MODULE_VAL(0x000040, 0x01) 353 #define RM_LOCK_MODULES_DYN_POWER RM_LOCK_MODULE_VAL(0x000040, 0x02) 354 355 #define RM_LOCK_MODULES_HYPERVISOR RM_LOCK_MODULE_VAL(0x000080, 0x00) 356 #define RM_LOCK_MODULES_VGPU RM_LOCK_MODULE_VAL(0x000080, 0x01) 357 #define RM_LOCK_MODULES_RPC RM_LOCK_MODULE_VAL(0x000080, 0x02) 358 359 #define RM_LOCK_MODULES_DIAG RM_LOCK_MODULE_VAL(0x000100, 0x00) 360 #define RM_LOCK_MODULES_RC RM_LOCK_MODULE_VAL(0x000100, 0x01) 361 362 #define RM_LOCK_MODULES_SLI RM_LOCK_MODULE_VAL(0x000200, 0x00) 363 #define RM_LOCK_MODULES_P2P RM_LOCK_MODULE_VAL(0x000200, 0x01) 364 #define RM_LOCK_MODULES_NVLINK RM_LOCK_MODULE_VAL(0x000200, 0x02) 365 366 #define RM_LOCK_MODULES_HOTPLUG RM_LOCK_MODULE_VAL(0x000400, 0x00) 367 #define RM_LOCK_MODULES_DISP RM_LOCK_MODULE_VAL(0x000400, 0x01) 368 #define RM_LOCK_MODULES_KERNEL_RM_EVENTS RM_LOCK_MODULE_VAL(0x000400, 0x02) 369 370 #define RM_LOCK_MODULES_GPU RM_LOCK_MODULE_VAL(0x000800, 0x00) 371 #define RM_LOCK_MODULES_GR RM_LOCK_MODULE_VAL(0x000800, 0x01) 372 #define RM_LOCK_MODULES_FB RM_LOCK_MODULE_VAL(0x000800, 0x02) 373 #define RM_LOCK_MODULES_FIFO RM_LOCK_MODULE_VAL(0x000800, 0x03) 374 #define RM_LOCK_MODULES_TMR RM_LOCK_MODULE_VAL(0x000800, 0x04) 375 376 #define RM_LOCK_MODULES_I2C RM_LOCK_MODULE_VAL(0x001000, 0x00) 377 #define RM_LOCK_MODULES_PFM_REQ_HNDLR RM_LOCK_MODULE_VAL(0x001000, 0x01) 378 #define RM_LOCK_MODULES_SEC2 RM_LOCK_MODULE_VAL(0x001000, 0x02) 379 #define RM_LOCK_MODULES_THERM RM_LOCK_MODULE_VAL(0x001000, 0x03) 380 #define RM_LOCK_MODULES_INFOROM RM_LOCK_MODULE_VAL(0x001000, 0x04) 381 382 #define RM_LOCK_MODULES_ISR RM_LOCK_MODULE_VAL(0x002000, 0x00) 383 #define RM_LOCK_MODULES_DPC RM_LOCK_MODULE_VAL(0x002000, 0x01) 384 385 #define RM_LOCK_MODULES_INIT RM_LOCK_MODULE_VAL(0x004000, 0x00) 386 #define RM_LOCK_MODULES_STATE_LOAD RM_LOCK_MODULE_VAL(0x004000, 0x01) 387 388 #define RM_LOCK_MODULES_STATE_UNLOAD RM_LOCK_MODULE_VAL(0x008000, 0x00) 389 #define RM_LOCK_MODULES_DESTROY RM_LOCK_MODULE_VAL(0x008000, 0x01) 390 391 // 392 // ResServ lock flag translation 393 // 394 #define RM_LOCK_FLAGS_NONE 0 395 #define RM_LOCK_FLAGS_NO_API_LOCK RS_LOCK_FLAGS_NO_TOP_LOCK 396 #define RM_LOCK_FLAGS_NO_CLIENT_LOCK RS_LOCK_FLAGS_NO_CLIENT_LOCK 397 #define RM_LOCK_FLAGS_NO_GPUS_LOCK RS_LOCK_FLAGS_NO_CUSTOM_LOCK_1 398 #define RM_LOCK_FLAGS_GPU_GROUP_LOCK RS_LOCK_FLAGS_NO_CUSTOM_LOCK_2 399 #define RM_LOCK_FLAGS_RM_SEMA RS_LOCK_FLAGS_NO_CUSTOM_LOCK_3 400 401 // 402 // ResServ lock state translation 403 // 404 #define RM_LOCK_STATES_NONE 0 405 #define RM_LOCK_STATES_API_LOCK_ACQUIRED RS_LOCK_STATE_TOP_LOCK_ACQUIRED 406 #define RM_LOCK_STATES_GPUS_LOCK_ACQUIRED RS_LOCK_STATE_CUSTOM_LOCK_1_ACQUIRED 407 #define RM_LOCK_STATES_GPU_GROUP_LOCK_ACQUIRED RS_LOCK_STATE_CUSTOM_LOCK_2_ACQUIRED 408 #define RM_LOCK_STATES_ALLOW_RECURSIVE_LOCKS RS_LOCK_STATE_ALLOW_RECURSIVE_RES_LOCK 409 #define RM_LOCK_STATES_CLIENT_LOCK_ACQUIRED RS_LOCK_STATE_CLIENT_LOCK_ACQUIRED 410 #define RM_LOCK_STATES_RM_SEMA_ACQUIRED RS_LOCK_STATE_CUSTOM_LOCK_3_ACQUIRED 411 412 // 413 // ResServ lock release translation 414 // 415 #define RM_LOCK_RELEASE_API_LOCK RS_LOCK_RELEASE_TOP_LOCK 416 #define RM_LOCK_RELEASE_CLIENT_LOCK RS_LOCK_RELEASE_CLIENT_LOCK 417 #define RM_LOCK_RELEASE_GPUS_LOCK RS_LOCK_RELEASE_CUSTOM_LOCK_1 418 #define RM_LOCK_RELEASE_GPU_GROUP_LOCK RS_LOCK_RELEASE_CUSTOM_LOCK_2 419 #define RM_LOCK_RELEASE_RM_SEMA RS_LOCK_RELEASE_CUSTOM_LOCK_3 420 421 #endif // _RMAPI_H_ 422