diff -r 000000000000 -r 96e5fb8b040d kernel/eka/include/u32std.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kernel/eka/include/u32std.h Thu Dec 17 09:24:54 2009 +0200 @@ -0,0 +1,821 @@ +// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the License "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// e32\include\u32std.h +// +// + +/** + @file + @internalComponent + @released +*/ + +#ifndef __U32STD_H__ +#define __U32STD_H__ +#include +#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef __MARM__ +#define EKA2_ENTRY_POINT_VERSION_IDENTIFIER \ + asm("tst pc, #%a0" : : "i" ((TInt)0) ) +#endif + +struct TUnicodeDataSet; // forward declaration +struct TCollationDataSet; // forward declaration + +/* +The LCharSet structure is used in Unicode builds to supply locale-specific +character attribute and collation data. + +The structure is defined in both builds to avoid having to have a dummy ExecHandler::GetLocaleCharSet function +with a different signature in the 8-bit build. +*/ +struct LCharSet + { + const TUnicodeDataSet* iCharDataSet; // if non-null, character data overriding standard Unicode data + const TCollationDataSet* iCollationDataSet; // if non-null, locale-specific collation data + }; + +extern const LCharSet* GetLocaleCharSet(); + +/** @internalTechnology */ +const TInt KNumLocaleExports = 22; + +// +// The bits in the type table (non-Unicode build only) +// +#ifndef _UNICODE + +/** @internalTechnology */ +const TUint __U=0x01; // Uppercase letter + +/** @internalTechnology */ +const TUint __L=0x02; // Lowercase letter + +/** @internalTechnology */ +const TUint __D=0x04; // Decimal digit + +/** @internalTechnology */ +const TUint __S=0x08; // Space + +/** @internalTechnology */ +const TUint __P=0x10; // Punctuation + +/** @internalTechnology */ +const TUint __C=0x20; // Control character + +/** @internalTechnology */ +const TUint __X=0x40; // Hex digit + +/** @internalTechnology */ +const TUint __B=0x80; // A blank character + +#endif + +// +// Time set mode parameters for setting system time and offset +// +enum TTimeSetMode + { + ETimeSetTime = 1, // set the time to the value given, else leave it unchanged + ETimeSetOffset = 2, // set the offset to the value given, else leave it unchanged + ETimeSetAllowTimeReversal = 4, // allow time to go backwards + ETimeSetNoTimeUpdate = 8, // Don't restart second queue or notify changes - not valid with ESetTime, used early in boot only + ETimeSetLocalTime = 16, // Set time in local time, instead of UTC + ETimeSetSecure = 32, // use when setting the secure hardware clock + }; + +// +enum TMatchType {EMatchNormal,EMatchFolded,EMatchCollated}; + +// +// Constants for descriptor implementation code +// +enum TDesType {EBufC,EPtrC,EPtr,EBuf,EBufCPtr}; +const TUint KMaskDesLength=0xfffffff; +const TInt KShiftDesType=28; + +// +// Constants for iFlags in DProcess and DThread +// +const TUint KThreadFlagProcessCritical = 0x00000001; // thread panic panics process +const TUint KThreadFlagProcessPermanent = 0x00000002; // thread exit of any kind causes process to exit (=main) +const TUint KThreadFlagSystemCritical = 0x00000004; // thread panic reboots entire system +const TUint KThreadFlagSystemPermanent = 0x00000008; // thread exit of any kind reboots entire system +const TUint KThreadFlagOriginal = 0x00000010; +const TUint KThreadFlagLastChance = 0x00000020; +const TUint KThreadFlagRealtime = 0x00000040; // thread will be panicked when using some non-realtime functions +const TUint KThreadFlagRealtimeTest = 0x00000080; // non-realtime functions only warn rather than panic +const TUint KThreadFlagLocalThreadDataValid = 0x00000100; // thread has valid local thread data +const TUint KProcessFlagPriorityControl = 0x40000000; +const TUint KProcessFlagJustInTime = 0x80000000; +const TUint KProcessFlagSystemCritical = KThreadFlagSystemCritical; // process panic reboots entire system +const TUint KProcessFlagSystemPermanent = KThreadFlagSystemPermanent; // process exit of any kind reboots entire system +// +const TUint KThreadHandle=0x40000000; +// +struct SPtrC8 {TInt length;const TUint8 *ptr;}; +struct SBufC8 {TInt length;TUint8 buf[1];}; +struct SPtr8 {TInt length;TInt maxLength;TUint8 *ptr;}; +struct SBuf8 {TInt length;TInt maxLength;TUint8 buf[1];}; +struct SBufCPtr8 {TInt length;TInt maxLength;SBufC8 *ptr;}; + +struct SPtrC16 {TInt length;const TUint16 *ptr;}; +struct SBufC16 {TInt length;TUint16 buf[1];}; +struct SPtr16 {TInt length;TInt maxLength;TUint16 *ptr;}; +struct SBuf16 {TInt length;TInt maxLength;TUint16 buf[1];}; +struct SBufCPtr16 {TInt length;TInt maxLength;SBufC16 *ptr;}; + +// +// Flags used for IPC copy functions +// +const TInt KChunkShiftBy0=0; +const TInt KChunkShiftBy1=KMinTInt; +const TInt KIpcDirRead=0; +const TInt KIpcDirWrite=0x10000000; + +class TChunkCreate + { +public: + // Attributes for chunk creation that are used by both euser and the kernel + // by classes TChunkCreateInfo and SChunkCreateInfo, respectively. + enum TChunkCreateAtt + { + ENormal = 0x00000000, + EDoubleEnded = 0x00000001, + EDisconnected = 0x00000002, + ECache = 0x00000003, + EMappingMask = 0x0000000f, + ELocal = 0x00000000, + EGlobal = 0x00000010, + EData = 0x00000000, + ECode = 0x00000020, + EMemoryNotOwned = 0x00000040, + + // Force local chunk to be named. Only required for thread heap + // chunks, all other local chunks should be nameless. + ELocalNamed = 0x000000080, + + // Make global chunk read only to all processes but the controlling owner + EReadOnly = 0x000000100, + + // Paging attributes for chunks. + EPagingUnspec = 0x00000000, + EPaged = 0x80000000, + EUnpaged = 0x40000000, + EPagingMask = EPaged | EUnpaged, + + EChunkCreateAttMask = EMappingMask | EGlobal | ECode | + ELocalNamed | EReadOnly | EPagingMask, + }; +public: + TUint iAtt; + TBool iForceFixed; + TInt iInitialBottom; + TInt iInitialTop; + TInt iMaxSize; + TUint8 iClearByte; + }; + +enum TChunkRestrictions + { + // Keep this in sync with definitions in RChunk + EChunkPreventAdjust = 0x01, // Disallow Adjust, Commit, Allocate and Decommit + }; + +class TChannelDoCreate + { +public: + TVersion iVer; + const TDesC *iName; + const TDesC *iPhysicalDevice; + const TDesC8 *iInfo; + }; + +class TCreateSession + { +public: + TVersion iVer; + TInt iMessageSlots; + }; + +enum TObjectType + { + EThread=0, + EProcess, + EChunk, + ELibrary, + ESemaphore, + EMutex, + ETimer, + EServer, + ESession, + ELogicalDevice, + EPhysicalDevice, + ELogicalChannel, + EChangeNotifier, + EUndertaker, + EMsgQueue, + EPropertyRef, + ECondVar, + EShPool, + EShBuf, + ENumObjectTypes, // number of DObject-derived types + EObjectTypeAny=-1, + + EIpcMessageD=0x20, // lookup IPC message handle, allow disconnect + EIpcMessage=0x21, // lookup IPC message handle, don't allow disconnect + EIpcClient=0x22, // lookup IPC message client, don't allow disconnect + }; + +class TObjectOpenInfo + { +public: + TObjectType iObjType; + TBool isReadOnly; + }; + +class TChannelCreateInfo + { +public: + TVersion iVersion; + TInt iUnit; + const TDesC* iPhysicalDevice; + const TDesC8* iInfo; + }; + +#if defined(_UNICODE) && !defined(__KERNEL_MODE__) +class TChannelCreateInfo8 + { +public: + TVersion iVersion; + TInt iUnit; + const TDesC8* iPhysicalDevice; + const TDesC8* iInfo; + }; +#else +typedef TChannelCreateInfo TChannelCreateInfo8; +#endif + +const TInt KMaxThreadCreateInfo = 256; +struct SThreadCreateInfo + { + TAny* iHandle; + TInt iType; + TThreadFunction iFunction; + TAny* iPtr; + TAny* iSupervisorStack; + TInt iSupervisorStackSize; + TAny* iUserStack; + TInt iUserStackSize; + TInt iInitialThreadPriority; + TPtrC iName; + TInt iTotalSize; // Size including any extras (must be a multiple of 8 bytes) + }; + +enum TThreadCreationFlags + { + ETraceHeapAllocs = 0x00000001, + EMonitorHeapMemory = 0x00000002, + + EThreadCreateFlagPaged = 0x00000004, + EThreadCreateFlagUnpaged = 0x00000008, + EThreadCreateFlagPagingUnspec = 0x00000000, + EThreadCreateFlagPagingMask = EThreadCreateFlagPaged | EThreadCreateFlagUnpaged, + + EThreadCreateFlagMask = ETraceHeapAllocs | EMonitorHeapMemory | EThreadCreateFlagPagingMask, + }; + +struct SStdEpocThreadCreateInfo : public SThreadCreateInfo + { + SStdEpocThreadCreateInfo() + : iFlags(0) // Must be clear on creation. + { + }; + RAllocator* iAllocator; + TInt iHeapInitialSize; + TInt iHeapMaxSize; + TUint iFlags; + }; + +#if defined(_UNICODE) && !defined(__KERNEL_MODE__) +struct SThreadCreateInfo8 + { + TAny* iHandle; + TInt iType; + TThreadFunction iFunction; + TAny* iPtr; + TAny* iSupervisorStack; + TInt iSupervisorStackSize; + TAny* iUserStack; + TInt iUserStackSize; + TInt iInitialThreadPriority; + TPtrC8 iName; + TInt iTotalSize; // size including any extras + }; + +struct SStdEpocThreadCreateInfo8 : public SThreadCreateInfo8 + { + SStdEpocThreadCreateInfo8() + : iFlags(0) // Must be clear on creation. + { + }; + RAllocator* iAllocator; + TInt iHeapInitialSize; + TInt iHeapMaxSize; + TUint iFlags; + }; +#else +typedef SThreadCreateInfo SThreadCreateInfo8; +typedef SStdEpocThreadCreateInfo SStdEpocThreadCreateInfo8; +#endif + +struct SIpcCopyInfo + { + TUint8* iLocalPtr; + TInt iLocalLen; + TInt iFlags; + }; + +enum TChunkAdjust + { + EChunkAdjust=0, + EChunkAdjustDoubleEnded=1, + EChunkCommit=2, + EChunkDecommit=3, + EChunkAllocate=4, + EChunkUnlock=5, + EChunkLock=6 + }; + +enum TMemModelAttributes + { + EMemModelTypeMask=0xf, // bottom 4 bits give type of memory model + EMemModelTypeDirect=0, // direct memory model on hardware + EMemModelTypeMoving=1, // moving memory model on hardware + EMemModelTypeMultiple=2, // multiple memory model on hardware + EMemModelTypeEmul=3, // emulation using single host process + EMemModelTypeFlexible=4, // flexible memory model on hardware + + EMemModelAttrRomPaging=0x10, // Demand paging of XIP ROM + EMemModelAttrCodePaging=0x20, // Demand paging of RAM loaded code + EMemModelAttrDataPaging=0x40, // Demand paging of all RAM + EMemModelAttrPagingMask=0xf0, // Mask for demand paging attributes + + EMemModelAttrNonExProt=(TInt)0x80000000,// accesses to nonexistent addresses are trapped + EMemModelAttrKernProt=0x40000000, // accesses to kernel memory from user mode are trapped + EMemModelAttrWriteProt=0x20000000, // addresses can be marked as read-only; writes to these are trapped + EMemModelAttrVA=0x10000000, // system supports virtual addresses + EMemModelAttrProcessProt=0x08000000, // accesses to other processes' memory are trapped + EMemModelAttrSameVA=0x04000000, // different processes map the same virtual address to different physical addresses + EMemModelAttrSupportFixed=0x02000000, // 'fixed' processes are supported + EMemModelAttrSvKernProt=0x01000000, // unexpected accesses to kernel memory within an executive call are trapped + EMemModelAttrIPCKernProt=0x00800000, // accesses to kernel memory via IPC are trapped + EMemModelAttrIPCFullProt=0x00400000, // accesses via IPC have same protection as user mode + EMemModelAttrRamCodeProt=0x00200000, // RAM-loaded code is only visible to processes which have loaded it + }; + +/** @test */ +enum TKernelHeapDebugFunction {EDbgMarkStart,EDbgMarkCheck,EDbgMarkEnd,EDbgSetAllocFail,EDbgSetBurstAllocFail,EDbgCheckFailure}; + +/** @test */ +class TKernelHeapMarkCheckInfo + { +public: + TBool iCountAll; + const TDesC8* iFileName; + TInt iLineNum; + }; +// +class TTrapHandler; +class CActiveScheduler; +class TLocale; + +// +// +// +// Handler below is used by test prints to trucate rather than panic the caller. +// +#if defined(_UNICODE) && !defined(__KERNEL_MODE__) +NONSHARABLE_CLASS(TestOverflowTruncate) : public TDes16Overflow + { +public: + virtual void Overflow(TDes16 &aDes); + }; +#else +NONSHARABLE_CLASS(TestOverflowTruncate) : public TDes8Overflow + { +public: + virtual void Overflow(TDes8 &aDes); + }; +#endif +// + +/******************************************** + * Thread local storage entry + ********************************************/ +struct STls + { + TInt iHandle; + TInt iDllUid; + TAny* iPtr; + }; + +const TInt KDllUid_Default = 0; // for ROM DLLs and direct calls to UserSvr::DllTls +const TInt KDllUid_Special = -1; // used on emulator to instruct the kernel to get the DLL UID from the module handle + +/******************************************** + * Entry point call values + ********************************************/ +const TInt KModuleEntryReasonProcessInit =0; // Process start +const TInt KModuleEntryReasonThreadInit =1; // Start new thread +const TInt KModuleEntryReasonProcessAttach =2; // Process attach (init static data) +const TInt KModuleEntryReasonProcessDetach =3; // Process detach (destroy static data) +const TInt KModuleEntryReasonException =4; // Handle exception +const TInt KModuleEntryReasonVariantInit0 =-3; // Call variant static constructors + +/** @publishedPartner + @released +*/ +const TInt KModuleEntryReasonExtensionInit0 =-2; // Extension early initialisation check + +/** @publishedPartner + @released +*/ +const TInt KModuleEntryReasonExtensionInit1 =-1; // Extension initialisation + +/** + Flags returned by Exec::KernelConfigFlags() +*/ +enum TKernelConfigFlags + { + EKernelConfigIpcV1Available = 1<<0, + EKernelConfigPlatSecEnforcement = 1<<1, + EKernelConfigPlatSecDiagnostics = 1<<2, + EKernelConfigPlatSecProcessIsolation = 1<<3, + EKernelConfigPlatSecEnforceSysBin = 1<<4, + + // paging policy values use by 2-bit code and data paging policy enums... + EKernelConfigPagingPolicyNoPaging = 0, + EKernelConfigPagingPolicyAlwaysPage = 1, + EKernelConfigPagingPolicyDefaultUnpaged = 2, + EKernelConfigPagingPolicyDefaultPaged = 3, + + EKernelConfigCodePagingPolicyShift = 5, + EKernelConfigCodePagingPolicyMask = 3<<5, + EKernelConfigCodePagingPolicyNoPaging = EKernelConfigPagingPolicyNoPaging<<5, + EKernelConfigCodePagingPolicyAlwaysPage = EKernelConfigPagingPolicyAlwaysPage<<5, + EKernelConfigCodePagingPolicyDefaultUnpaged = EKernelConfigPagingPolicyDefaultUnpaged<<5, + EKernelConfigCodePagingPolicyDefaultPaged = EKernelConfigPagingPolicyDefaultPaged<<5, + + EKernelConfigPlatSecLocked = 1<<7, // Primarily used by __PLATSEC_UNLOCKED__ (q.v.) test code + + EKernelConfigCrazyScheduling = 1<<8, // Enables thread priority/timeslice craziness + + EKernelConfigDataPagingPolicyShift = 9, + EKernelConfigDataPagingPolicyMask = 3<<9, + EKernelConfigDataPagingPolicyNoPaging = EKernelConfigPagingPolicyNoPaging<<9, + EKernelConfigDataPagingPolicyAlwaysPage = EKernelConfigPagingPolicyAlwaysPage<<9, + EKernelConfigDataPagingPolicyDefaultUnpaged = EKernelConfigPagingPolicyDefaultUnpaged<<9, + EKernelConfigDataPagingPolicyDefaultPaged = EKernelConfigPagingPolicyDefaultPaged<<9, + + EKernelConfigSMPUnsafeCompat = 1<<12, // Enables compatibility mode for SMP-unsafe processes + EKernelConfigSMPUnsafeCPU0 = 1<<13, // Slow compatibility mode: all SMP-unsafe processes run on CPU 0 only + EKernelConfigSMPCrazyInterrupts = 1<<14, // Enables CPU target rotation for HW Interrupts. + + EKernelConfigDisableAPs = 1u<<30, + + EKernelConfigTest = 1u<<31, // Only used by test code for __PLATSEC_UNLOCKED__ + }; + +/** + If __PLATSEC_UNLOCKED__ is not defined, these flags must always + be considered to be set. See KernelConfigFlags() in kern_priv.h. + + @see KernelConfigFlags() + + @internalTechnology +*/ +#ifdef __PLATSEC_UNLOCKED__ +#define __PLATSEC_FORCED_FLAGS__ 0 +#else +#define __PLATSEC_FORCED_FLAGS__ (EKernelConfigPlatSecEnforcement|EKernelConfigPlatSecProcessIsolation|EKernelConfigPlatSecEnforceSysBin) +#endif + +/** +@internalTechnology +*/ +enum TGlobalUserData + { + ELocaleDefaultCharSet, + ELocalePreferredCharSet, + EMaxGlobalUserData + }; + +typedef void (*TGlobalDestructorFunc)(void); + +// This must not conflict with any possible valid TLS keys +const TInt KGlobalDestructorTlsKey = -1; + +GLREF_C void ExitCurrentThread(TExitType, TInt, const TDesC8*); + +#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__ +/** +@internalTechnology +*/ +class TPlatSecDiagnostic + { +public: + enum TType + { + ELoaderCapabilityViolation1, + ELoaderCapabilityViolation2, + EThreadCapabilityCheckFail, + EProcessCapabilityCheckFail, + EKernelSecureIdCheckFail, + EKernelObjectPolicyCheckFail, + EHandleCapabilityCheckFail, + ECreatorCapabilityCheckFail, + EMessageCapabilityCheckFail, + EKernelProcessIsolationFail, + EKernelProcessIsolationIPCFail, + ECreatorPolicyCheckFail, + }; +public: + inline TPlatSecDiagnostic(); + inline TPlatSecDiagnostic(TType aType); + inline TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2, const SCapabilitySet& aCaps); + inline TPlatSecDiagnostic(TType aType, TInt aInt1, const SSecurityInfo& aCaps); + inline TPlatSecDiagnostic(TType aType, TInt aInt, const TDesC8& aString, const SCapabilitySet& aCaps); + inline TPlatSecDiagnostic(TType aType, const TDesC8& aString1, const TDesC8& aString2, const SCapabilitySet& aCaps); + inline TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2); + inline TPlatSecDiagnostic(TType aType, TInt aInt1); + inline const TDesC8* String1(); + inline const TDesC8* String2(); +public: + TType iType; + TInt iArg1; + TInt iArg2; + const char* iContextText; + TInt iContextTextLength; + SSecurityInfo iSecurityInfo; + }; + +inline TPlatSecDiagnostic::TPlatSecDiagnostic() + {} + +inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType) + : iType(aType) + {} + +inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType,TInt aInt1) + : iType(aType), iArg1(aInt1) + {} + +inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2, const SCapabilitySet& aCaps) + : iType(aType), iArg1(aInt1), iArg2(aInt2), iContextText(0) + { + iSecurityInfo.iSecureId = 0; + iSecurityInfo.iVendorId = 0; + iSecurityInfo.iCaps = aCaps; + }; +inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt1, const SSecurityInfo& aInfo) + : iType(aType), iArg1(aInt1), iArg2(ECapability_None), iContextText(0), iSecurityInfo(aInfo) + { + }; + +inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt, const TDesC8& aString, const SCapabilitySet& aCaps) + : iType(aType), iArg1(aInt), iArg2((TInt)&aString), iContextText(0) + { + iSecurityInfo.iSecureId = 0; + iSecurityInfo.iVendorId = 0; + iSecurityInfo.iCaps = aCaps; + }; + +inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, const TDesC8& aString1, const TDesC8& aString2, const SCapabilitySet& aCaps) + : iType(aType), iArg1((TInt)&aString1), iArg2((TInt)&aString2), iContextText(0) + { + iSecurityInfo.iSecureId = 0; + iSecurityInfo.iVendorId = 0; + iSecurityInfo.iCaps = aCaps; + }; + +inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2) + : iType(aType), iArg1(aInt1), iArg2(aInt2) + { + iSecurityInfo.iSecureId = 0; + iSecurityInfo.iVendorId = 0; + iSecurityInfo.iCaps[0] = 0; + iSecurityInfo.iCaps[1] = 0; + }; + +inline const TDesC8* TPlatSecDiagnostic::String1() + { return (const TDesC8*)iArg1; } + +inline const TDesC8* TPlatSecDiagnostic::String2() + { return (const TDesC8*)iArg2; } + +inline TInt PlatSec::LoaderCapabilityViolation(const TDesC8& aImporterName, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::ELoaderCapabilityViolation2,aImporterName,aFileName,aMissingCaps); + return EmitDiagnostic(d, NULL); + } + +#ifdef __KERNEL_MODE__ + +inline TInt PlatSec::CapabilityCheckFail(const DProcess* aViolatingProcess, TCapability aCapability, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EProcessCapabilityCheckFail,(TInt)aViolatingProcess,(TInt)aCapability); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::CapabilityCheckFail(const DThread* aViolatingThread, TCapability aCapability, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EThreadCapabilityCheckFail,(TInt)aViolatingThread,(TInt)aCapability); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::SecureIdCheckFail(const DProcess* aViolatingProcess, TSecureId aSid, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelSecureIdCheckFail,(TInt)aViolatingProcess,(TInt)aSid); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::PolicyCheckFail(const DProcess* aProcess, const SSecurityInfo& aMissingSecurityInfo, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelObjectPolicyCheckFail,(TInt)aProcess,(const SSecurityInfo&)aMissingSecurityInfo); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::PolicyCheckFail(const DThread* aThread, const SSecurityInfo& aMissingSecurityInfo, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelObjectPolicyCheckFail,(TInt)aThread,(const SSecurityInfo&)aMissingSecurityInfo); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::ProcessIsolationFail(const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelProcessIsolationFail); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::ProcessIsolationIPCFail(RMessageK* aMessage, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelProcessIsolationIPCFail,(TInt)aMessage); + return EmitDiagnostic(d,aContextText); + } + +#else // !__KERNEL_MODE__ + +inline TInt PlatSec::LoaderCapabilityViolation(RProcess aLoadingProcess, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::ELoaderCapabilityViolation1,aLoadingProcess.Handle(),aFileName,aMissingCaps); + return EmitDiagnostic(d, NULL); + } + +inline TInt PlatSec::CreatorCapabilityCheckFail(TCapability aCapability, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::ECreatorCapabilityCheckFail,(TInt)0,aCapability); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::ECreatorCapabilityCheckFail,(TInt)0,ECapability_None,(const SCapabilitySet&)aMissingCaps); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::CapabilityCheckFail(TInt aHandle, TCapability aCapability, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EHandleCapabilityCheckFail,aHandle,aCapability); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EHandleCapabilityCheckFail,aHandle,ECapability_None,(const SCapabilitySet&)aMissingCaps); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissingSecurityInfo, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EHandleCapabilityCheckFail,aHandle,(const SSecurityInfo&)aMissingSecurityInfo); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EMessageCapabilityCheckFail,(TInt)aMessage.Handle(),aCapability); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EMessageCapabilityCheckFail,(TInt)aMessage.Handle(),ECapability_None,(const SCapabilitySet&)aMissingCaps); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissing, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::EMessageCapabilityCheckFail,(TInt)aMessage.Handle(),(const SSecurityInfo&)aMissing); + return EmitDiagnostic(d,aContextText); + } + +inline TInt PlatSec::CreatorPolicyCheckFail(const SSecurityInfo& aMissing, const char* aContextText) + { + TPlatSecDiagnostic d(TPlatSecDiagnostic::ECreatorPolicyCheckFail,(TInt)0,(const SSecurityInfo&)aMissing); + return EmitDiagnostic(d,aContextText); + } + +#endif //__KERNEL_MODE__ +#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__ + +const TInt KTlsArrayGranularity=2; + +#ifdef __CPU_HAS_CP15_THREAD_ID_REG + +#define __USERSIDE_THREAD_DATA__ + +class TLocalThreadData + { +public: + void Close(); +#ifndef __KERNEL_MODE__ + TAny* DllTls(TInt aHandle, TInt aDllUid); + TInt DllSetTls(TInt aHandle, TInt aDllUid, TAny* aPtr); + void DllFreeTls(TInt aHandle); +#endif +public: + RAllocator* iHeap; ///< The thread's current heap + CActiveScheduler* iScheduler; ///< The thread's current active scheduler + TTrapHandler* iTrapHandler; ///< The thread's current trap handler +private: + RAllocator* iTlsHeap; ///< The heap that the DLL TLS data is stored on + RArray iTls; ///< DLL TLS data + }; + +const TInt KLocalThreadDataSize = _ALIGN_UP(sizeof(TLocalThreadData), 8); + +#endif + +#ifdef __WINS__ + +enum TWin32RuntimeReason + { + // Same values as passed to DllMain + EWin32RuntimeProcessAttach = 1, + EWin32RuntimeThreadAttach = 2, + EWin32RuntimeThreadDetach = 3, + EWin32RuntimeProcessDetach = 4, + }; + +typedef TBool (*TWin32RuntimeHook)(TWin32RuntimeReason); + +#endif + +struct SAtomicOpInfo64 + { + TAny* iA; + TAny* iQ; + TUint64 i1; + TUint64 i2; + TUint64 i3; + }; + +struct SAtomicOpInfo32 + { + TAny* iA; + union + { + TAny* iQ; + TUint32 i0; + }; + TUint32 i1; + TUint32 i2; + }; + +#endif //__U32STD_H__