1 #ifndef _G_CLIENT_NVOC_H_ 2 #define _G_CLIENT_NVOC_H_ 3 #include "nvoc/runtime.h" 4 5 #ifdef __cplusplus 6 extern "C" { 7 #endif 8 9 /* 10 * SPDX-FileCopyrightText: Copyright (c) 2016-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 11 * SPDX-License-Identifier: MIT 12 * 13 * Permission is hereby granted, free of charge, to any person obtaining a 14 * copy of this software and associated documentation files (the "Software"), 15 * to deal in the Software without restriction, including without limitation 16 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 17 * and/or sell copies of the Software, and to permit persons to whom the 18 * Software is furnished to do so, subject to the following conditions: 19 * 20 * The above copyright notice and this permission notice shall be included in 21 * all copies or substantial portions of the Software. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 24 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 26 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 27 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 28 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 29 * DEALINGS IN THE SOFTWARE. 30 */ 31 #include "g_client_nvoc.h" 32 33 #ifndef _CLIENT_H_ 34 #define _CLIENT_H_ 35 36 #include "ctrl/ctrl0000/ctrl0000proc.h" // NV_PROC_NAME_MAX_LENGTH 37 #include "containers/btree.h" 38 #include "resserv/resserv.h" 39 #include "nvoc/prelude.h" 40 #include "resserv/rs_client.h" 41 #include "rmapi/resource.h" 42 #include "rmapi/event.h" 43 #include "nvsecurityinfo.h" 44 45 // event information definitions 46 typedef struct _def_client_system_event_info CLI_SYSTEM_EVENT_INFO, *PCLI_SYSTEM_EVENT_INFO; 47 48 /** 49 * This ref-counted object is shared by all clients that were registered under 50 * the same user and is used to identify clients from the same user. 51 */ 52 #ifdef NVOC_CLIENT_H_PRIVATE_ACCESS_ALLOWED 53 #define PRIVATE_FIELD(x) x 54 #else 55 #define PRIVATE_FIELD(x) NVOC_PRIVATE_FIELD(x) 56 #endif 57 struct UserInfo { 58 const struct NVOC_RTTI *__nvoc_rtti; 59 struct RsShared __nvoc_base_RsShared; 60 struct Object *__nvoc_pbase_Object; 61 struct RsShared *__nvoc_pbase_RsShared; 62 struct UserInfo *__nvoc_pbase_UserInfo; 63 PUID_TOKEN pUidToken; 64 }; 65 66 #ifndef __NVOC_CLASS_UserInfo_TYPEDEF__ 67 #define __NVOC_CLASS_UserInfo_TYPEDEF__ 68 typedef struct UserInfo UserInfo; 69 #endif /* __NVOC_CLASS_UserInfo_TYPEDEF__ */ 70 71 #ifndef __nvoc_class_id_UserInfo 72 #define __nvoc_class_id_UserInfo 0x21d236 73 #endif /* __nvoc_class_id_UserInfo */ 74 75 extern const struct NVOC_CLASS_DEF __nvoc_class_def_UserInfo; 76 77 #define __staticCast_UserInfo(pThis) \ 78 ((pThis)->__nvoc_pbase_UserInfo) 79 80 #ifdef __nvoc_client_h_disabled 81 #define __dynamicCast_UserInfo(pThis) ((UserInfo*)NULL) 82 #else //__nvoc_client_h_disabled 83 #define __dynamicCast_UserInfo(pThis) \ 84 ((UserInfo*)__nvoc_dynamicCast(staticCast((pThis), Dynamic), classInfo(UserInfo))) 85 #endif //__nvoc_client_h_disabled 86 87 88 NV_STATUS __nvoc_objCreateDynamic_UserInfo(UserInfo**, Dynamic*, NvU32, va_list); 89 90 NV_STATUS __nvoc_objCreate_UserInfo(UserInfo**, Dynamic*, NvU32); 91 #define __objCreate_UserInfo(ppNewObj, pParent, createFlags) \ 92 __nvoc_objCreate_UserInfo((ppNewObj), staticCast((pParent), Dynamic), (createFlags)) 93 94 NV_STATUS userinfoConstruct_IMPL(struct UserInfo *arg_pUserInfo); 95 96 #define __nvoc_userinfoConstruct(arg_pUserInfo) userinfoConstruct_IMPL(arg_pUserInfo) 97 void userinfoDestruct_IMPL(struct UserInfo *pUserInfo); 98 99 #define __nvoc_userinfoDestruct(pUserInfo) userinfoDestruct_IMPL(pUserInfo) 100 #undef PRIVATE_FIELD 101 102 103 // Flags for RmClient 104 #define RMAPI_CLIENT_FLAG_RM_INTERNAL_CLIENT 0x00000001 105 #define RMAPI_CLIENT_FLAG_DELETE_PENDING 0x00000002 106 107 // Values for client debugger state 108 #define RMAPI_CLIENT_DEBUGGER_STATE_NOT_SET 0x00000000 109 #define RMAPI_CLIENT_DEBUGGER_STATE_COMPUTE_ACTIVE 0x00000001 110 #define RMAPI_CLIENT_DEBUGGER_STATE_DEBUG_ACTIVE 0x00000002 111 112 #ifdef NVOC_CLIENT_H_PRIVATE_ACCESS_ALLOWED 113 #define PRIVATE_FIELD(x) x 114 #else 115 #define PRIVATE_FIELD(x) NVOC_PRIVATE_FIELD(x) 116 #endif 117 struct RmClient { 118 const struct NVOC_RTTI *__nvoc_rtti; 119 struct RsClient __nvoc_base_RsClient; 120 struct Object *__nvoc_pbase_Object; 121 struct RsClient *__nvoc_pbase_RsClient; 122 struct RmClient *__nvoc_pbase_RmClient; 123 NV_STATUS (*__rmclientValidate__)(struct RmClient *, const API_SECURITY_INFO *); 124 NV_STATUS (*__rmclientFreeResource__)(struct RmClient *, struct RsServer *, struct RS_RES_FREE_PARAMS_INTERNAL *); 125 NV_STATUS (*__rmclientInterMap__)(struct RmClient *, struct RsResourceRef *, struct RsResourceRef *, struct RS_INTER_MAP_PARAMS *); 126 void (*__rmclientInterUnmap__)(struct RmClient *, struct RsResourceRef *, struct RS_INTER_UNMAP_PARAMS *); 127 NV_STATUS (*__rmclientPostProcessPendingFreeList__)(struct RmClient *, struct RsResourceRef **); 128 RS_PRIV_LEVEL (*__rmclientGetCachedPrivilege__)(struct RmClient *); 129 NvBool (*__rmclientIsAdmin__)(struct RmClient *, RS_PRIV_LEVEL); 130 NV_STATUS (*__rmclientDestructResourceRef__)(struct RmClient *, RsServer *, struct RsResourceRef *); 131 NV_STATUS (*__rmclientValidateNewResourceHandle__)(struct RmClient *, NvHandle, NvBool); 132 NV_STATUS (*__rmclientShareResource__)(struct RmClient *, struct RsResourceRef *, RS_SHARE_POLICY *, struct CALL_CONTEXT *); 133 NV_STATUS (*__rmclientUnmapMemory__)(struct RmClient *, struct RsResourceRef *, struct RS_LOCK_INFO *, struct RsCpuMapping **, API_SECURITY_INFO *); 134 RS_PRIV_LEVEL cachedPrivilege; 135 NvBool bIsRootNonPriv; 136 NvU32 ProcID; 137 NvU32 SubProcessID; 138 char SubProcessName[100]; 139 NvBool bIsSubProcessDisabled; 140 NvU32 Flags; 141 NvU32 ClientDebuggerState; 142 void *pOSInfo; 143 void *pOsPidInfo; 144 char name[100]; 145 CLI_SYSTEM_EVENT_INFO CliSysEventInfo; 146 PSECURITY_TOKEN pSecurityToken; 147 struct UserInfo *pUserInfo; 148 NvBool bIsClientVirtualMode; 149 PNODE pCliSyncGpuBoostTree; 150 }; 151 152 #ifndef __NVOC_CLASS_RmClient_TYPEDEF__ 153 #define __NVOC_CLASS_RmClient_TYPEDEF__ 154 typedef struct RmClient RmClient; 155 #endif /* __NVOC_CLASS_RmClient_TYPEDEF__ */ 156 157 #ifndef __nvoc_class_id_RmClient 158 #define __nvoc_class_id_RmClient 0xb23d83 159 #endif /* __nvoc_class_id_RmClient */ 160 161 extern const struct NVOC_CLASS_DEF __nvoc_class_def_RmClient; 162 163 #define __staticCast_RmClient(pThis) \ 164 ((pThis)->__nvoc_pbase_RmClient) 165 166 #ifdef __nvoc_client_h_disabled 167 #define __dynamicCast_RmClient(pThis) ((RmClient*)NULL) 168 #else //__nvoc_client_h_disabled 169 #define __dynamicCast_RmClient(pThis) \ 170 ((RmClient*)__nvoc_dynamicCast(staticCast((pThis), Dynamic), classInfo(RmClient))) 171 #endif //__nvoc_client_h_disabled 172 173 174 NV_STATUS __nvoc_objCreateDynamic_RmClient(RmClient**, Dynamic*, NvU32, va_list); 175 176 NV_STATUS __nvoc_objCreate_RmClient(RmClient**, Dynamic*, NvU32, struct PORT_MEM_ALLOCATOR * arg_pAllocator, struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams); 177 #define __objCreate_RmClient(ppNewObj, pParent, createFlags, arg_pAllocator, arg_pParams) \ 178 __nvoc_objCreate_RmClient((ppNewObj), staticCast((pParent), Dynamic), (createFlags), arg_pAllocator, arg_pParams) 179 180 #define rmclientValidate(pClient, pSecInfo) rmclientValidate_DISPATCH(pClient, pSecInfo) 181 #define rmclientFreeResource(pClient, pServer, pParams) rmclientFreeResource_DISPATCH(pClient, pServer, pParams) 182 #define rmclientInterMap(pClient, pMapperRef, pMappableRef, pParams) rmclientInterMap_DISPATCH(pClient, pMapperRef, pMappableRef, pParams) 183 #define rmclientInterUnmap(pClient, pMapperRef, pParams) rmclientInterUnmap_DISPATCH(pClient, pMapperRef, pParams) 184 #define rmclientPostProcessPendingFreeList(pClient, ppFirstLowPriRef) rmclientPostProcessPendingFreeList_DISPATCH(pClient, ppFirstLowPriRef) 185 #define rmclientGetCachedPrivilege(pClient) rmclientGetCachedPrivilege_DISPATCH(pClient) 186 #define rmclientIsAdmin(pClient, privLevel) rmclientIsAdmin_DISPATCH(pClient, privLevel) 187 #define rmclientDestructResourceRef(pClient, pServer, pResourceRef) rmclientDestructResourceRef_DISPATCH(pClient, pServer, pResourceRef) 188 #define rmclientValidateNewResourceHandle(pClient, hResource, bRestrict) rmclientValidateNewResourceHandle_DISPATCH(pClient, hResource, bRestrict) 189 #define rmclientShareResource(pClient, pResourceRef, pSharePolicy, pCallContext) rmclientShareResource_DISPATCH(pClient, pResourceRef, pSharePolicy, pCallContext) 190 #define rmclientUnmapMemory(pClient, pResourceRef, pLockInfo, ppCpuMapping, pSecInfo) rmclientUnmapMemory_DISPATCH(pClient, pResourceRef, pLockInfo, ppCpuMapping, pSecInfo) 191 NV_STATUS rmclientValidate_IMPL(struct RmClient *pClient, const API_SECURITY_INFO *pSecInfo); 192 193 static inline NV_STATUS rmclientValidate_DISPATCH(struct RmClient *pClient, const API_SECURITY_INFO *pSecInfo) { 194 return pClient->__rmclientValidate__(pClient, pSecInfo); 195 } 196 197 NV_STATUS rmclientFreeResource_IMPL(struct RmClient *pClient, struct RsServer *pServer, struct RS_RES_FREE_PARAMS_INTERNAL *pParams); 198 199 static inline NV_STATUS rmclientFreeResource_DISPATCH(struct RmClient *pClient, struct RsServer *pServer, struct RS_RES_FREE_PARAMS_INTERNAL *pParams) { 200 return pClient->__rmclientFreeResource__(pClient, pServer, pParams); 201 } 202 203 NV_STATUS rmclientInterMap_IMPL(struct RmClient *pClient, struct RsResourceRef *pMapperRef, struct RsResourceRef *pMappableRef, struct RS_INTER_MAP_PARAMS *pParams); 204 205 static inline NV_STATUS rmclientInterMap_DISPATCH(struct RmClient *pClient, struct RsResourceRef *pMapperRef, struct RsResourceRef *pMappableRef, struct RS_INTER_MAP_PARAMS *pParams) { 206 return pClient->__rmclientInterMap__(pClient, pMapperRef, pMappableRef, pParams); 207 } 208 209 void rmclientInterUnmap_IMPL(struct RmClient *pClient, struct RsResourceRef *pMapperRef, struct RS_INTER_UNMAP_PARAMS *pParams); 210 211 static inline void rmclientInterUnmap_DISPATCH(struct RmClient *pClient, struct RsResourceRef *pMapperRef, struct RS_INTER_UNMAP_PARAMS *pParams) { 212 pClient->__rmclientInterUnmap__(pClient, pMapperRef, pParams); 213 } 214 215 NV_STATUS rmclientPostProcessPendingFreeList_IMPL(struct RmClient *pClient, struct RsResourceRef **ppFirstLowPriRef); 216 217 static inline NV_STATUS rmclientPostProcessPendingFreeList_DISPATCH(struct RmClient *pClient, struct RsResourceRef **ppFirstLowPriRef) { 218 return pClient->__rmclientPostProcessPendingFreeList__(pClient, ppFirstLowPriRef); 219 } 220 221 RS_PRIV_LEVEL rmclientGetCachedPrivilege_IMPL(struct RmClient *pClient); 222 223 static inline RS_PRIV_LEVEL rmclientGetCachedPrivilege_DISPATCH(struct RmClient *pClient) { 224 return pClient->__rmclientGetCachedPrivilege__(pClient); 225 } 226 227 NvBool rmclientIsAdmin_IMPL(struct RmClient *pClient, RS_PRIV_LEVEL privLevel); 228 229 static inline NvBool rmclientIsAdmin_DISPATCH(struct RmClient *pClient, RS_PRIV_LEVEL privLevel) { 230 return pClient->__rmclientIsAdmin__(pClient, privLevel); 231 } 232 233 static inline NV_STATUS rmclientDestructResourceRef_DISPATCH(struct RmClient *pClient, RsServer *pServer, struct RsResourceRef *pResourceRef) { 234 return pClient->__rmclientDestructResourceRef__(pClient, pServer, pResourceRef); 235 } 236 237 static inline NV_STATUS rmclientValidateNewResourceHandle_DISPATCH(struct RmClient *pClient, NvHandle hResource, NvBool bRestrict) { 238 return pClient->__rmclientValidateNewResourceHandle__(pClient, hResource, bRestrict); 239 } 240 241 static inline NV_STATUS rmclientShareResource_DISPATCH(struct RmClient *pClient, struct RsResourceRef *pResourceRef, RS_SHARE_POLICY *pSharePolicy, struct CALL_CONTEXT *pCallContext) { 242 return pClient->__rmclientShareResource__(pClient, pResourceRef, pSharePolicy, pCallContext); 243 } 244 245 static inline NV_STATUS rmclientUnmapMemory_DISPATCH(struct RmClient *pClient, struct RsResourceRef *pResourceRef, struct RS_LOCK_INFO *pLockInfo, struct RsCpuMapping **ppCpuMapping, API_SECURITY_INFO *pSecInfo) { 246 return pClient->__rmclientUnmapMemory__(pClient, pResourceRef, pLockInfo, ppCpuMapping, pSecInfo); 247 } 248 249 NV_STATUS rmclientConstruct_IMPL(struct RmClient *arg_pClient, struct PORT_MEM_ALLOCATOR *arg_pAllocator, struct RS_RES_ALLOC_PARAMS_INTERNAL *arg_pParams); 250 251 #define __nvoc_rmclientConstruct(arg_pClient, arg_pAllocator, arg_pParams) rmclientConstruct_IMPL(arg_pClient, arg_pAllocator, arg_pParams) 252 void rmclientDestruct_IMPL(struct RmClient *pClient); 253 254 #define __nvoc_rmclientDestruct(pClient) rmclientDestruct_IMPL(pClient) 255 void rmclientSetClientFlags_IMPL(struct RmClient *pClient, NvU32 clientFlags); 256 257 #ifdef __nvoc_client_h_disabled 258 static inline void rmclientSetClientFlags(struct RmClient *pClient, NvU32 clientFlags) { 259 NV_ASSERT_FAILED_PRECOMP("RmClient was disabled!"); 260 } 261 #else //__nvoc_client_h_disabled 262 #define rmclientSetClientFlags(pClient, clientFlags) rmclientSetClientFlags_IMPL(pClient, clientFlags) 263 #endif //__nvoc_client_h_disabled 264 265 void *rmclientGetSecurityToken_IMPL(struct RmClient *pClient); 266 267 #ifdef __nvoc_client_h_disabled 268 static inline void *rmclientGetSecurityToken(struct RmClient *pClient) { 269 NV_ASSERT_FAILED_PRECOMP("RmClient was disabled!"); 270 return NULL; 271 } 272 #else //__nvoc_client_h_disabled 273 #define rmclientGetSecurityToken(pClient) rmclientGetSecurityToken_IMPL(pClient) 274 #endif //__nvoc_client_h_disabled 275 276 NvBool rmclientIsCapableOrAdmin_IMPL(struct RmClient *pClient, NvU32 capability, RS_PRIV_LEVEL privLevel); 277 278 #ifdef __nvoc_client_h_disabled 279 static inline NvBool rmclientIsCapableOrAdmin(struct RmClient *pClient, NvU32 capability, RS_PRIV_LEVEL privLevel) { 280 NV_ASSERT_FAILED_PRECOMP("RmClient was disabled!"); 281 return NV_FALSE; 282 } 283 #else //__nvoc_client_h_disabled 284 #define rmclientIsCapableOrAdmin(pClient, capability, privLevel) rmclientIsCapableOrAdmin_IMPL(pClient, capability, privLevel) 285 #endif //__nvoc_client_h_disabled 286 287 NvBool rmclientIsCapable_IMPL(struct RmClient *pClient, NvU32 capability); 288 289 #ifdef __nvoc_client_h_disabled 290 static inline NvBool rmclientIsCapable(struct RmClient *pClient, NvU32 capability) { 291 NV_ASSERT_FAILED_PRECOMP("RmClient was disabled!"); 292 return NV_FALSE; 293 } 294 #else //__nvoc_client_h_disabled 295 #define rmclientIsCapable(pClient, capability) rmclientIsCapable_IMPL(pClient, capability) 296 #endif //__nvoc_client_h_disabled 297 298 #undef PRIVATE_FIELD 299 300 301 MAKE_LIST(RmClientList, RmClient*); 302 extern RmClientList g_clientListBehindGpusLock; 303 MAKE_LIST(UserInfoList, UserInfo*); 304 extern UserInfoList g_userInfoList; 305 MAKE_MULTIMAP(OsInfoMap, RmClient*); 306 extern OsInfoMap g_osInfoList; 307 308 309 // 310 // Convenience rmclientXxxByHandle util macros. Ideally, code operates on 311 // pClient directly instead of hClient but providing these for compatibility 312 // to hClient-heavy code. 313 // 314 RS_PRIV_LEVEL rmclientGetCachedPrivilegeByHandle(NvHandle hClient); 315 NvBool rmclientIsAdminByHandle(NvHandle hClient, RS_PRIV_LEVEL privLevel); 316 NvBool rmclientIsKernelOnlyByHandle(NvHandle hClient); 317 NvBool rmclientSetClientFlagsByHandle(NvHandle hClient, NvU32 clientFlags); 318 void rmclientPromoteDebuggerStateByHandle(NvHandle hClient, NvU32 newMinimumState); 319 void *rmclientGetSecurityTokenByHandle(NvHandle hClient); 320 NV_STATUS rmclientUserClientSecurityCheckByHandle(NvHandle hClient, const API_SECURITY_INFO *pSecInfo); 321 NvBool rmclientIsCapableOrAdminByHandle(NvHandle hClient, NvU32 capability, RS_PRIV_LEVEL privLevel); 322 NvBool rmclientIsCapableByHandle(NvHandle hClient, NvU32 capability); 323 324 #endif 325 326 #ifdef __cplusplus 327 } // extern "C" 328 #endif 329 330 #endif // _G_CLIENT_NVOC_H_ 331