LOCAL_D void SwitchToMainThread(RMutex& aMutex) { RThread::Rendezvous(KErrNone); aMutex.Wait(); aMutex.Signal(); User::After(10); }
bool wait(unsigned long time) { TInt err = KErrNone; if (time == ULONG_MAX) { // untimed wait, loop because RCondVar::Wait may return before the condition is triggered do { err = cond.Wait(mutex); } while (err == KErrNone && wakeups == 0); } else { unsigned long maxWait = KMaxTInt / 1000; QElapsedTimer waitTimer; do { waitTimer.start(); unsigned long waitTime = qMin(maxWait, time); // wait at least 1ms, as 0 means no wait err = cond.TimedWait(mutex, qMax(1ul, waitTime) * 1000); // RCondVar::TimedWait may return before the condition is triggered, update the timeout with actual wait time time -= qMin((unsigned long)waitTimer.elapsed(), waitTime); } while ((err == KErrNone && wakeups == 0) || (err == KErrTimedOut && time > 0)); } Q_ASSERT_X(waiters > 0, "QWaitCondition::wait", "internal error (waiters)"); --waiters; if (err == KErrNone) { Q_ASSERT_X(wakeups > 0, "QWaitCondition::wait", "internal error (wakeups)"); --wakeups; } mutex.Signal(); if (err && err != KErrTimedOut) report_error(err, "QWaitCondition::wait()", "cv wait"); return err == KErrNone; }
void TRecursiveMutex::Release() { if (--iCount == 0) { iOwner = 0; iMutex.Signal(); } }
void Wait() { RMutex syncMutex; if(syncMutex.OpenGlobal(KSyncMutext)!=KErrNone) User::Invariant(); syncMutex.Wait(); syncMutex.Signal(); syncMutex.Close(); }
/* Unlock the mutex */ int SDL_mutexV(SDL_mutex *mutex) { if ( mutex == NULL ) { SDL_SetError("Passed a NULL mutex"); return -1; } RMutex rmutex; rmutex.SetHandle(mutex->handle); rmutex.Signal(); return(0); }
void LockLeave(void* Handle) { lock_t *lock = (lock_t *)Handle; if (lock && --lock->Counter == 0) { lock->Thread = 0; RMutex p; p.SetHandle(lock->Handle); p.Signal(); } }
/* Free the mutex */ void SDL_DestroyMutex(SDL_mutex *mutex) { if ( mutex ) { RMutex rmutex; rmutex.SetHandle(mutex->handle); rmutex.Signal(); rmutex.Close(); delete(mutex); mutex = NULL; } }
TInt CCapabilityTestStep::StartServer() { TInt err = KErrNone; RMutex mutex; err = mutex.CreateGlobal(KSipServerStarterMutex); if (err != KErrNone) { err = mutex.OpenGlobal(KSipServerStarterMutex); if (err != KErrNone) { return err; } } mutex.Wait(); { // Protected with a mutex TFindServer findServer(KSipServerName); TFullName name; if (findServer.Next(name) == KErrNone) { mutex.Signal(); mutex.Close(); return KErrNone; // Server already running } RSemaphore semaphore; err = semaphore.CreateGlobal(KSipServerSemaphoreName,0); if (err == KErrNone) { err = CreateServerProcess(semaphore); semaphore.Close(); } } mutex.Signal(); mutex.Close(); return err; }
TInt CPARAM_MESS_NAMEStep::Exec_SendReceive() { _LIT(KEsockSessStartMutex,"KESSMTX"); //Keep the descriptor short RMutex mutex; TInt r; // Protect the openning of the session // with a mutex to stop thread collision FOREVER { r = mutex.CreateGlobal(KEsockSessStartMutex()); if (r == KErrNone) break; if (r != KErrAlreadyExists) return r; r=mutex.OpenGlobal(KEsockSessStartMutex()); if (r == KErrNone) break; if (r != KErrNotFound) return r; } mutex.Wait(); // the exclusion ensures the session is started atomically iResult_Server=CreateSession(SOCKET_SERVER_NAME,Version()); // Because ESock is now loaded by the Comms Root Server which is generally started during // the boot this should commonly succeed; however for test code this is still a possibility // Hence here we try starting it; this is an atomic operation (and cheap if it's already started) if (iResult_Server==KErrNotFound) { r=StartC32(); if (r==KErrNone || r==KErrAlreadyExists) { iResult_Server=CreateSession(SOCKET_SERVER_NAME,Version()); } } mutex.Signal(); mutex.Close(); if (iResult_Server == KErrNone) { iSessionCreated = ETrue; const TInt test_id = dispatch_num<PARAM_MESS_VALUE>::result; iResult_SR = do_execute(Int2Type<test_id>()); } else { iSessionCreated = EFalse; return 0; } return r; }
/* Free the mutex */ void SDL_DestroyMutex(SDL_mutex *mutex) { if ( mutex ) { RMutex rmutex; rmutex.SetHandle(mutex->handle); if(rmutex.IsHeld()) { rmutex.Signal(); } rmutex.Close(); EpocSdlEnv::RemoveCleanupItem(mutex); delete(mutex); mutex = NULL; } }
// -------------------------------------------------------------------------------- // void DumpToFileL( TPtrC8 aBuffer ) // -------------------------------------------------------------------------------- void DumpToFileL( TPtrC8 aBuffer ) { RFs fileSession; TInt pushed(0); if( fileSession.Connect() == KErrNone ) { CleanupClosePushL(fileSession); pushed++; RFile file; #ifdef __WINS__ if( file.Open(fileSession, KNSmlDebugOutputName(), EFileShareAny|EFileWrite) == KErrNone ) #else HBufC* outputName = HBufC::NewLC( KNSmlDebugOutputName().Length()+1 ); pushed++; TPtr namePtr = outputName->Des(); TDriveInfo driveInfo; for ( TUint driveNumber = EDriveA; driveNumber <= EDriveZ; driveNumber++ ) { fileSession.Drive( driveInfo, driveNumber ); if ( KDriveAttRemovable & driveInfo.iDriveAtt ) { // this is MMC namePtr.Insert( 0, KNSmlDebugDriveLetters().Mid( driveNumber, 1 )); namePtr.Insert( 1, KNSmlDebugOutputName() ); break; } } if( file.Open(fileSession, *outputName, EFileShareAny|EFileWrite) == KErrNone ) #endif { CleanupClosePushL(file); TInt pos(0); file.Seek(ESeekEnd, pos); RMutex mutex; NSmlGrabMutexLC(mutex, KNSmlDebugMutexName()); TInt result = file.Write(aBuffer); TInt result2 = file.Flush(); mutex.Signal(); CleanupStack::PopAndDestroy(2); // file, mutex User::LeaveIfError(result); User::LeaveIfError(result2); } CleanupStack::PopAndDestroy( pushed ); // fileSession and (for target) outputName } }
LOCAL_D void SwitchToWorkerThread(RMutex& aMutex, RThread& aThread, TBool aSignal, TBool aWait) { if (aSignal) { aMutex.Signal(); User::After(10); } if (aWait) { aMutex.Wait(); } TRequestStatus status; aThread.Rendezvous(status); User::WaitForRequest(status); }
/** Releases the mutex if leave occurs between wait and signal. @internalTechnology */ void CTzLocalizationDbAccessor::ReleaseMutex(TAny *target) { RMutex *mutex = static_cast<RMutex*> (target) ; mutex->Signal() ; }
/** Application invoked as part of CommandLine tests @SYMPREQ 280 File Handle Support FunctionDesc Tests Environment slots . Acquires a Mutex for log file access Invokes EnvironmentSlotsReaderL() which returns an CApaCommandLine Object Verifies the values returned by the GET APIs of CApaCommandLine object with those of predefined values Writes "Pass" to the logfile if verification passes else "Fail" is written. */ void testEnvironmentSlotsL() { TPtrC appName; TPtrC docName; TApaCommand command = EApaCommandOpen; TBool testResult = PASS; //Get the Mutex to access the log file RMutex fileAccess; fileAccess.OpenGlobal(KTLogFileAccess); fileAccess.Wait(); /** Invoke EnvironmenstSlotsReaderL() function which would constuct the CApaCommandLine class object from the environment slots and return the pointer to that object */ //CApaCommandLine* cmdLine = CApaCommandLine::EnvironmentSlotsReaderL(); //Method CApaCommandLine::EnvironmentSlotsReaderL has been implemented in a different fashion CApaCommandLine* cmdLine; CApaCommandLine::GetCommandLineFromProcessEnvironment(cmdLine); CleanupStack::PushL(cmdLine); appName.Set(KTAppName); docName.Set(KTDocName); RFs fSession; fSession.Connect(); RFile logFile; TBufC<KMaxFilePath> testFilePath(KFilePath); //Open the Log file in Write Mode User::LeaveIfError(logFile.Replace(fSession,testFilePath,EFileWrite)); // Compare the values returned by GET APIs with pre defined values TESTCOND(appName,cmdLine->ExecutableName()); if(appName != cmdLine->ExecutableName()) { logFile.Write(KTFail); logFile.Write(KTApp); } TESTCOND(docName,cmdLine->DocumentName()); if(docName != cmdLine->DocumentName()) { logFile.Write(KTFail); logFile.Write(KTDoc); } TESTCOND(command,cmdLine->Command()); if(command != cmdLine->Command()) { logFile.Write(KTFail); logFile.Write(KTCommand); } if(testResult == PASS) { logFile.Write(KTPass); } //Close the file and the file session logFile.Close(); fSession.Close(); //Signal the Mutex fileAccess.Signal(); CleanupStack::PopAndDestroy(cmdLine); }
void LockLeave(void* Handle) { RMutex p; p.SetHandle((int)Handle); p.Signal(); }
// ----------------------------------------------------------------------------- // InitServerL // Initialises the SatServer. // ----------------------------------------------------------------------------- // LOCAL_C void InitServerL() { LOG( SIMPLE, "SATSERVER: InitServerL calling" ) RMutex serverStartMutex; TInt createErr( serverStartMutex.CreateGlobal( KSatServerMtx ) ); if ( createErr ) { TInt openErr( serverStartMutex.OpenGlobal( KSatServerMtx ) ); User::LeaveIfError( openErr ); LOG( SIMPLE, "SATSERVER: Opened SATSERVERMTX" ) } LOG( SIMPLE, "SATSERVER: Asking ownership of SATSERVERMTX" ) serverStartMutex.Wait(); LOG( SIMPLE, "SATSERVER: Got ownership of SATSERVERMTX" ) // create server - if one of this name does not already exist TFindServer findSatServer( KSatServerName ); TFullName pathName; // Search for the server. if ( KErrNone != findSatServer.Next( pathName ) ) { // We don't already exist. // Start scheduler and server. CSatSScheduler* scheduler = new ( ELeave ) CSatSScheduler; __ASSERT_ALWAYS( scheduler != NULL, PanicServer( ESatSMainSchedulerError ) ); CleanupStack::PushL( scheduler ); CActiveScheduler::Install( scheduler ); // Rename the thread. User::RenameThread( KSatServerName ); // Create the server and connect to external interfaces. CSatSServer* server = CreateSatServerL(); CleanupStack::PushL( server ); // The scheduler needs access to the server instance. //lint -e{613} scheduler cannot be null, due assertion in creation. scheduler->SetServer( server ); // Call Rendezvous to improve startup time RProcess::Rendezvous( KErrNone ); LOG( SIMPLE, "SATSERVER: Releasing ownership of SATSERVERMTX, Starting.." ) serverStartMutex.Signal(); // start fielding requests from clients CActiveScheduler::Start(); // finished when the scheduler stops CleanupStack::PopAndDestroy( KInitServerPop ); // scheduler, server } else { LOG( SIMPLE, "SATSERVER: Releasing ownership of SATSERVERMTX, Already started" ) serverStartMutex.Signal(); } serverStartMutex.Close(); LOG( SIMPLE, "SATSERVER: InitServerL exiting" ) }
// -------------------------------------------------------------------------------- // void doNSmlDebugDumpL( void* aData, TInt aLength, TText8* aFile, TInt aLine, const TText8* aMsg ) // -------------------------------------------------------------------------------- void doNSmlDebugDumpL( void* aData, TInt aLength, TText8* aFile, TInt aLine, const TText8* aMsg ) { TInt pushed(0); HBufC8* pDateBuffer8 = HBufC8::NewLC(64); pushed++; TPtr8 dateBuffer8 = pDateBuffer8->Des(); HBufC8* pTimeBuffer8 = HBufC8::NewLC(64); pushed++; TPtr8 timeBuffer8 = pTimeBuffer8->Des(); NSmlGetDateAndTimeL(dateBuffer8, timeBuffer8); TPtrC8 data(REINTERPRET_CAST(TUint8*, aData), aLength); TPtrC8 fileName(aFile); HBufC8* buffer8 = HBufC8::NewLC(KBufferSize); pushed++; TPtr8 ptrBuffer8 = buffer8->Des(); TPtrC8 msg(aMsg); if( !msg.Length() ) { #if !defined(__SML_DEVELOPER_DEBUG__) ptrBuffer8.Format(_L8("[%S %S File: %S Line: %d Length: %d]\r\n"), &dateBuffer8, &timeBuffer8, &fileName, aLine, aLength); #else ptrBuffer8.Format(_L8("[%S %S Length: %d]\r\n"), &dateBuffer8, &timeBuffer8, aLength); #endif } else { #if !defined(__SML_DEVELOPER_DEBUG__) ptrBuffer8.Format(_L8("[%S %S File: %S Line: %d Length: %d] %S\r\n"), &dateBuffer8, &timeBuffer8, &fileName, aLine, aLength, &msg); #else ptrBuffer8.Format(_L8("[%S %S Length: %d] %S\r\n"), &dateBuffer8, &timeBuffer8, aLength, &msg); #endif } // Now we're ready to write into file RFs fileSession; if( fileSession.Connect() == KErrNone ) { CleanupClosePushL(fileSession); pushed++; RFile file; #ifdef __WINS__ if( file.Open(fileSession, KNSmlDebugDumpName(), EFileShareAny|EFileWrite) == KErrNone ) #else HBufC* outputDumpName = HBufC::NewLC( KNSmlDebugDumpName().Length()+1 ); pushed++; TPtr nameDumpPtr = outputDumpName->Des(); TDriveInfo driveInfo; for ( TUint driveNumber = EDriveA; driveNumber <= EDriveZ; driveNumber++ ) { fileSession.Drive( driveInfo, driveNumber ); if ( KDriveAttRemovable & driveInfo.iDriveAtt ) { // this is MMC nameDumpPtr.Insert( 0, KNSmlDebugDriveLetters().Mid( driveNumber, 1 )); nameDumpPtr.Insert( 1, KNSmlDebugDumpName() ); break; } } if( file.Open(fileSession, *outputDumpName, EFileShareAny|EFileWrite) == KErrNone ) #endif { CleanupClosePushL(file); TInt pos(0); file.Seek(ESeekEnd, pos); RMutex mutex; NSmlGrabMutexLC(mutex, KNSmlDebugMutexNameDump()); TInt result1 = file.Write(ptrBuffer8); TInt result2 = file.Write(data); TInt result3 = file.Write(_L8("\r\n\r\n")); TInt result4 = file.Flush(); mutex.Signal(); CleanupStack::PopAndDestroy(2); // file, mutex User::LeaveIfError(result1); User::LeaveIfError(result2); User::LeaveIfError(result3); User::LeaveIfError(result4); } } CleanupStack::PopAndDestroy( pushed ); // buffer8, pDateBuffer8, pTimeBuffer8 }
void TestKill() { RTestProcess process; RTestProcess process2; TRequestStatus logonStatus; TRequestStatus logonStatus2; process2.Create(0,ETestProcessNull); process2.Logon(logonStatus2); // Test RProcess::Kill() test.Start(_L("Test killing an un-resumed process created by us")); process.Create(0,ETestProcessNull); process.Logon(logonStatus); process.Kill(999); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitKill); test(logonStatus==999); CLOSE_AND_WAIT(process); test.Next(_L("Try killing un-resumed process not created by self")); process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessKill,process2.Id()); process.Logon(logonStatus); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic test(logonStatus==EPlatformSecurityTrap); test(logonStatus2==KRequestPending); // the process should still be alive CLOSE_AND_WAIT(process); test.Next(_L("Test a process killing itself")); process.Create(0,ETestProcessKillSelf); process.Logon(logonStatus); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitKill); test(logonStatus==999); CLOSE_AND_WAIT(process); test.Next(_L("Try killing running process")); process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessKill,RProcess().Id()); process.Logon(logonStatus); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic test(logonStatus==EPlatformSecurityTrap); CLOSE_AND_WAIT(process); // Test RProcess::Teminate() test.Next(_L("Test terminating an un-resumed process created by us")); process.Create(0,ETestProcessNull); process.Logon(logonStatus); process.Terminate(999); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitTerminate); test(logonStatus==999); CLOSE_AND_WAIT(process); test.Next(_L("Try terminating un-resumed process not created by self")); process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessTerminate,process2.Id()); process.Logon(logonStatus); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic test(logonStatus==EPlatformSecurityTrap); test(logonStatus2==KRequestPending); // the process should still be alive CLOSE_AND_WAIT(process); test.Next(_L("Test a process terminating itself")); process.Create(0,ETestProcessTerminateSelf); process.Logon(logonStatus); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitTerminate); test(logonStatus==999); CLOSE_AND_WAIT(process); test.Next(_L("Try terminating running process")); process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessTerminate,RProcess().Id()); process.Logon(logonStatus); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic test(logonStatus==EPlatformSecurityTrap); CLOSE_AND_WAIT(process); // Test RProcess::Panic() test.Next(_L("Test panicking an un-resumed process created by us")); process.Create(0,ETestProcessNull); process.Logon(logonStatus); process.Panic(KTestPanicCategory,999); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitPanic); test(logonStatus==999); CLOSE_AND_WAIT(process); test.Next(_L("Try panicking un-resumed process not created by self")); process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessPanic,process2.Id()); process.Logon(logonStatus); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic test(logonStatus==EPlatformSecurityTrap); test(logonStatus2==KRequestPending); // the process should still be alive CLOSE_AND_WAIT(process); test.Next(_L("Test a process panicking itself")); process.Create(0,ETestProcessPanicSelf); process.Logon(logonStatus); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitPanic); test(logonStatus==999); CLOSE_AND_WAIT(process); test.Next(_L("Try panicking running process")); process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessPanic,RProcess().Id()); process.Logon(logonStatus); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic test(logonStatus==EPlatformSecurityTrap); CLOSE_AND_WAIT(process); // test(logonStatus2==KRequestPending); // the process should still be alive process2.Resume(); User::WaitForRequest(logonStatus2); test(logonStatus2==KErrNone); CLOSE_AND_WAIT(process2); // Checks with ECapabilityPowerMgmt test.Next(_L("Test kill running process ECapabilityPowerMgmt")); process2.Create(0,ETestProcessNull); process2.Logon(logonStatus2); process.Create((1<<ECapabilityPowerMgmt),ETestProcessKill,process2.Id()); process.Logon(logonStatus); SyncMutex.Wait(); process2.Resume(); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitKill); test(logonStatus==0); CLOSE_AND_WAIT(process); User::WaitForRequest(logonStatus2); test(process2.ExitType()==EExitKill); test(logonStatus2==999); process2.Close(); SyncMutex.Signal(); test.Next(_L("Test terminating running process ECapabilityPowerMgmt")); process2.Create(0,ETestProcessNull); process2.Logon(logonStatus2); process.Create((1<<ECapabilityPowerMgmt),ETestProcessTerminate,process2.Id()); process.Logon(logonStatus); SyncMutex.Wait(); process2.Resume(); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitKill); test(logonStatus==0); CLOSE_AND_WAIT(process); User::WaitForRequest(logonStatus2); test(process2.ExitType()==EExitTerminate); test(logonStatus2==999); CLOSE_AND_WAIT(process2); SyncMutex.Signal(); test.Next(_L("Test panicking running process ECapabilityPowerMgmt")); process2.Create(0,ETestProcessNull); process2.Logon(logonStatus2); process.Create((1<<ECapabilityPowerMgmt),ETestProcessPanic,process2.Id()); process.Logon(logonStatus); SyncMutex.Wait(); process2.Resume(); process.Resume(); User::WaitForRequest(logonStatus); test(process.ExitType()==EExitKill); test(logonStatus==0); CLOSE_AND_WAIT(process); User::WaitForRequest(logonStatus2); test(process2.ExitType()==EExitPanic); test(logonStatus2==999); CLOSE_AND_WAIT(process2); SyncMutex.Signal(); // test.End(); }
void TestSetPriority() { RTestProcess process; RTestProcess process2; TProcessPriority priority; TRequestStatus rendezvousStatus; TRequestStatus logonStatus; test.Start(_L("Test changing our own process priority")); priority = process.Priority(); process.SetPriority(EPriorityLow); test(process.Priority()==EPriorityLow); process.SetPriority(EPriorityBackground); test(process.Priority()==EPriorityBackground); process.SetPriority(EPriorityForeground); test(process.Priority()==EPriorityForeground); process.SetPriority(priority); test.Next(_L("Test changing unresumed process priority (which we created)")); process.Create(0,ETestProcessNull); priority = process.Priority(); process.SetPriority(EPriorityLow); test(process.Priority()==EPriorityLow); process.SetPriority(EPriorityBackground); test(process.Priority()==EPriorityBackground); process.SetPriority(EPriorityForeground); test(process.Priority()==EPriorityForeground); process.SetPriority(priority); process.Kill(0); CLOSE_AND_WAIT(process); test.Next(_L("Try other process changing the priority of our created process")); process2.Create(0,ETestProcessNull); process.Create(~0u,ETestProcessPriority,process2.Id()); process.Logon(logonStatus); process.Resume(); User::WaitForRequest(logonStatus); test(logonStatus==KErrNone); CLOSE_AND_WAIT(process); process2.Kill(0); CLOSE_AND_WAIT(process2); test.Next(_L("Try changing other process's priority (no priority-control enabled)")); process.Create(~0u,ETestProcessPriorityControlOff); process.Rendezvous(rendezvousStatus); process.Logon(logonStatus); SyncMutex.Wait(); process.Resume(); User::WaitForRequest(rendezvousStatus); // Process has started priority = process.Priority(); TInt result = process.SetPriority(EPriorityLow); test(result == KErrPermissionDenied); test(process.Priority()==priority); // priority shouldn't have changed process.SetPriority(EPriorityBackground); test(result == KErrPermissionDenied); test(process.Priority()==priority); // priority shouldn't have changed process.SetPriority(EPriorityForeground); test(result == KErrPermissionDenied); test(process.Priority()==priority); // priority shouldn't have changed test(logonStatus==KRequestPending); // wait for process to end SyncMutex.Signal(); User::WaitForRequest(logonStatus); CLOSE_AND_WAIT(process); test.Next(_L("Try changing other process's priority (priority-control enabled)")); process.Create(~0u,ETestProcessPriorityControlOn); process.Rendezvous(rendezvousStatus); process.Logon(logonStatus); SyncMutex.Wait(); process.Resume(); User::WaitForRequest(rendezvousStatus); // Process has started priority = process.Priority(); result = process.SetPriority(EPriorityForeground); test(result == KErrNone); test(process.Priority()==EPriorityForeground); result = process.SetPriority(EPriorityBackground); test(result == KErrNone); test(process.Priority()==EPriorityBackground); result = process.SetPriority(EPriorityForeground); test(result == KErrNone); test(process.Priority()==EPriorityForeground); result = process.SetPriority(EPriorityLow); test(result == KErrPermissionDenied); test(process.Priority()==EPriorityForeground); // should still be foreground priority result = process.SetPriority(EPriorityHigh); test(result == KErrNone); test(process.Priority()==EPriorityHigh); result = process.SetPriority(priority); test(result == KErrNone); test(logonStatus==KRequestPending); // wait for process to end SyncMutex.Signal(); User::WaitForRequest(logonStatus); CLOSE_AND_WAIT(process); test.Next(_L("Try changing other process's priority (priority-control enabled and low priority)")); process.Create(~0u,ETestProcessPriorityControlOnAndLowPriority); process.Rendezvous(rendezvousStatus); process.Logon(logonStatus); SyncMutex.Wait(); process.Resume(); User::WaitForRequest(rendezvousStatus); // Process has started test(process.Priority()==EPriorityLow); result = process.SetPriority(EPriorityForeground); test(result == KErrPermissionDenied); test(process.Priority()==EPriorityLow); result = process.SetPriority(EPriorityBackground); test(result == KErrPermissionDenied); test(process.Priority()==EPriorityLow); result = process.SetPriority(EPriorityForeground); test(result == KErrPermissionDenied); test(process.Priority()==EPriorityLow); result = process.SetPriority(EPriorityLow); test(result == KErrPermissionDenied); test(process.Priority()==EPriorityLow); result = process.SetPriority(EPriorityHigh); test(result == KErrPermissionDenied); test(process.Priority()==EPriorityLow); test(logonStatus==KRequestPending); // wait for process to end SyncMutex.Signal(); User::WaitForRequest(logonStatus); CLOSE_AND_WAIT(process); test.End(); }
void CLogFileControl::WriteXml(const TDesC8 &aDes) /** * @param aDes - send a aDes string in xml format to a log file */ { /*--------- Maintaince Warning: ----------------------------------- ******* the fomat of below is sensible from client original format. ******* Any change should match actual string formated from client. ******* Double check the code on client side * The current assumtion of format: * First string values are seperated by sign " - " and extra pair of fields are * seperated from main log message by long unusual string "LogFieldsRequiredBeingAddedToAboveLogMessage" * The \t used to seperate field name and field value and \r\n used to seperate * each other from those pairs of field * \t\t\t\t\t\t is used to end of whole string --------------------------------------------------------------------------------*/ _LIT8(KxmlHeader,"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\r\n<LOGFILE>"); //The order of variables: // time - aTime // Severity - aSeverity // Thread - aThread // Filename - aFilename // Linenumber - aLinenumber // Text - aText // Start of string retrive/deformating HBufC8* pBuf1 = HBufC8::New(KMaxLoggerLineLength*2); //(aDes.Length()+200); if(!pBuf1) { return; // no memory } TPtr8 aPtr(pBuf1->Des()); // used for searching TPtr8 alogbuf(pBuf1->Des()); //used for final log aPtr.Append(aDes); TPtrC8 SearchBuf; TInt aCount[8]; aCount[0]=0; TInt posI(0); // retrive log message: // Retrive common part of log message: TInt i=0; for(i=1; i<6; i++) { SearchBuf.Set(aPtr.Mid(posI)); aCount[i]=SearchBuf.Find(KSeperation8)+posI; posI=aCount[i]+3; if(aCount[i]<aCount[i-1]) { delete pBuf1; return; // wrong format string from client } } // seperating common log message and extra log fields will be easy for future maintaince. TLogField8* alogField = new TLogField8[6]; // the common part of log message for both // with and without extra log fields if(!alogField) { delete pBuf1; return; // no memory } TLogField8* extralogField=NULL; // only applied to extra log fields TInt alength=0; // a length of array of extra log fields alogField[0].iLogTag8.Copy(_L8("TIME")); alogField[1].iLogTag8.Copy(_L8("SEVERITY")); alogField[2].iLogTag8.Copy(_L8("THREAD")); alogField[3].iLogTag8.Copy(_L8("FILENAME")); alogField[4].iLogTag8.Copy(_L8("LINENUMBER")); alogField[5].iLogTag8.Copy(_L8("TEXT")); alogField[0].iLogValue8.Copy(aPtr.Mid(aCount[0],aCount[1]-aCount[0])); for(i=1; i<5; i++) { alogField[i].iLogValue8.Copy(aPtr.Mid(aCount[i]+3,aCount[i+1]-aCount[i]-3)); } SearchBuf.Set(aPtr.Mid(posI)); aCount[6]=SearchBuf.Find(_L8("LogFieldsRequiredBeingAddedToAboveLogMessage"))+posI; if(aCount[6]<posI) // no addtional fields. Find return value is KErrNotFound or >0 { alogField[5].iLogValue8.Copy(aPtr.Mid(aCount[5]+3,aDes.Length()-aCount[5]-5)); } else { alogField[5].iLogValue8.Copy(aPtr.Mid(aCount[5]+3,aCount[6]-aCount[5]-5)); posI=aCount[6]+45; //45 is from the length of long string and a tab SearchBuf.Set(aPtr.Mid(posI)); aCount[7]=SearchBuf.Find(_L8("\r\n"))+posI; TLex8 lex(aPtr.Mid(posI,aCount[7]-posI)); // get the length TInt err=lex.Val(alength); if (err) alength=0; // ignor the extra log fields. Let the log go // Retrive the extra log fields extralogField = new TLogField8[alength]; if(!extralogField) { delete pBuf1; return; // no memory } for(TInt i=0; i<alength; i++) { aCount[6]=aCount[7]+2; SearchBuf.Set(aPtr.Mid(aCount[6])); aCount[7]=SearchBuf.Find(_L8("\t"))+aCount[6]; extralogField[i].iLogTag8.Copy(aPtr.Mid(aCount[6],aCount[7]-aCount[6])); aCount[6]=aCount[7]+1; SearchBuf.Set(aPtr.Mid(aCount[6])); aCount[7]=SearchBuf.Find(_L8("\r\n"))+aCount[6]; extralogField[i].iLogValue8.Copy(aPtr.Mid(aCount[6],aCount[7]-aCount[6])); } } // Start to organize an XML format: TInt afileSize; _LIT(KLogMutex, "LoggingServerMutex"); RMutex mutex; TInt r = mutex.CreateGlobal(KLogMutex); if(r==KErrAlreadyExists) r = mutex.OpenGlobal(KLogMutex); if(!r) mutex.Wait(); // If still failed, let logging go without bother the mutex. iLogFile.Size(afileSize); if(afileSize<12) // 12 is from charters of "\r\n</LOGFILE>" //It shoud happened once at the beginning of the file // such as overwrite mode { afileSize=12; // used for lock position alogbuf.Copy(KxmlHeader); } alogbuf.Append(_L8("\r\n<MESSAGE>\r\n")); for(TInt i=0; i<6; i++) { alogbuf.Append(_L8(" <")); alogbuf.Append(alogField[i].iLogTag8); alogbuf.Append(_L8(">")); alogbuf.Append(alogField[i].iLogValue8); alogbuf.Append(_L8("</")); alogbuf.Append(alogField[i].iLogTag8); alogbuf.Append(_L8(">\r\n")); } for(TInt i=0; i<alength; i++) { alogbuf.Append(_L8(" <")); alogbuf.Append(extralogField[i].iLogTag8); alogbuf.Append(_L8(">")); alogbuf.Append(extralogField[i].iLogValue8); alogbuf.Append(_L8("</")); alogbuf.Append(extralogField[i].iLogTag8); alogbuf.Append(_L8(">\r\n")); } alogbuf.Append(_L8("</MESSAGE>")); alogbuf.Append(_L8("\r\n</LOGFILE>")); iLogFile.Write(afileSize-12, alogbuf,iStatus); if(!r) { mutex.Signal(); mutex.Close(); } if(extralogField) delete[] extralogField; delete[] alogField; delete pBuf1; }
// --------------------------------------------------------- // TInt RSCPClient::Connect() // Creates a new session, and starts the server, if required. // // Status : Approved // --------------------------------------------------------- // EXPORT_C TInt RSCPClient::Connect() { Dprint( (_L("--> RSCPClient::Connect()") )); // Use a mutex-object so that two processes cannot start the server at the same time RMutex startMutex; TRAPD( errf, FeatureManager::InitializeLibL() ); if( errf != KErrNone ) { return errf; } if(FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements)) { isFlagEnabled = ETrue; } else { isFlagEnabled = EFalse; } FeatureManager::UnInitializeLib(); TInt mRet = startMutex.OpenGlobal( KSCPServerName ); if ( mRet == KErrNotFound ) { mRet = startMutex.CreateGlobal( KSCPServerName ); } if ( mRet != KErrNone ) { return mRet; } // Acquire the mutex startMutex.Wait(); TInt retry = KSCPConnectRetries; TInt r; for (;;) { r = CreateSession( KSCPServerName, Version(), KDefaultMessageSlots ); if ( ( r != KErrNotFound ) && ( r != KErrServerTerminated ) ) { break; } if ( --retry == 0 ) { break; } r = StartServer(); if ( ( r != KErrNone ) && ( r != KErrAlreadyExists ) ) { break; } } Dprint( (_L("<-- RSCPClient::Connect(), exiting: %d"), r )); // Release the mutex startMutex.Signal(); startMutex.Close(); return r; }