Symaptic: os/kernelhwsrv/kernel/eka/include/u32std.h@bde4ae8d615e

     1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\include\u32std.h

    15 //

    16 //

    18 /**

    19  @file

    20  @internalComponent

    21  @released

    22 */

    24 #ifndef __U32STD_H__

    25 #define __U32STD_H__

    26 #include <e32cmn.h>

    27 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

    28 #include <e32cmn_private.h>

    29 #endif

    30 #include <e32hal.h>

    31 #include <e32lmsg.h>

    32 #include <e32event.h>

    33 #include <e32ldr.h>

    34 #include <e32ldr_private.h>

    35 #include <e32power.h>

    36 #include <e32shbufcmn.h>

    37 #include <e32property.h>

    38 #include <u32property.h>

    39 #include <u32hal.h>

    41 #include <cpudefs.h>

    43 #ifdef __MARM__

    44 #define	EKA2_ENTRY_POINT_VERSION_IDENTIFIER	\

    45 	asm("tst pc, #%a0" : : "i" ((TInt)0) )

    46 #endif

    48 struct TUnicodeDataSet;                 // forward declaration

    49 struct TCollationDataSet;               // forward declaration

    51 /*

    52 The LCharSet structure is used in Unicode builds to supply locale-specific

    53 character attribute and collation data.

    55 The structure is defined in both builds to avoid having to have a dummy ExecHandler::GetLocaleCharSet function

    56 with a different signature in the 8-bit build.

    57 */

    58 struct LCharSet

    59 	{

    60 	const TUnicodeDataSet* iCharDataSet;			// if non-null, character data overriding standard Unicode data

    61 	const TCollationDataSet* iCollationDataSet;		// if non-null, locale-specific collation data

    62 	};

    64 extern const LCharSet* GetLocaleCharSet();

    66 /** @internalTechnology */

    67 const TInt KNumLocaleExports = 22;

    69 //

    70 // The bits in the type table (non-Unicode build only)

    71 //

    72 #ifndef _UNICODE

    74 /** @internalTechnology */

    75 const TUint __U=0x01; // Uppercase letter

    77 /** @internalTechnology */

    78 const TUint __L=0x02; // Lowercase letter

    80 /** @internalTechnology */

    81 const TUint __D=0x04; // Decimal digit

    83 /** @internalTechnology */

    84 const TUint __S=0x08; // Space

    86 /** @internalTechnology */

    87 const TUint __P=0x10; // Punctuation

    89 /** @internalTechnology */

    90 const TUint __C=0x20; // Control character

    92 /** @internalTechnology */

    93 const TUint __X=0x40; // Hex digit

    95 /** @internalTechnology */

    96 const TUint __B=0x80; // A blank character

    98 #endif

   100 //

   101 // Time set mode parameters for setting system time and offset

   102 //

   103 enum TTimeSetMode

   104 	{

   105 	ETimeSetTime = 1,    // set the time to the value given, else leave it unchanged

   106 	ETimeSetOffset = 2,  // set the offset to the value given, else leave it unchanged

   107 	ETimeSetAllowTimeReversal = 4,  // allow time to go backwards

   108 	ETimeSetNoTimeUpdate = 8,       // Don't restart second queue or notify changes - not valid with ESetTime, used early in boot only

   109 	ETimeSetLocalTime = 16,			// Set time in local time, instead of UTC

   110 	ETimeSetSecure = 32,  // use when setting the secure hardware clock

   111 	};

   113 //

   114 enum TMatchType {EMatchNormal,EMatchFolded,EMatchCollated};

   116 //

   117 // Constants for descriptor implementation code

   118 //

   119 enum TDesType {EBufC,EPtrC,EPtr,EBuf,EBufCPtr};

   120 const TUint KMaskDesLength=0xfffffff;

   121 const TInt KShiftDesType=28;

   123 //

   124 // Constants for iFlags in DProcess and DThread

   125 //

   126 const TUint KThreadFlagProcessCritical		= 0x00000001;	// thread panic panics process

   127 const TUint KThreadFlagProcessPermanent		= 0x00000002;	// thread exit of any kind causes process to exit (=main)

   128 const TUint KThreadFlagSystemCritical		= 0x00000004;	// thread panic reboots entire system

   129 const TUint KThreadFlagSystemPermanent		= 0x00000008;	// thread exit of any kind reboots entire system

   130 const TUint KThreadFlagOriginal				= 0x00000010;

   131 const TUint KThreadFlagLastChance			= 0x00000020;

   132 const TUint KThreadFlagRealtime				= 0x00000040;	// thread will be panicked when using some non-realtime functions

   133 const TUint KThreadFlagRealtimeTest			= 0x00000080;	// non-realtime functions only warn rather than panic

   134 const TUint KThreadFlagLocalThreadDataValid	= 0x00000100;	// thread has valid local thread data

   135 const TUint KProcessFlagPriorityControl		= 0x40000000;

   136 const TUint KProcessFlagJustInTime			= 0x80000000;

   137 const TUint KProcessFlagSystemCritical		= KThreadFlagSystemCritical;	// process panic reboots entire system

   138 const TUint KProcessFlagSystemPermanent		= KThreadFlagSystemPermanent;	// process exit of any kind reboots entire system

   139 //

   140 const TUint KThreadHandle=0x40000000;

   141 //

   142 struct SPtrC8 {TInt length;const TUint8 *ptr;};

   143 struct SBufC8 {TInt length;TUint8 buf[1];};

   144 struct SPtr8 {TInt length;TInt maxLength;TUint8 *ptr;};

   145 struct SBuf8 {TInt length;TInt maxLength;TUint8 buf[1];};

   146 struct SBufCPtr8 {TInt length;TInt maxLength;SBufC8 *ptr;};

   148 struct SPtrC16 {TInt length;const TUint16 *ptr;};

   149 struct SBufC16 {TInt length;TUint16 buf[1];};

   150 struct SPtr16 {TInt length;TInt maxLength;TUint16 *ptr;};

   151 struct SBuf16 {TInt length;TInt maxLength;TUint16 buf[1];};

   152 struct SBufCPtr16 {TInt length;TInt maxLength;SBufC16 *ptr;};

   154 //

   155 // Flags used for IPC copy functions

   156 //

   157 const TInt KChunkShiftBy0=0;

   158 const TInt KChunkShiftBy1=KMinTInt;

   159 const TInt KIpcDirRead=0;

   160 const TInt KIpcDirWrite=0x10000000;

   162 class TChunkCreate

   163 	{

   164 public:

   165 	// Attributes for chunk creation that are used by both euser and the kernel

   166 	// by classes TChunkCreateInfo and SChunkCreateInfo, respectively.

   167 	enum TChunkCreateAtt

   168 		{

   169 		ENormal				= 0x00000000,

   170 		EDoubleEnded		= 0x00000001,

   171 		EDisconnected		= 0x00000002,

   172 		ECache				= 0x00000003,

   173 		EMappingMask		= 0x0000000f,

   174 		ELocal				= 0x00000000,

   175 		EGlobal				= 0x00000010,

   176 		EData				= 0x00000000,

   177 		ECode				= 0x00000020,

   178 		EMemoryNotOwned		= 0x00000040,

   180 		// Force local chunk to be named.  Only required for thread heap

   181 		// chunks, all other local chunks should be nameless.

   182 		ELocalNamed 		= 0x000000080,

   184 		// Make global chunk read only to all processes but the controlling owner

   185 		EReadOnly			= 0x000000100,

   187 		// Paging attributes for chunks.

   188 		EPagingUnspec		= 0x00000000,

   189 		EPaged				= 0x80000000,

   190 		EUnpaged			= 0x40000000,

   191 		EPagingMask 		= EPaged | EUnpaged,

   193 		EChunkCreateAttMask =	EMappingMask | EGlobal | ECode |

   194 								ELocalNamed | EReadOnly | EPagingMask,

   195 		};

   196 public:

   197 	TUint iAtt;

   198 	TBool iForceFixed;

   199 	TInt iInitialBottom;

   200 	TInt iInitialTop;

   201 	TInt iMaxSize;

   202 	TUint8 iClearByte;

   203 	};

   205 enum TChunkRestrictions

   206 	{

   207 	// Keep this in sync with definitions in RChunk

   208 	EChunkPreventAdjust = 0x01,  // Disallow Adjust, Commit, Allocate and Decommit

   209 	};

   211 class TChannelDoCreate

   212 	{

   213 public:

   214 	TVersion iVer;

   215 	const TDesC *iName;

   216 	const TDesC *iPhysicalDevice;

   217 	const TDesC8 *iInfo;

   218 	};

   220 class TCreateSession

   221 	{

   222 public:

   223 	TVersion iVer;

   224 	TInt iMessageSlots;

   225 	};

   227 enum TObjectType

   228 	{

   229 	EThread=0,

   230 	EProcess,

   231 	EChunk,

   232 	ELibrary,

   233 	ESemaphore,

   234 	EMutex,

   235 	ETimer,

   236 	EServer,

   237 	ESession,

   238 	ELogicalDevice,

   239 	EPhysicalDevice,

   240 	ELogicalChannel,

   241 	EChangeNotifier,

   242 	EUndertaker,

   243 	EMsgQueue,

   244 	EPropertyRef,

   245 	ECondVar,

   246 	EShPool,

   247 	EShBuf,

   248 	ENumObjectTypes,	// number of DObject-derived types

   249 	EObjectTypeAny=-1,

   251 	EIpcMessageD=0x20,	// lookup IPC message handle, allow disconnect

   252 	EIpcMessage=0x21,	// lookup IPC message handle, don't allow disconnect

   253 	EIpcClient=0x22,	// lookup IPC message client, don't allow disconnect

   254 	};

   256 class TObjectOpenInfo

   257 	{

   258 public:

   259 	TObjectType iObjType;

   260 	TBool isReadOnly;

   261 	};

   263 class TChannelCreateInfo

   264 	{

   265 public:

   266 	TVersion iVersion;

   267 	TInt iUnit;

   268 	const TDesC* iPhysicalDevice;

   269 	const TDesC8* iInfo;

   270 	};

   272 #if defined(_UNICODE) && !defined(__KERNEL_MODE__)

   273 class TChannelCreateInfo8

   274 	{

   275 public:

   276 	TVersion iVersion;

   277 	TInt iUnit;

   278 	const TDesC8* iPhysicalDevice;

   279 	const TDesC8* iInfo;

   280 	};

   281 #else

   282 typedef TChannelCreateInfo TChannelCreateInfo8;

   283 #endif

   285 const TInt KMaxThreadCreateInfo = 256;

   286 struct SThreadCreateInfo

   287 	{

   288 	TAny* iHandle;

   289 	TInt iType;

   290 	TThreadFunction iFunction;

   291 	TAny* iPtr;

   292 	TAny* iSupervisorStack;

   293 	TInt iSupervisorStackSize;

   294 	TAny* iUserStack;

   295 	TInt iUserStackSize;

   296 	TInt iInitialThreadPriority;

   297 	TPtrC iName;

   298 	TInt iTotalSize;	// Size including any extras (must be a multiple of 8 bytes)

   299 	};

   301 enum TThreadCreationFlags

   302 	{

   303 	ETraceHeapAllocs 				= 0x00000001,

   304 	EMonitorHeapMemory				= 0x00000002,

   306 	EThreadCreateFlagPaged			= 0x00000004,

   307 	EThreadCreateFlagUnpaged		= 0x00000008,

   308 	EThreadCreateFlagPagingUnspec	= 0x00000000,

   309 	EThreadCreateFlagPagingMask	= EThreadCreateFlagPaged | EThreadCreateFlagUnpaged,

   311 	EThreadCreateFlagMask = ETraceHeapAllocs | EMonitorHeapMemory | EThreadCreateFlagPagingMask,

   312 	};

   314 struct SStdEpocThreadCreateInfo : public SThreadCreateInfo

   315 	{

   316 	SStdEpocThreadCreateInfo()

   317 		: iFlags(0)	// Must be clear on creation.

   318 		{

   319 		};

   320 	RAllocator* iAllocator;

   321 	TInt iHeapInitialSize;

   322 	TInt iHeapMaxSize;

   323 	TUint iFlags;

   324 	};

   326 #if defined(_UNICODE) && !defined(__KERNEL_MODE__)

   327 struct SThreadCreateInfo8

   328 	{

   329 	TAny* iHandle;

   330 	TInt iType;

   331 	TThreadFunction iFunction;

   332 	TAny* iPtr;

   333 	TAny* iSupervisorStack;

   334 	TInt iSupervisorStackSize;

   335 	TAny* iUserStack;

   336 	TInt iUserStackSize;

   337 	TInt iInitialThreadPriority;

   338 	TPtrC8 iName;

   339 	TInt iTotalSize;	// size including any extras

   340 	};

   342 struct SStdEpocThreadCreateInfo8 : public SThreadCreateInfo8

   343 	{

   344 	SStdEpocThreadCreateInfo8()

   345 		: iFlags(0) // Must be clear on creation.

   346 		{

   347 		};

   348 	RAllocator* iAllocator;

   349 	TInt iHeapInitialSize;

   350 	TInt iHeapMaxSize;

   351 	TUint iFlags;

   352 	};

   353 #else

   354 typedef SThreadCreateInfo SThreadCreateInfo8;

   355 typedef SStdEpocThreadCreateInfo SStdEpocThreadCreateInfo8;

   356 #endif

   358 struct SIpcCopyInfo

   359 	{

   360 	TUint8* iLocalPtr;

   361 	TInt iLocalLen;

   362 	TInt iFlags;

   363 	};

   365 enum TChunkAdjust

   366 	{

   367 	EChunkAdjust=0,

   368 	EChunkAdjustDoubleEnded=1,

   369 	EChunkCommit=2,

   370 	EChunkDecommit=3,

   371 	EChunkAllocate=4,

   372 	EChunkUnlock=5,

   373 	EChunkLock=6

   374 	};

   376 enum TMemModelAttributes

   377 	{

   378 	EMemModelTypeMask=0xf,					// bottom 4 bits give type of memory model

   379 	EMemModelTypeDirect=0,					// direct memory model on hardware

   380 	EMemModelTypeMoving=1,					// moving memory model on hardware

   381 	EMemModelTypeMultiple=2,				// multiple memory model on hardware

   382 	EMemModelTypeEmul=3,					// emulation using single host process

   383 	EMemModelTypeFlexible=4,				// flexible memory model on hardware

   385 	EMemModelAttrRomPaging=0x10,			// Demand paging of XIP ROM

   386 	EMemModelAttrCodePaging=0x20,			// Demand paging of RAM loaded code

   387 	EMemModelAttrDataPaging=0x40,			// Demand paging of all RAM

   388 	EMemModelAttrPagingMask=0xf0,			// Mask for demand paging attributes

   390 	EMemModelAttrNonExProt=(TInt)0x80000000,// accesses to nonexistent addresses are trapped

   391 	EMemModelAttrKernProt=0x40000000,		// accesses to kernel memory from user mode are trapped

   392 	EMemModelAttrWriteProt=0x20000000,		// addresses can be marked as read-only; writes to these are trapped

   393 	EMemModelAttrVA=0x10000000,				// system supports virtual addresses

   394 	EMemModelAttrProcessProt=0x08000000,	// accesses to other processes' memory are trapped

   395 	EMemModelAttrSameVA=0x04000000,			// different processes map the same virtual address to different physical addresses

   396 	EMemModelAttrSupportFixed=0x02000000,	// 'fixed' processes are supported

   397 	EMemModelAttrSvKernProt=0x01000000,		// unexpected accesses to kernel memory within an executive call are trapped

   398 	EMemModelAttrIPCKernProt=0x00800000,	// accesses to kernel memory via IPC are trapped

   399 	EMemModelAttrIPCFullProt=0x00400000,	// accesses via IPC have same protection as user mode

   400 	EMemModelAttrRamCodeProt=0x00200000,	// RAM-loaded code is only visible to processes which have loaded it

   401 	};

   403 /** @test */

   404 enum TKernelHeapDebugFunction {EDbgMarkStart,EDbgMarkCheck,EDbgMarkEnd,EDbgSetAllocFail,EDbgSetBurstAllocFail,EDbgCheckFailure};

   406 /** @test */

   407 class TKernelHeapMarkCheckInfo

   408 	{

   409 public:

   410 	TBool iCountAll;

   411 	const TDesC8* iFileName;

   412 	TInt iLineNum;

   413 	};

   414 //

   415 class TTrapHandler;

   416 class CActiveScheduler;

   417 class TLocale;

   419 //

   420 //

   421 //

   422 // Handler below is used by test prints to trucate rather than panic the caller.

   423 //

   424 #if defined(_UNICODE) && !defined(__KERNEL_MODE__)

   425 NONSHARABLE_CLASS(TestOverflowTruncate) : public TDes16Overflow

   426 	{

   427 public:

   428 	virtual void Overflow(TDes16 &aDes);

   429 	};

   430 #else

   431 NONSHARABLE_CLASS(TestOverflowTruncate) : public TDes8Overflow

   432 	{

   433 public:

   434 	virtual void Overflow(TDes8 &aDes);

   435 	};

   436 #endif

   437 //

   439 /********************************************

   440  * Thread local storage entry

   441  ********************************************/

   442 struct STls

   443 	{

   444 	TInt	iHandle;

   445 	TInt	iDllUid;

   446 	TAny*	iPtr;

   447 	};

   449 const TInt KDllUid_Default = 0;		// for ROM DLLs and direct calls to UserSvr::DllTls

   450 const TInt KDllUid_Special = -1;	// used on emulator to instruct the kernel to get the DLL UID from the module handle

   452 /********************************************

   453  * Entry point call values

   454  ********************************************/

   455 const TInt	KModuleEntryReasonProcessInit		=0;		// Process start

   456 const TInt	KModuleEntryReasonThreadInit		=1;		// Start new thread

   457 const TInt	KModuleEntryReasonProcessAttach		=2;		// Process attach (init static data)

   458 const TInt	KModuleEntryReasonProcessDetach		=3;		// Process detach (destroy static data)

   459 const TInt	KModuleEntryReasonException			=4;		// Handle exception

   460 const TInt	KModuleEntryReasonVariantInit0		=-3;	// Call variant static constructors

   462 /** @publishedPartner

   463 	@released

   464 */

   465 const TInt	KModuleEntryReasonExtensionInit0	=-2;	// Extension early initialisation check

   467 /** @publishedPartner

   468 	@released

   469 */

   470 const TInt	KModuleEntryReasonExtensionInit1	=-1;	// Extension initialisation

   472 /**

   473 	Flags returned by Exec::KernelConfigFlags()

   474 */

   475 enum TKernelConfigFlags

   476 	{

   477 	EKernelConfigIpcV1Available = 1<<0,

   478 	EKernelConfigPlatSecEnforcement = 1<<1,

   479 	EKernelConfigPlatSecDiagnostics = 1<<2,

   480 	EKernelConfigPlatSecProcessIsolation = 1<<3,

   481 	EKernelConfigPlatSecEnforceSysBin = 1<<4,

   483 	// paging policy values use by 2-bit code and data paging policy enums...

   484 	EKernelConfigPagingPolicyNoPaging = 0,

   485 	EKernelConfigPagingPolicyAlwaysPage = 1,

   486 	EKernelConfigPagingPolicyDefaultUnpaged = 2,

   487 	EKernelConfigPagingPolicyDefaultPaged = 3,

   489 	EKernelConfigCodePagingPolicyShift			= 5,

   490 	EKernelConfigCodePagingPolicyMask			= 3<<5,

   491 	EKernelConfigCodePagingPolicyNoPaging		= EKernelConfigPagingPolicyNoPaging<<5,

   492 	EKernelConfigCodePagingPolicyAlwaysPage		= EKernelConfigPagingPolicyAlwaysPage<<5,

   493 	EKernelConfigCodePagingPolicyDefaultUnpaged	= EKernelConfigPagingPolicyDefaultUnpaged<<5,

   494 	EKernelConfigCodePagingPolicyDefaultPaged	= EKernelConfigPagingPolicyDefaultPaged<<5,

   496 	EKernelConfigPlatSecLocked = 1<<7,					// Primarily used by __PLATSEC_UNLOCKED__ (q.v.) test code

   498 	EKernelConfigCrazyScheduling = 1<<8,				// Enables thread priority/timeslice craziness

   500 	EKernelConfigDataPagingPolicyShift			= 9,

   501 	EKernelConfigDataPagingPolicyMask			= 3<<9,

   502 	EKernelConfigDataPagingPolicyNoPaging		= EKernelConfigPagingPolicyNoPaging<<9,

   503 	EKernelConfigDataPagingPolicyAlwaysPage		= EKernelConfigPagingPolicyAlwaysPage<<9,

   504 	EKernelConfigDataPagingPolicyDefaultUnpaged	= EKernelConfigPagingPolicyDefaultUnpaged<<9,

   505 	EKernelConfigDataPagingPolicyDefaultPaged	= EKernelConfigPagingPolicyDefaultPaged<<9,

   507 	EKernelConfigSMPUnsafeCompat = 1<<12,				// Enables compatibility mode for SMP-unsafe processes

   508 	EKernelConfigSMPUnsafeCPU0   = 1<<13,				// Slow compatibility mode: all SMP-unsafe processes run on CPU 0 only

   509 	EKernelConfigSMPCrazyInterrupts = 1<<14,			// Enables CPU target rotation for HW Interrupts.

   511 	EKernelConfigDisableAPs = 1u<<30,

   513 	EKernelConfigTest = 1u<<31,							// Only used by test code for __PLATSEC_UNLOCKED__

   514 	};

   516 /**

   517 	If __PLATSEC_UNLOCKED__ is not defined, these flags must always

   518 	be considered to be set.  See KernelConfigFlags() in kern_priv.h.

   520 	@see KernelConfigFlags()

   522 	@internalTechnology

   523 */

   524 #ifdef __PLATSEC_UNLOCKED__

   525 #define __PLATSEC_FORCED_FLAGS__	 0

   526 #else

   527 #define __PLATSEC_FORCED_FLAGS__	(EKernelConfigPlatSecEnforcement|EKernelConfigPlatSecProcessIsolation|EKernelConfigPlatSecEnforceSysBin)

   528 #endif

   530 /**

   531 @internalTechnology

   532 */

   533 enum TGlobalUserData

   534 	{

   535 	ELocaleDefaultCharSet,

   536 	ELocalePreferredCharSet,

   537 	EMaxGlobalUserData

   538 	};

   540 typedef void (*TGlobalDestructorFunc)(void);

   542 // This must not conflict with any possible valid TLS keys

   543 const TInt KGlobalDestructorTlsKey = -1;

   545 GLREF_C void ExitCurrentThread(TExitType, TInt, const TDesC8*);

   547 #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__

   548 /**

   549 @internalTechnology

   550 */

   551 class TPlatSecDiagnostic

   552 	{

   553 public:

   554 	enum TType

   555 		{

   556 		ELoaderCapabilityViolation1,

   557 		ELoaderCapabilityViolation2,

   558 		EThreadCapabilityCheckFail,

   559 		EProcessCapabilityCheckFail,

   560 		EKernelSecureIdCheckFail,

   561 		EKernelObjectPolicyCheckFail,

   562 		EHandleCapabilityCheckFail,

   563 		ECreatorCapabilityCheckFail,

   564 		EMessageCapabilityCheckFail,

   565 		EKernelProcessIsolationFail,

   566 		EKernelProcessIsolationIPCFail,

   567 		ECreatorPolicyCheckFail,

   568 		};

   569 public:

   570 	inline TPlatSecDiagnostic();

   571 	inline TPlatSecDiagnostic(TType aType);

   572 	inline TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2, const SCapabilitySet& aCaps);

   573 	inline TPlatSecDiagnostic(TType aType, TInt aInt1, const SSecurityInfo& aCaps);

   574 	inline TPlatSecDiagnostic(TType aType, TInt aInt, const TDesC8& aString, const SCapabilitySet& aCaps);

   575 	inline TPlatSecDiagnostic(TType aType, const TDesC8& aString1, const TDesC8& aString2, const SCapabilitySet& aCaps);

   576 	inline TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2);

   577 	inline TPlatSecDiagnostic(TType aType, TInt aInt1);

   578 	inline const TDesC8* String1();

   579 	inline const TDesC8* String2();

   580 public:

   581 	TType iType;

   582 	TInt iArg1;

   583 	TInt iArg2;

   584 	const char* iContextText;

   585 	TInt iContextTextLength;

   586 	SSecurityInfo iSecurityInfo;

   587 	};

   589 inline TPlatSecDiagnostic::TPlatSecDiagnostic()

   590 	{}

   592 inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType)

   593 	: iType(aType)

   594 	{}

   596 inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType,TInt aInt1)

   597 	: iType(aType), iArg1(aInt1)

   598 	{}

   600 inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2, const SCapabilitySet& aCaps)

   601 	: iType(aType), iArg1(aInt1), iArg2(aInt2), iContextText(0)

   602 	{

   603 	iSecurityInfo.iSecureId = 0;

   604 	iSecurityInfo.iVendorId = 0;

   605 	iSecurityInfo.iCaps = aCaps;

   606 	};

   607 inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt1, const SSecurityInfo& aInfo)

   608 	: iType(aType), iArg1(aInt1), iArg2(ECapability_None), iContextText(0), iSecurityInfo(aInfo)

   609 	{

   610 	};

   612 inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt, const TDesC8& aString, const SCapabilitySet& aCaps)

   613 	: iType(aType), iArg1(aInt), iArg2((TInt)&aString), iContextText(0)

   614 	{

   615 	iSecurityInfo.iSecureId = 0;

   616 	iSecurityInfo.iVendorId = 0;

   617 	iSecurityInfo.iCaps = aCaps;

   618 	};

   620 inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, const TDesC8& aString1, const TDesC8& aString2, const SCapabilitySet& aCaps)

   621 	: iType(aType), iArg1((TInt)&aString1), iArg2((TInt)&aString2), iContextText(0)

   622 	{

   623 	iSecurityInfo.iSecureId = 0;

   624 	iSecurityInfo.iVendorId = 0;

   625 	iSecurityInfo.iCaps = aCaps;

   626 	};

   628 inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2)

   629 	: iType(aType), iArg1(aInt1), iArg2(aInt2)

   630 	{

   631 	iSecurityInfo.iSecureId = 0;

   632 	iSecurityInfo.iVendorId = 0;

   633 	iSecurityInfo.iCaps[0] = 0;

   634 	iSecurityInfo.iCaps[1] = 0;

   635 	};

   637 inline const TDesC8* TPlatSecDiagnostic::String1()

   638 	{ return (const TDesC8*)iArg1; }

   640 inline const TDesC8* TPlatSecDiagnostic::String2()

   641 	{ return (const TDesC8*)iArg2; }

   643 inline TInt PlatSec::LoaderCapabilityViolation(const TDesC8& aImporterName, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps)

   644 	{

   645 	TPlatSecDiagnostic d(TPlatSecDiagnostic::ELoaderCapabilityViolation2,aImporterName,aFileName,aMissingCaps);

   646 	return EmitDiagnostic(d, NULL);

   647 	}

   649 #ifdef __KERNEL_MODE__

   651 inline TInt PlatSec::CapabilityCheckFail(const DProcess* aViolatingProcess, TCapability aCapability, const char* aContextText)

   652 	{

   653 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EProcessCapabilityCheckFail,(TInt)aViolatingProcess,(TInt)aCapability);

   654 	return EmitDiagnostic(d,aContextText);

   655 	}

   657 inline TInt PlatSec::CapabilityCheckFail(const DThread* aViolatingThread, TCapability aCapability, const char* aContextText)

   658 	{

   659 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EThreadCapabilityCheckFail,(TInt)aViolatingThread,(TInt)aCapability);

   660 	return EmitDiagnostic(d,aContextText);

   661 	}

   663 inline TInt PlatSec::SecureIdCheckFail(const DProcess* aViolatingProcess, TSecureId aSid, const char* aContextText)

   664 	{

   665 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelSecureIdCheckFail,(TInt)aViolatingProcess,(TInt)aSid);

   666 	return EmitDiagnostic(d,aContextText);

   667 	}

   669 inline TInt PlatSec::PolicyCheckFail(const DProcess* aProcess, const SSecurityInfo& aMissingSecurityInfo, const char* aContextText)

   670 	{

   671 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelObjectPolicyCheckFail,(TInt)aProcess,(const SSecurityInfo&)aMissingSecurityInfo);

   672 	return EmitDiagnostic(d,aContextText);

   673 	}

   675 inline TInt PlatSec::PolicyCheckFail(const DThread* aThread, const SSecurityInfo& aMissingSecurityInfo, const char* aContextText)

   676 	{

   677 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelObjectPolicyCheckFail,(TInt)aThread,(const SSecurityInfo&)aMissingSecurityInfo);

   678 	return EmitDiagnostic(d,aContextText);

   679 	}

   681 inline TInt PlatSec::ProcessIsolationFail(const char* aContextText)

   682 	{

   683 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelProcessIsolationFail);

   684 	return EmitDiagnostic(d,aContextText);

   685 	}

   687 inline TInt PlatSec::ProcessIsolationIPCFail(RMessageK* aMessage, const char* aContextText)

   688 	{

   689 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelProcessIsolationIPCFail,(TInt)aMessage);

   690 	return EmitDiagnostic(d,aContextText);

   691 	}

   693 #else // !__KERNEL_MODE__

   695 inline TInt PlatSec::LoaderCapabilityViolation(RProcess aLoadingProcess, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps)

   696 	{

   697 	TPlatSecDiagnostic d(TPlatSecDiagnostic::ELoaderCapabilityViolation1,aLoadingProcess.Handle(),aFileName,aMissingCaps);

   698 	return EmitDiagnostic(d, NULL);

   699 	}

   701 inline TInt PlatSec::CreatorCapabilityCheckFail(TCapability aCapability, const char* aContextText)

   702 	{

   703 	TPlatSecDiagnostic d(TPlatSecDiagnostic::ECreatorCapabilityCheckFail,(TInt)0,aCapability);

   704 	return EmitDiagnostic(d,aContextText);

   705 	}

   707 inline TInt PlatSec::CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps, const char* aContextText)

   708 	{

   709 	TPlatSecDiagnostic d(TPlatSecDiagnostic::ECreatorCapabilityCheckFail,(TInt)0,ECapability_None,(const SCapabilitySet&)aMissingCaps);

   710 	return EmitDiagnostic(d,aContextText);

   711 	}

   713 inline TInt PlatSec::CapabilityCheckFail(TInt aHandle, TCapability aCapability, const char* aContextText)

   714 	{

   715 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EHandleCapabilityCheckFail,aHandle,aCapability);

   716 	return EmitDiagnostic(d,aContextText);

   717 	}

   719 inline TInt PlatSec::CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps, const char* aContextText)

   720 	{

   721 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EHandleCapabilityCheckFail,aHandle,ECapability_None,(const SCapabilitySet&)aMissingCaps);

   722 	return EmitDiagnostic(d,aContextText);

   723 	}

   725 inline TInt PlatSec::PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissingSecurityInfo, const char* aContextText)

   726 	{

   727 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EHandleCapabilityCheckFail,aHandle,(const SSecurityInfo&)aMissingSecurityInfo);

   728 	return EmitDiagnostic(d,aContextText);

   729 	}

   731 inline TInt PlatSec::CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability, const char* aContextText)

   732 	{

   733 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EMessageCapabilityCheckFail,(TInt)aMessage.Handle(),aCapability);

   734 	return EmitDiagnostic(d,aContextText);

   735 	}

   737 inline TInt PlatSec::CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps, const char* aContextText)

   738 	{

   739 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EMessageCapabilityCheckFail,(TInt)aMessage.Handle(),ECapability_None,(const SCapabilitySet&)aMissingCaps);

   740 	return EmitDiagnostic(d,aContextText);

   741 	}

   743 inline TInt PlatSec::PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissing, const char* aContextText)

   744 	{

   745 	TPlatSecDiagnostic d(TPlatSecDiagnostic::EMessageCapabilityCheckFail,(TInt)aMessage.Handle(),(const SSecurityInfo&)aMissing);

   746 	return EmitDiagnostic(d,aContextText);

   747 	}

   749 inline TInt PlatSec::CreatorPolicyCheckFail(const SSecurityInfo& aMissing, const char* aContextText)

   750 	{

   751 	TPlatSecDiagnostic d(TPlatSecDiagnostic::ECreatorPolicyCheckFail,(TInt)0,(const SSecurityInfo&)aMissing);

   752 	return EmitDiagnostic(d,aContextText);

   753 	}

   755 #endif //__KERNEL_MODE__

   756 #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__

   758 const TInt KTlsArrayGranularity=2;

   760 #ifdef __CPU_HAS_CP15_THREAD_ID_REG

   762 #define __USERSIDE_THREAD_DATA__

   764 class TLocalThreadData

   765 	{

   766 public:

   767 	void Close();

   768 #ifndef __KERNEL_MODE__

   769 	TAny* DllTls(TInt aHandle, TInt aDllUid);

   770 	TInt DllSetTls(TInt aHandle, TInt aDllUid, TAny* aPtr);

   771 	void DllFreeTls(TInt aHandle);

   772 #endif

   773 public:

   774 	RAllocator* iHeap;				///< The thread's current heap

   775 	CActiveScheduler* iScheduler;	///< The thread's current active scheduler

   776 	TTrapHandler* iTrapHandler;		///< The thread's current trap handler

   777 private:

   778 	RAllocator* iTlsHeap; 			///< The heap that the DLL TLS data is stored on

   779 	RArray<STls> iTls; 				///< DLL TLS data

   780 	};

   782 const TInt KLocalThreadDataSize = _ALIGN_UP(sizeof(TLocalThreadData), 8);

   784 #endif

   786 #ifdef __WINS__

   788 enum TWin32RuntimeReason

   789 	{

   790 	// Same values as passed to DllMain

   791 	EWin32RuntimeProcessAttach = 1,

   792 	EWin32RuntimeThreadAttach = 2,

   793 	EWin32RuntimeThreadDetach = 3,

   794 	EWin32RuntimeProcessDetach = 4,

   795 	};

   797 typedef TBool (*TWin32RuntimeHook)(TWin32RuntimeReason);

   799 #endif

   801 struct SAtomicOpInfo64

   802 	{

   803 	TAny*		iA;

   804 	TAny*		iQ;

   805 	TUint64		i1;

   806 	TUint64		i2;

   807 	TUint64		i3;

   808 	};

   810 struct SAtomicOpInfo32

   811 	{

   812 	TAny*		iA;

   813 	union

   814 		{

   815 		TAny*	iQ;

   816 		TUint32	i0;

   817 		};

   818 	TUint32		i1;

   819 	TUint32		i2;

   820 	};

   822 #endif //__U32STD_H__

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--