// 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 "Symbian Foundation License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32\include\u32std.h
//
//
/**
@file
@internalComponent
@released
*/
#ifndef __U32STD_H__
#define __U32STD_H__
#include <e32cmn.h>
#include <e32cmn_private.h>
#include <e32hal.h>
#include <e32lmsg.h>
#include <e32event.h>
#include <e32ldr.h>
#include <e32power.h>
#include <e32shbufcmn.h>
#include <e32property.h>
#include <u32property.h>
#include <u32hal.h>
#include <cpudefs.h>
#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 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:
enum TChunkCreateAtt
{
ENormal=0x00,
EDoubleEnded=0x01,
EDisconnected=0x02,
EMappingMask=0x0f,
ELocal=0x00,
EGlobal=0x10,
EData=0x00,
ECode=0x20,
EChunkCreateAttMask = EMappingMask | EGlobal | ECode,
};
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 EThreadCreationFlags
{
ETraceHeapAllocs = 1,
EMonitorHeapMemory = 2,
};
struct SStdEpocThreadCreateInfo : public SThreadCreateInfo
{
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
{
RAllocator* iAllocator;
TInt iHeapInitialSize;
TInt iHeapMaxSize;
TInt iPadding; // Make structure size a multiple of 8 bytes
};
#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,
EKernelConfigPagingPolicyMask = 3<<5,
EKernelConfigPagingPolicyNoPaging = 0<<5,
EKernelConfigPagingPolicyAlwaysPage = 1<<5,
EKernelConfigPagingPolicyDefaultUnpaged = 2<<5,
EKernelConfigPagingPolicyDefaultPaged = 3<<5,
EKernelConfigPlatSecLocked = 1<<7, // Primarily used by __PLATSEC_UNLOCKED__ (q.v.) test code
EKernelConfigCrazyScheduling = 1<<8, // Enables thread priority/timeslice craziness
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
#ifndef __TOOLS2__
#define __USERSIDE_THREAD_DATA__
#endif // __TOOLS2__
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:
#ifndef __TOOLS2__
RAllocator* iHeap; ///< The thread's current heap
#endif // __TOOLS2__
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<STls> 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__