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\euser\epoc\win32\uc_exec.cpp

    15 // 

    16 //

    17 

    18 

    19 #define __GEN_USER_EXEC_CODE__

    20 

    21 #include "../win32/uc_std.h"

    22 #include <e32svr.h>

    23 #include <emulator.h>

    24 

    25 typedef TInt (__fastcall *TDispatcher)(TInt, TInt*);

    26 TInt __fastcall LazyDispatch(TInt aFunction, TInt* aArgs);

    27 

    28 #pragma data_seg(".data2")

    29 #ifdef __VC32__

    30 #pragma bss_seg(".data2")

    31 #endif

    32 static TDispatcher TheDispatcher = &LazyDispatch;

    33 #pragma data_seg()

    34 #ifdef __VC32__

    35 #pragma bss_seg()

    36 #endif

    37 

    38 TInt __fastcall LazyDispatch(TInt aFunction, TInt* aArgs)

    39 	{

    40 	//SL:

    41 	HINSTANCE kernel = GetModuleHandleA("ekern.dll");

    42 	//HINSTANCE kernel = GetModuleHandleA("ekern.exe");

    43 	if (kernel)

    44 		{

    45 		TDispatcher dispatcher = (TDispatcher)Emulator::GetProcAddress(kernel, (LPCSTR)1);

    46 		if (dispatcher)

    47 			{

    48 			TheDispatcher = dispatcher;

    49 			return dispatcher(aFunction, aArgs);

    50 			}

    51 		}

    52 	ExitProcess(101);

    53 	return 0;

    54 	}

    55 

    56 #include <u32exec.h>

    57 

    58 /******************************************************************************

    59  * Slow executive calls with preprocessing or extra arguments

    60  ******************************************************************************/

    61 

    62 __NAKED__ TInt Exec::SessionSend(TInt /*aHandle*/, TInt /*aFunction*/, TAny* /*aPtr*/, TRequestStatus* /*aStatus*/)

    63 //

    64 // Send a blind message to the server.

    65 //

    66 	{

    67 	__DISPATCH(EExecSessionSend|EXECUTIVE_SLOW)

    68 	}

    69 

    70 __NAKED__ TInt Exec::SessionSendSync(TInt /*aHandle*/, TInt /*aFunction*/, TAny* /*aPtr*/, TRequestStatus* /*aStatus*/)

    71 //

    72 // Send a blind message to the server using thread's dedicated message slot.

    73 //

    74 	{

    75 	__DISPATCH(EExecSessionSendSync|EXECUTIVE_SLOW)

    76 	}

    77 

    78 

    79 __NAKED__ TInt Exec::MessageIpcCopy(TInt /*aHandle*/, TInt /*aParam*/, SIpcCopyInfo& /*aInfo*/, TInt /*anOffset*/)

    80 //

    81 // Perform a descriptor-to-descriptor IPC copy

    82 //

    83 	{

    84 

    85 	__DISPATCH(EExecMessageIpcCopy|EXECUTIVE_SLOW)

    86 	}

    87 

    88 __NAKED__ TInt Exec::BTraceOut(TUint32 /*a0*/, TUint32 /*a1*/, const BTrace::SExecExtension& /*aExtension*/, TInt /*aDataSize*/)

    89 	{

    90 	__DISPATCH(EExecBTraceOut|EXECUTIVE_SLOW)

    91 	}

    92 

    93 __NAKED__ TInt Exec::BTraceOutBig(TUint32 /*a0*/, TUint32 /*a1*/, const BTrace::SExecExtension& /*aExtension*/, TInt /*aDataSize*/)

    94 	{

    95 	__DISPATCH(EExecBTraceOutBig|EXECUTIVE_SLOW)

    96 	}

    97 

    98 __NAKED__ TInt Exec::UTraceOut(TUint32 /*a0*/, TUint32 /*a1*/, const BTrace::SExecExtension& /*aExtension*/, TInt /*aDataSize*/)

    99 	{

   100 	__DISPATCH(EExecUTraceOut|EXECUTIVE_SLOW)

   101 	}

   102 

   103 EXPORT_C TBool BTrace::Out(TUint32 a0, TUint32 a1, TUint32 a2, TUint32 a3)

   104 	{

   105 	BTrace::SExecExtension ext;

   106 	ext.iA2 = a2;

   107 	ext.iA3 = a3;

   108 	ext.iPc = (&a0)[-1]; // return address on X86

   109 	return Exec::BTraceOut(a0,a1,ext,0);

   110 	}

   111 

   112 EXPORT_C TBool BTrace::OutX(TUint32 a0, TUint32 a1, TUint32 a2, TUint32 a3)

   113 	{

   114 	BTrace::SExecExtension ext;

   115 	ext.iA2 = a2;

   116 	ext.iA3 = a3;

   117 	ext.iPc = (&a0)[-1]; // return address on X86

   118 	return Exec::BTraceOut(a0,a1,ext,0);

   119 	}

   120 

   121 EXPORT_C TBool BTrace::OutN(TUint32 a0, TUint32 a1, TUint32 a2, const TAny* aData, TInt aDataSize)

   122 	{

   123 	BTrace::SExecExtension ext;

   124 	ext.iA2 = a2;

   125 	ext.iA3 = (TUint32)aData;

   126 	ext.iPc = (&a0)[-1]; // return address on X86

   127 	return Exec::BTraceOut(a0,a1,ext,aDataSize);

   128 	}

   129 

   130 EXPORT_C TBool BTrace::OutNX(TUint32 a0, TUint32 a1, TUint32 a2, const TAny* aData, TInt aDataSize)

   131 	{

   132 	BTrace::SExecExtension ext;

   133 	ext.iA2 = a2;

   134 	ext.iA3 = (TUint32)aData;

   135 	ext.iPc = (&a0)[-1]; // return address on X86

   136 	return Exec::BTraceOut(a0,a1,ext,aDataSize);

   137 	}

   138 

   139 EXPORT_C TBool BTrace::OutBig(TUint32 a0, TUint32 a1, const TAny* aData, TInt aDataSize)

   140 	{

   141 	BTrace::SExecExtension ext;

   142 	ext.iA2 = 0;

   143 	ext.iA3 = (TUint32)aData;

   144 	ext.iPc = (&a0)[-1]; // return address on X86

   145 

   146 	if((TUint)aDataSize>8u)

   147 		{

   148 		if((TUint)aDataSize>KMaxBTraceDataArray+4u)

   149 			return Exec::BTraceOutBig(a0,a1,ext,aDataSize);

   150 		a0 += 4;

   151 		aDataSize -= 4;

   152 		ext.iA2 = *((TUint32*&)aData)++;

   153 		ext.iA3 = (TUint32)aData;

   154 		return Exec::BTraceOut(a0,a1,ext,aDataSize);

   155 		}

   156 

   157 	if((TUint)aDataSize>4u)

   158 		ext.iA3 = ((TUint32*)aData)[1];

   159 	if(aDataSize)

   160 		ext.iA2 = ((TUint32*)aData)[0];

   161 	a0 += aDataSize;

   162 	aDataSize = 0;

   163 	return Exec::BTraceOut(a0,a1,ext,aDataSize);

   164 	}

   165 

   166 EXPORT_C TBool BTrace::OutFiltered(TUint32 a0, TUint32 a1, TUint32 a2, TUint32 a3)

   167 	{

   168 	BTrace::SExecExtension ext;

   169 	a0 |= EMissingRecord<<BTrace::EFlagsIndex*8; // overload meaning of this flag to indicate filtered trace

   170 	ext.iA2 = a2;

   171 	ext.iA3 = a3;

   172 	ext.iPc = (&a0)[-1]; // return address on X86

   173 	return Exec::BTraceOut(a0,a1,ext,0);

   174 	}

   175 

   176 EXPORT_C TBool BTrace::OutFilteredX(TUint32 a0, TUint32 a1, TUint32 a2, TUint32 a3)

   177 	{

   178 	BTrace::SExecExtension ext;

   179 	a0 |= EMissingRecord<<BTrace::EFlagsIndex*8; // overload meaning of this flag to indicate filtered trace

   180 	ext.iA2 = a2;

   181 	ext.iA3 = a3;

   182 	ext.iPc = (&a0)[-1]; // return address on X86

   183 	return Exec::BTraceOut(a0,a1,ext,0);

   184 	}

   185 

   186 EXPORT_C TBool BTrace::OutFilteredN(TUint32 a0, TUint32 a1, TUint32 a2, const TAny* aData, TInt aDataSize)

   187 	{

   188 	BTrace::SExecExtension ext;

   189 	a0 |= EMissingRecord<<BTrace::EFlagsIndex*8; // overload meaning of this flag to indicate filtered trace

   190 	ext.iA2 = a2;

   191 	ext.iA3 = (TUint32)aData;

   192 	ext.iPc = (&a0)[-1]; // return address on X86

   193 	return Exec::BTraceOut(a0,a1,ext,aDataSize);

   194 	}

   195 

   196 EXPORT_C TBool BTrace::OutFilteredNX(TUint32 a0, TUint32 a1, TUint32 a2, const TAny* aData, TInt aDataSize)

   197 	{

   198 	BTrace::SExecExtension ext;

   199 	a0 |= EMissingRecord<<BTrace::EFlagsIndex*8; // overload meaning of this flag to indicate filtered trace

   200 	ext.iA2 = a2;

   201 	ext.iA3 = (TUint32)aData;

   202 	ext.iPc = (&a0)[-1]; // return address on X86

   203 	return Exec::BTraceOut(a0,a1,ext,aDataSize);

   204 	}

   205 

   206 EXPORT_C TBool BTrace::OutFilteredBig(TUint32 a0, TUint32 a1, const TAny* aData, TInt aDataSize)

   207 	{

   208 	BTrace::SExecExtension ext;

   209 	a0 |= EMissingRecord<<BTrace::EFlagsIndex*8; // overload meaning of this flag to indicate filtered trace

   210 	ext.iA2 = 0;

   211 	ext.iA3 = (TUint32)aData;

   212 	ext.iPc = (&a0)[-1]; // return address on X86

   213 

   214 	if((TUint)aDataSize>8u)

   215 		{

   216 		if((TUint)aDataSize>KMaxBTraceDataArray+4u)

   217 			return Exec::BTraceOutBig(a0,a1,ext,aDataSize);

   218 		a0 += 4;

   219 		aDataSize -= 4;

   220 		ext.iA2 = *((TUint32*&)aData)++;

   221 		ext.iA3 = (TUint32)aData;

   222 		return Exec::BTraceOut(a0,a1,ext,aDataSize);

   223 		}

   224 

   225 	if((TUint)aDataSize>4u)

   226 		ext.iA3 = ((TUint32*)aData)[1];

   227 	if(aDataSize)

   228 		ext.iA2 = ((TUint32*)aData)[0];

   229 	a0 += aDataSize;

   230 	aDataSize = 0;

   231 	return Exec::BTraceOut(a0,a1,ext,aDataSize);

   232 	}

   233 

   234 EXPORT_C TBool BTrace::OutFilteredPcFormatBig(TUint32 aHeader, TUint32 aModuleUid, TUint32 aPc, TUint16 aFormatId, const TAny* aData, TInt aDataSize)

   235 	{

   236  	BTrace::SExecExtension ext;

   237 	aHeader |= EMissingRecord<<BTrace::EFlagsIndex*8; // overload meaning of this flag to indicate filtered trace

   238 	ext.iA2 = aFormatId;

   239 	ext.iA3 = (TUint32)aData;

   240 	ext.iPc = aPc;

   241 

   242 	if((TUint)aDataSize>KMaxBTraceDataArray)

   243 		return Exec::UTraceOut(aHeader,aModuleUid,ext,aDataSize);

   244 	aHeader += 4;

   245 	return Exec::BTraceOut(aHeader,aModuleUid,ext,aDataSize);

   246 	}

   247 

   248 __NAKED__ void ExecRequestComplete(TInt /*aHandle*/, TRequestStatus*& /*aStatus*/, TInt /*aReason*/)

   249 	{

   250 	_asm mov ecx, [esp+8]			// ecx = TRequestStatus**

   251 	_asm xor eax, eax				//

   252 	_asm lock xchg eax, [ecx]		// eax=TRequestStatus*, zero TRequestStatus*

   253 	_asm cmp eax, 0					//

   254 	_asm je ExecRequestComplete_ret

   255 	_asm mov ecx, [esp+12]			// ecx = aReason

   256 	_asm mov [eax], ecx				// store aReason in request status

   257 	__DISPATCH(EExecThreadRequestSignal|EXECUTIVE_SLOW)

   258 	_asm ExecRequestComplete_ret: ret

   259 	}

   260 

   261 

   262 

   263 

   264 EXPORT_C void RThread::RequestComplete(TRequestStatus*& aStatus, TInt aReason) const

   265 /**

   266 Signals this thread that an asynchronous request originating from this thread,

   267 is complete.

   268 

   269 The request is associated with the specified request status object supplied

   270 by this thread.

   271 

   272 Typically, the caller of this function is the service provider responsible

   273 for satisfying the request made by this thread.

   274 

   275 The request is completed with the completion code passed in aReason. This

   276 value is copied into this thread's request status, *aStatus, before signalling

   277 this thread's request semaphore.

   278 

   279 The meaning of the completion code is a matter of convention to be decided

   280 between the service provider and this thread.

   281 

   282 In a client-server situation, completion of a request takes place in the context

   283 of the server thread, but the pointer is interpreted in the address space

   284 of the client.

   285 

   286 It is often the case in client-server situations that the client and the server

   287 are in the same address space (i.e. the same process).

   288 

   289 Setting the pointer to the request status to NULL is a convenience, not all

   290 servers need it.

   291 

   292 @param aStatus A reference to a pointer to the request status originally

   293                supplied by this thread. This is a pointer into this thread's

   294                address space, which may be different to the thread currently

   295                executing (this code). On return, the pointer to the request

   296                status is set to NULL.

   297 

   298 @param aReason The completion code of this request.

   299 */

   300 	{

   301 	ExecRequestComplete(iHandle,aStatus,aReason);

   302 	}

   303 

   304 

   305 

   306 /**

   307 Signal this threads request semaphore.

   308 

   309 This is similar to RThread::RequestComplete() except that no TRequestStatus object

   310 is modified.

   311 

   312 May only be used to signal a thread in the same process as the callers.

   313 

   314 @panic KERN-EXEC 46 if the thread is not in the same process as the callers

   315 */

   316 EXPORT_C void RThread::RequestSignal() const

   317 	{

   318 	Exec::ThreadRequestSignal(iHandle);

   319 	}

   320 

   321 

   322 

   323 void ExitCurrentThread(TExitType aType, TInt aReason, const TDesC8* aCategory)

   324 	{

   325 	Exec::ThreadKill(KCurrentThreadHandle, aType, aReason, aCategory);

   326 	}

   327 

   328 

   329 //

   330 #ifndef __GEN_USER_EXEC_CODE__

   331 

   332 

   333 //RHeap gAllocator;

   334 

   335 __EXECDECL__ void Exec::WaitForAnyRequest()

   336 	{

   337 	FAST_EXEC0(EFastExecWaitForAnyRequest);

   338 	}

   339 

   340 __EXECDECL__ RAllocator* Exec::Heap()

   341 	{

   342 	

   343 	FAST_EXEC0(EFastExecHeap);

   344 	}

   345 

   346 __EXECDECL__ RAllocator* Exec::HeapSwitch(RAllocator*)

   347 	{

   348 	FAST_EXEC1(EFastExecHeapSwitch);

   349 	}

   350 

   351 __EXECDECL__ TTrapHandler* Exec::PushTrapFrame(TTrap*)

   352 	{

   353 	FAST_EXEC1(EFastExecPushTrapFrame);

   354 	}

   355 

   356 __EXECDECL__ TTrap* Exec::PopTrapFrame()

   357 	{

   358 	FAST_EXEC0(EFastExecPopTrapFrame);

   359 	}

   360 

   361 __EXECDECL__ CActiveScheduler* Exec::ActiveScheduler()

   362 	{

   363 	FAST_EXEC0(EFastExecActiveScheduler);

   364 	}

   365 

   366 __EXECDECL__ void Exec::SetActiveScheduler(CActiveScheduler*)

   367 	{

   368 	FAST_EXEC1(EFastExecSetActiveScheduler);

   369 	}

   370 

   371 __EXECDECL__ TTimerLockSpec Exec::LockPeriod()

   372 	{

   373 	FAST_EXEC0(EFastExecLockPeriod);

   374 	}

   375 

   376 __EXECDECL__ TTrapHandler* Exec::TrapHandler()

   377 	{

   378 	FAST_EXEC0(EFastExecTrapHandler);

   379 	}

   380 

   381 __EXECDECL__ TTrapHandler* Exec::SetTrapHandler(TTrapHandler*)

   382 	{

   383 	FAST_EXEC1(EFastExecSetTrapHandler);

   384 	}

   385 

   386 __EXECDECL__ TUint32 Exec::DebugMask()

   387 	{

   388 	FAST_EXEC0(EFastExecDebugMask);

   389 	}

   390 

   391 __EXECDECL__ TUint32 Exec::DebugMaskIndex(TUint)

   392 	{

   393 	FAST_EXEC1(EFastExecDebugMaskIndex);

   394 	}

   395 

   396 __EXECDECL__ void Exec::SetDebugMask(TUint32)

   397 	{

   398 	FAST_EXEC1(EFastExecSetDebugMask);

   399 	}

   400 

   401 __EXECDECL__ TUint32 Exec::FastCounter()

   402 	{

   403 	FAST_EXEC0(EFastExecFastCounter);

   404 	}

   405 

   406 __EXECDECL__ TUint32 Exec::NTickCount()

   407 	{

   408 	FAST_EXEC0(EFastExecNTickCount);

   409 	}

   410 

   411 EXPORT_C __EXECDECL__ void UserSvr::LockRamDrive()

   412 	{

   413 	FAST_EXEC0(EFastExecLockRamDrive);

   414 	}

   415 

   416 EXPORT_C __EXECDECL__ void UserSvr::UnlockRamDrive()

   417 	{

   418 	FAST_EXEC0(EFastExecUnlockRamDrive);

   419 	}

   420 

   421 EXPORT_C __EXECDECL__ TLinAddr UserSvr::RomHeaderAddress()

   422 	{

   423 	FAST_EXEC0(EFastExecRomHeaderAddress);

   424 	}

   425 

   426 EXPORT_C __EXECDECL__ TLinAddr UserSvr::RomRootDirectoryAddress()

   427 	{

   428 	FAST_EXEC0(EFastExecRomRootDirectoryAddress);

   429 	}

   430 

   431 __EXECDECL__ void Exec::SetReentryPoint(TLinAddr)

   432 	{

   433 	FAST_EXEC1(EFastExecSetReentryPoint);

   434 	}

   435 

   436 __EXECDECL__ TUint32 Exec::KernelConfigFlags()

   437 	{

   438 	FAST_EXEC0(EFastExecKernelConfigFlags);

   439 	}

   440 

   441 __EXECDECL__ TInt Exec::UTCOffset()

   442 	{

   443 	FAST_EXEC0(EFastExecUTCOffset);

   444 	}

   445 

   446 __EXECDECL__ TInt Exec::GetGlobalUserData(TInt)

   447 	{

   448 	FAST_EXEC1(EFastExecGetGlobalUserData);

   449 	}

   450 

   451 EXPORT_C __EXECDECL__ TBool BTrace::CheckFilter(TUint32)

   452 	{

   453 	FAST_EXEC1(EFastExecCheckFilter);

   454 	}

   455 

   456 __EXECDECL__ TInt Exec::ObjectNext(TObjectType, TBuf8<KMaxFullName>&, TFindHandle&)

   457 	{

   458 	SLOW_EXEC3(EExecObjectNext);

   459 	}

   460 

   461 __EXECDECL__ TUint8* Exec::ChunkBase(TInt)

   462 	{

   463 	SLOW_EXEC1(EExecChunkBase);

   464 	}

   465 

   466 __EXECDECL__ TInt Exec::ChunkSize(TInt)

   467 	{

   468 	SLOW_EXEC1(EExecChunkSize);

   469 	}

   470 

   471 __EXECDECL__ TInt Exec::ChunkMaxSize(TInt)

   472 	{

   473 	SLOW_EXEC1(EExecChunkMaxSize);

   474 	}

   475 

   476 __EXECDECL__ TUint Exec::HandleAttributes(TInt)

   477 	{

   478 	SLOW_EXEC1(EExecHandleAttributes);

   479 	}

   480 

   481 __EXECDECL__ TUint Exec::TickCount()

   482 	{

   483 	SLOW_EXEC0(EExecTickCount);

   484 	}

   485 

   486 __EXECDECL__ void Exec::LogicalDeviceGetCaps(TInt, TDes8&)

   487 	{

   488 	SLOW_EXEC2(EExecLogicalDeviceGetCaps);

   489 	}

   490 

   491 __EXECDECL__ TBool Exec::LogicalDeviceQueryVersionSupported(TInt, const TVersion&)

   492 	{

   493 	SLOW_EXEC2(EExecLogicalDeviceQueryVersionSupported);

   494 	}

   495 

   496 __EXECDECL__ TBool Exec::LogicalDeviceIsAvailable(TInt, TInt, const TDesC8*, const TDesC8*)

   497 	{

   498 	SLOW_EXEC4(EExecLogicalDeviceIsAvailable);

   499 	}

   500 

   501 EXPORT_C __EXECDECL__ TInt E32Loader::LocaleExports(TAny*, TLibraryFunction*)

   502 	{

   503 	SLOW_EXEC2(EExecLocaleExports);

   504 	}

   505 

   506 __EXECDECL__ TInt Exec::ChannelRequest(TInt, TInt, TAny*, TAny*)

   507 	{

   508 	SLOW_EXEC4(EExecChannelRequest);

   509 	}

   510 

   511 __EXECDECL__ TUint32 Exec::MathRandom()

   512 	{

   513 	SLOW_EXEC0(EExecMathRandom);

   514 	}

   515 

   516 __EXECDECL__ void Exec::IMB_Range(TAny*, TUint)

   517 	{

   518 	SLOW_EXEC2(EExecIMBRange);

   519 	}

   520 

   521 __EXECDECL__ TInt Exec::ResetMachine(TMachineStartupType)

   522 	{

   523 	SLOW_EXEC1(EExecResetMachine);

   524 	}

   525 

   526 __EXECDECL__ TLibraryFunction Exec::LibraryLookup(TInt, TInt)

   527 	{

   528 	SLOW_EXEC2(EExecLibraryLookup);

   529 	}

   530 

   531 __EXECDECL__ void Exec::LibraryFileName(TInt, TDes8&)

   532 	{

   533 	SLOW_EXEC2(EExecLibraryFileName);

   534 	}

   535 

   536 EXPORT_C __EXECDECL__ TInt UserSvr::ExecuteInSupervisorMode(TSupervisorFunction, TAny*)

   537 	{

   538 	SLOW_EXEC2(EExecExecuteInSupervisorMode);

   539 	}

   540 

   541 __EXECDECL__ void Exec::MutexWait(TInt)

   542 	{

   543 	SLOW_EXEC1(EExecMutexWait);

   544 	}

   545 

   546 __EXECDECL__ void Exec::MutexSignal(TInt)

   547 	{

   548 	SLOW_EXEC1(EExecMutexSignal);

   549 	}

   550 

   551 __EXECDECL__ TInt Exec::ProcessId(TInt)

   552 	{

   553 	SLOW_EXEC1(EExecProcessId);

   554 	}

   555 

   556 __EXECDECL__ void Exec::DllFileName(TInt, TDes8&)

   557 	{

   558 	SLOW_EXEC2(EExecDllFileName);

   559 	}

   560 

   561 __EXECDECL__ void Exec::ProcessResume(TInt)

   562 	{

   563 	SLOW_EXEC1(EExecProcessResume);

   564 	}

   565 

   566 __EXECDECL__ void Exec::ProcessFileName(TInt, TDes8&)

   567 	{

   568 	SLOW_EXEC2(EExecProcessFileName);

   569 	}

   570 

   571 __EXECDECL__ void Exec::ProcessCommandLine(TInt, TDes8&)

   572 	{

   573 	SLOW_EXEC2(EExecProcessCommandLine);

   574 	}

   575 

   576 __EXECDECL__ TExitType Exec::ProcessExitType(TInt)

   577 	{

   578 	SLOW_EXEC1(EExecProcessExitType);

   579 	}

   580 

   581 __EXECDECL__ TInt Exec::ProcessExitReason(TInt)

   582 	{

   583 	SLOW_EXEC1(EExecProcessExitReason);

   584 	}

   585 

   586 __EXECDECL__ void Exec::ProcessExitCategory(TInt, TDes8&)

   587 	{

   588 	SLOW_EXEC2(EExecProcessExitCategory);

   589 	}

   590 

   591 __EXECDECL__ TProcessPriority Exec::ProcessPriority(TInt)

   592 	{

   593 	SLOW_EXEC1(EExecProcessPriority);

   594 	}

   595 

   596 __EXECDECL__ TInt Exec::ProcessSetPriority(TInt, TProcessPriority)

   597 	{

   598 	SLOW_EXEC2(EExecProcessSetPriority);

   599 	}

   600 

   601 __EXECDECL__ TUint Exec::ProcessFlags(TInt)

   602 	{

   603 	SLOW_EXEC1(EExecProcessFlags);

   604 	}

   605 

   606 __EXECDECL__ void Exec::ProcessSetFlags(TInt, TUint, TUint)

   607 	{

   608 	SLOW_EXEC3(EExecProcessSetFlags);

   609 	}

   610 

   611 __EXECDECL__ TInt Exec::SemaphoreWait(TInt, TInt)

   612 	{

   613 	SLOW_EXEC2(EExecSemaphoreWait);

   614 	}

   615 

   616 __EXECDECL__ void Exec::SemaphoreSignal1(TInt)

   617 	{

   618 	SLOW_EXEC1(EExecSemaphoreSignal1);

   619 	}

   620 

   621 __EXECDECL__ void Exec::SemaphoreSignalN(TInt, TInt)

   622 	{

   623 	SLOW_EXEC2(EExecSemaphoreSignalN);

   624 	}

   625 

   626 __EXECDECL__ void Exec::ServerReceive(TInt, TRequestStatus&, TAny*)

   627 	{

   628 	SLOW_EXEC3(EExecServerReceive);

   629 	}

   630 

   631 __EXECDECL__ void Exec::ServerCancel(TInt)

   632 	{

   633 	SLOW_EXEC1(EExecServerCancel);

   634 	}

   635 

   636 __EXECDECL__ void Exec::SetSessionPtr(TInt, const TAny*)

   637 	{

   638 	SLOW_EXEC2(EExecSetSessionPtr);

   639 	}

   640 

   641 __EXECDECL__ TInt Exec::ThreadId(TInt)

   642 	{

   643 	SLOW_EXEC1(EExecThreadId);

   644 	}

   645 

   646 __EXECDECL__ TInt Exec::SessionShare(TInt&, TInt)

   647 	{

   648 	SLOW_EXEC2(EExecSessionShare);

   649 	}

   650 

   651 __EXECDECL__ void Exec::ThreadResume(TInt)

   652 	{

   653 	SLOW_EXEC1(EExecThreadResume);

   654 	}

   655 

   656 __EXECDECL__ void Exec::ThreadSuspend(TInt)

   657 	{

   658 	SLOW_EXEC1(EExecThreadSuspend);

   659 	}

   660 

   661 __EXECDECL__ TThreadPriority Exec::ThreadPriority(TInt)

   662 	{

   663 	SLOW_EXEC1(EExecThreadPriority);

   664 	}

   665 

   666 __EXECDECL__ void Exec::ThreadSetPriority(TInt, TThreadPriority)

   667 	{

   668 	SLOW_EXEC2(EExecThreadSetPriority);

   669 	}

   670 

   671 __EXECDECL__ TProcessPriority Exec::ThreadProcessPriority(TInt)

   672 	{

   673 	SLOW_EXEC1(EExecThreadProcessPriority);

   674 	}

   675 

   676 __EXECDECL__ void Exec::ThreadSetProcessPriority(TInt, TProcessPriority)

   677 	{

   678 	SLOW_EXEC2(EExecThreadSetProcessPriority);

   679 	}

   680 

   681 __EXECDECL__ TUint Exec::ThreadFlags(TInt)

   682 	{

   683 	SLOW_EXEC1(EExecThreadFlags);

   684 	}

   685 

   686 __EXECDECL__ void Exec::ThreadSetFlags(TInt, TUint, TUint)

   687 	{

   688 	SLOW_EXEC3(EExecThreadSetFlags);

   689 	}

   690 

   691 __EXECDECL__ TInt Exec::ThreadRequestCount(TInt)

   692 	{

   693 	SLOW_EXEC1(EExecThreadRequestCount);

   694 	}

   695 

   696 __EXECDECL__ TExitType Exec::ThreadExitType(TInt)

   697 	{

   698 	SLOW_EXEC1(EExecThreadExitType);

   699 	}

   700 

   701 __EXECDECL__ TInt Exec::ThreadExitReason(TInt)

   702 	{

   703 	SLOW_EXEC1(EExecThreadExitReason);

   704 	}

   705 

   706 __EXECDECL__ void Exec::ThreadExitCategory(TInt, TDes8&)

   707 	{

   708 	SLOW_EXEC2(EExecThreadExitCategory);

   709 	}

   710 

   711 __EXECDECL__ void Exec::TimerCancel(TInt)

   712 	{

   713 	SLOW_EXEC1(EExecTimerCancel);

   714 	}

   715 

   716 __EXECDECL__ void Exec::TimerAfter(TInt, TRequestStatus&, TInt)

   717 	{

   718 	SLOW_EXEC3(EExecTimerAfter);

   719 	}

   720 

   721 __EXECDECL__ void Exec::TimerAt(TInt, TRequestStatus&, TUint32, TUint32)

   722 	{

   723 	SLOW_EXEC4(EExecTimerAt);

   724 	}

   725 

   726 __EXECDECL__ void Exec::TimerLock(TInt, TRequestStatus&, TTimerLockSpec)

   727 	{

   728 	SLOW_EXEC3(EExecTimerLock);

   729 	}

   730 

   731 __EXECDECL__ TInt Exec::ChangeNotifierLogon(TInt, TRequestStatus&)

   732 	{

   733 	SLOW_EXEC2(EExecChangeNotifierLogon);

   734 	}

   735 

   736 __EXECDECL__ TInt Exec::ChangeNotifierLogoff(TInt)

   737 	{

   738 	SLOW_EXEC1(EExecChangeNotifierLogoff);

   739 	}

   740 

   741 __EXECDECL__ void Exec::RequestSignal(TInt)

   742 	{

   743 	SLOW_EXEC1(EExecRequestSignal);

   744 	}

   745 

   746 __EXECDECL__ void Exec::HandleName(TInt, TDes8&)

   747 	{

   748 	SLOW_EXEC2(EExecHandleName);

   749 	}

   750 

   751 __EXECDECL__ void Exec::HandleFullName(TInt, TDes8&)

   752 	{

   753 	SLOW_EXEC2(EExecHandleFullName);

   754 	}

   755 

   756 __EXECDECL__ void Exec::HandleInfo(TInt, THandleInfo*)

   757 	{

   758 	SLOW_EXEC2(EExecHandleInfo);

   759 	}

   760 

   761 __EXECDECL__ void Exec::HandleCount(TInt, TInt&, TInt&)

   762 	{

   763 	SLOW_EXEC3(EExecHandleCount);

   764 	}

   765 

   766 __EXECDECL__ void Exec::After(TInt, TRequestStatus&)

   767 	{

   768 	SLOW_EXEC2(EExecAfter);

   769 	}

   770 

   771 __EXECDECL__ void Exec::At(const EXEC_TIME&, TRequestStatus&)

   772 	{

   773 	SLOW_EXEC2(EExecAt);

   774 	}

   775 

   776 __EXECDECL__ void Exec::MessageComplete(TInt, TInt)

   777 	{

   778 	SLOW_EXEC2(EExecMessageComplete);

   779 	}

   780 

   781 __EXECDECL__ void Exec::MessageCompleteWithHandle(TInt, TInt)

   782 	{

   783 	SLOW_EXEC2(EExecMessageCompleteWithHandle);

   784 	}

   785 

   786 __EXECDECL__ void Exec::TransferSession(TInt, TInt)

   787 	{

   788 	SLOW_EXEC2(EExecTransferSession);

   789 	}

   790 

   791 __EXECDECL__ TInt Exec::TimeNow(EXEC_TIME&, TInt&)

   792 	{

   793 	SLOW_EXEC2(EExecTimeNow);

   794 	}

   795 

   796 __EXECDECL__ TInt Exec::TimeNowSecure(EXEC_TIME&, TInt&)

   797 	{

   798 	SLOW_EXEC2(EExecTimeNowSecure);

   799 	}

   800 

   801 __EXECDECL__ TInt Exec::SetUTCTimeAndOffset(const EXEC_TIME&, TInt, TUint, TUint)

   802 	{

   803 	SLOW_EXEC4(EExecSetUTCTimeAndOffset);

   804 	}

   805 

   806 __EXECDECL__ TInt Exec::SetMachineConfiguration(const TDesC8&)

   807 	{

   808 	SLOW_EXEC1(EExecSetMachineConfiguration);

   809 	}

   810 

   811 __EXECDECL__ void Exec::CaptureEventHook()

   812 	{

   813 	SLOW_EXEC0(EExecCaptureEventHook);

   814 	}

   815 

   816 __EXECDECL__ void Exec::ReleaseEventHook()

   817 	{

   818 	SLOW_EXEC0(EExecReleaseEventHook);

   819 	}

   820 

   821 __EXECDECL__ void Exec::RequestEvent(TRawEventBuf&, TRequestStatus&)

   822 	{

   823 	SLOW_EXEC2(EExecRequestEvent);

   824 	}

   825 

   826 __EXECDECL__ void Exec::RequestEventCancel()

   827 	{

   828 	SLOW_EXEC0(EExecRequestEventCancel);

   829 	}

   830 

   831 __EXECDECL__ TInt Exec::AddEvent(const TRawEvent&)

   832 	{

   833 	SLOW_EXEC1(EExecAddEvent);

   834 	}

   835 

   836 __EXECDECL__ TAny* Exec::DllTls(TInt, TInt)

   837 	{

   838 	SLOW_EXEC2(EExecDllTls);

   839 	}

   840 

   841 __EXECDECL__ TInt Exec::HalFunction(TInt, TInt, TAny*, TAny*)

   842 	{

   843 	SLOW_EXEC4(EExecHalFunction);

   844 	}

   845 

   846 __EXECDECL__ void Exec::WsRegisterThread()

   847 	{

   848 	SLOW_EXEC0(EExecWsRegisterThread);

   849 	}

   850 

   851 __EXECDECL__ void Exec::FsRegisterThread()

   852 	{

   853 	SLOW_EXEC0(EExecFsRegisterThread);

   854 	}

   855 

   856 __EXECDECL__ TInt Exec::ProcessCommandLineLength(TInt)

   857 	{

   858 	SLOW_EXEC1(EExecProcessCommandLineLength);

   859 	}

   860 

   861 __EXECDECL__ void Exec::TimerInactivity(TInt, TRequestStatus&, TInt)

   862 	{

   863 	SLOW_EXEC3(EExecTimerInactivity);

   864 	}

   865 

   866 __EXECDECL__ TInt Exec::UserInactivityTime()

   867 	{

   868 	SLOW_EXEC0(EExecUserInactivityTime);

   869 	}

   870 

   871 __EXECDECL__ void Exec::ResetInactivityTime()

   872 	{

   873 	SLOW_EXEC0(EExecResetInactivityTime);

   874 	}

   875 

   876 __EXECDECL__ void Exec::DebugPrint(TAny*, TInt)

   877 	{

   878 	SLOW_EXEC2(EExecDebugPrint);

   879 	}

   880 

   881 __EXECDECL__ TInt Exec::BreakPoint()

   882 	{

   883 	SLOW_EXEC0(EExecBreakPoint);

   884 	}

   885 

   886 __EXECDECL__ TInt Exec::ProfileStart(TInt)

   887 	{

   888 	SLOW_EXEC1(EExecProfileStart);

   889 	}

   890 

   891 __EXECDECL__ TInt Exec::ProfileEnd(TInt)

   892 	{

   893 	SLOW_EXEC1(EExecProfileEnd);

   894 	}

   895 

   896 __EXECDECL__ TExceptionHandler Exec::ExceptionHandler(TInt)

   897 	{

   898 	SLOW_EXEC1(EExecExceptionHandler);

   899 	}

   900 

   901 __EXECDECL__ TInt Exec::SetExceptionHandler(TInt, TExceptionHandler, TUint32)

   902 	{

   903 	SLOW_EXEC3(EExecSetExceptionHandler);

   904 	}

   905 

   906 __EXECDECL__ void Exec::ModifyExceptionMask(TInt, TUint32, TUint32)

   907 	{

   908 	SLOW_EXEC3(EExecModifyExceptionMask);

   909 	}

   910 

   911 __EXECDECL__ TInt Exec::RaiseException(TInt, TExcType)

   912 	{

   913 	SLOW_EXEC2(EExecRaiseException);

   914 	}

   915 

   916 __EXECDECL__ TInt Exec::IsExceptionHandled(TInt, TExcType, TBool)

   917 	{

   918 	SLOW_EXEC3(EExecIsExceptionHandled);

   919 	}

   920 

   921 __EXECDECL__ TInt Exec::ProcessGetMemoryInfo(TInt, TModuleMemoryInfo&)

   922 	{

   923 	SLOW_EXEC2(EExecProcessGetMemoryInfo);

   924 	}

   925 

   926 __EXECDECL__ TInt Exec::LibraryGetMemoryInfo(TInt, TModuleMemoryInfo&)

   927 	{

   928 	SLOW_EXEC2(EExecLibraryGetMemoryInfo);

   929 	}

   930 

   931 __EXECDECL__ TInt Exec::MachineConfiguration(TDes8&, TInt&)

   932 	{

   933 	SLOW_EXEC2(EExecMachineConfiguration);

   934 	}

   935 

   936 __EXECDECL__ TInt Exec::SetMemoryThresholds(TInt, TInt)

   937 	{

   938 	SLOW_EXEC2(EExecSetMemoryThresholds);

   939 	}

   940 

   941 __EXECDECL__ void Exec::LibraryType(TInt, TUidType&)

   942 	{

   943 	SLOW_EXEC2(EExecLibraryType);

   944 	}

   945 

   946 __EXECDECL__ void Exec::ProcessType(TInt, TUidType&)

   947 	{

   948 	SLOW_EXEC2(EExecProcessType);

   949 	}

   950 

   951 __EXECDECL__ TInt Exec::ChunkBottom(TInt)

   952 	{

   953 	SLOW_EXEC1(EExecChunkBottom);

   954 	}

   955 

   956 __EXECDECL__ TInt Exec::ChunkTop(TInt)

   957 	{

   958 	SLOW_EXEC1(EExecChunkTop);

   959 	}

   960 

   961 __EXECDECL__ void Exec::ThreadContext(TInt, TDes8&)

   962 	{

   963 	SLOW_EXEC2(EExecThreadContext);

   964 	}

   965 

   966 __EXECDECL__ TInt Exec::ThreadCreate(const TDesC8&, TOwnerType, SThreadCreateInfo8&)

   967 	{

   968 	SLOW_EXEC3(EExecThreadCreate);

   969 	}

   970 

   971 __EXECDECL__ TInt Exec::FindHandleOpen(TOwnerType, const TFindHandle&)

   972 	{

   973 	SLOW_EXEC2(EExecFindHandleOpen);

   974 	}

   975 

   976 __EXECDECL__ TInt Exec::HandleClose(TInt)

   977 	{

   978 	SLOW_EXEC1(EExecHandleClose);

   979 	}

   980 

   981 __EXECDECL__ TInt Exec::ChunkCreate(TOwnerType, const TDesC8*, TChunkCreate&)

   982 	{

   983 	SLOW_EXEC3(EExecChunkCreate);

   984 	}

   985 

   986 __EXECDECL__ TInt Exec::ChunkAdjust(TInt, TInt, TInt, TInt)

   987 	{

   988 	SLOW_EXEC4(EExecChunkAdjust);

   989 	}

   990 

   991 __EXECDECL__ TInt Exec::OpenObject(TObjectType, const TDesC8&, TOwnerType)

   992 	{

   993 	SLOW_EXEC3(EExecOpenObject);

   994 	}

   995 

   996 __EXECDECL__ TInt Exec::HandleDuplicate(TInt, TOwnerType, TInt&)

   997 	{

   998 	SLOW_EXEC3(EExecHandleDuplicate);

   999 	}

  1000 

  1001 __EXECDECL__ TInt Exec::MutexCreate(const TDesC8*, TOwnerType)

  1002 	{

  1003 	SLOW_EXEC2(EExecMutexCreate);

  1004 	}

  1005 

  1006 __EXECDECL__ TInt Exec::SemaphoreCreate(const TDesC8*, TInt, TOwnerType)

  1007 	{

  1008 	SLOW_EXEC3(EExecSemaphoreCreate);

  1009 	}

  1010 

  1011 __EXECDECL__ TInt Exec::ThreadOpenById(TUint, TOwnerType)

  1012 	{

  1013 	SLOW_EXEC2(EExecThreadOpenById);

  1014 	}

  1015 

  1016 __EXECDECL__ TInt Exec::ProcessOpenById(TUint, TOwnerType)

  1017 	{

  1018 	SLOW_EXEC2(EExecProcessOpenById);

  1019 	}

  1020 

  1021 __EXECDECL__ void Exec::ThreadKill(TInt, TExitType, TInt, const TDesC8*)

  1022 	{

  1023 	SLOW_EXEC4(EExecThreadKill);

  1024 	}

  1025 

  1026 __EXECDECL__ void Exec::ThreadLogon(TInt, TRequestStatus*, TBool)

  1027 	{

  1028 	SLOW_EXEC3(EExecThreadLogon);

  1029 	}

  1030 

  1031 __EXECDECL__ TInt Exec::ThreadLogonCancel(TInt, TRequestStatus*, TBool)

  1032 	{

  1033 	SLOW_EXEC3(EExecThreadLogonCancel);

  1034 	}

  1035 

  1036 __EXECDECL__ TInt Exec::DllSetTls(TInt, TInt, TAny*)

  1037 	{

  1038 	SLOW_EXEC3(EExecDllSetTls);

  1039 	}

  1040 

  1041 __EXECDECL__ void Exec::DllFreeTls(TInt)

  1042 	{

  1043 	SLOW_EXEC1(EExecDllFreeTls);

  1044 	}

  1045 

  1046 __EXECDECL__ TInt Exec::ThreadRename(TInt, const TDesC8&)

  1047 	{

  1048 	SLOW_EXEC2(EExecThreadRename);

  1049 	}

  1050 

  1051 __EXECDECL__ TInt Exec::ProcessRename(TInt, const TDesC8&)

  1052 	{

  1053 	SLOW_EXEC2(EExecProcessRename);

  1054 	}

  1055 

  1056 __EXECDECL__ void Exec::ProcessKill(TInt, TExitType, TInt, const TDesC8*)

  1057 	{

  1058 	SLOW_EXEC4(EExecProcessKill);

  1059 	}

  1060 

  1061 __EXECDECL__ void Exec::ProcessLogon(TInt, TRequestStatus*, TBool)

  1062 	{

  1063 	SLOW_EXEC3(EExecProcessLogon);

  1064 	}

  1065 

  1066 __EXECDECL__ TInt Exec::ProcessLogonCancel(TInt, TRequestStatus*, TBool)

  1067 	{

  1068 	SLOW_EXEC3(EExecProcessLogonCancel);

  1069 	}

  1070 

  1071 __EXECDECL__ TInt Exec::ThreadProcess(TInt)

  1072 	{

  1073 	SLOW_EXEC1(EExecThreadProcess);

  1074 	}

  1075 

  1076 __EXECDECL__ TInt Exec::ServerCreate(const TDesC8*, TInt)

  1077 	{

  1078 	SLOW_EXEC2(EExecServerCreate);

  1079 	}

  1080 

  1081 __EXECDECL__ TInt Exec::ServerCreateWithOptions(const TDesC8*, TInt, TInt, TInt)

  1082 	{

  1083 	SLOW_EXEC4(EExecServerCreateWithOptions);

  1084 	}

  1085 

  1086 __EXECDECL__ TInt Exec::SessionCreate(const TDesC8&, TInt, const TSecurityPolicy*, TInt)

  1087 	{

  1088 	SLOW_EXEC4(EExecSessionCreate);

  1089 	}

  1090 

  1091 __EXECDECL__ TInt Exec::SessionCreateFromHandle(TInt, TInt, const TSecurityPolicy*, TInt)

  1092 	{

  1093 	SLOW_EXEC4(EExecSessionCreateFromHandle);

  1094 	}

  1095 

  1096 EXPORT_C __EXECDECL__ TInt E32Loader::DeviceLoad(TAny*, TInt)

  1097 	{

  1098 	SLOW_EXEC2(EExecDeviceLoad);

  1099 	}

  1100 

  1101 __EXECDECL__ TInt Exec::DeviceFree(const TDesC8&, TInt)

  1102 	{

  1103 	SLOW_EXEC2(EExecDeviceFree);

  1104 	}

  1105 

  1106 __EXECDECL__ TInt Exec::ChannelCreate(const TDesC8&, TChannelCreateInfo8&, TInt)

  1107 	{

  1108 	SLOW_EXEC3(EExecChannelCreate);

  1109 	}

  1110 

  1111 __EXECDECL__ TInt Exec::TimerCreate()

  1112 	{

  1113 	SLOW_EXEC0(EExecTimerCreate);

  1114 	}

  1115 

  1116 __EXECDECL__ void Exec::TimerHighRes(TInt, TRequestStatus&, TInt)

  1117 	{

  1118 	SLOW_EXEC3(EExecTimerHighRes);

  1119 	}

  1120 

  1121 __EXECDECL__ void Exec::AfterHighRes(TInt, TRequestStatus&)

  1122 	{

  1123 	SLOW_EXEC2(EExecAfterHighRes);

  1124 	}

  1125 

  1126 __EXECDECL__ TInt Exec::ChangeNotifierCreate(TOwnerType)

  1127 	{

  1128 	SLOW_EXEC1(EExecChangeNotifierCreate);

  1129 	}

  1130 

  1131 __EXECDECL__ TInt Exec::UndertakerCreate(TOwnerType)

  1132 	{

  1133 	SLOW_EXEC1(EExecUndertakerCreate);

  1134 	}