|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 #include <memspy/engine/memspyengineimp.h> |
|
19 |
|
20 // System includes |
|
21 #include <e32svr.h> |
|
22 |
|
23 // Driver includes |
|
24 #include <memspy/driver/memspydriverclient.h> |
|
25 |
|
26 // User includes |
|
27 #include <memspy/engine/memspyengineobjectthread.h> |
|
28 #include <memspy/engine/memspyengineobjectprocess.h> |
|
29 #include <memspy/engine/memspyengineobjectcontainer.h> |
|
30 #include <memspy/engine/memspyengineundertaker.h> |
|
31 #include "MemSpyEngineChunkWatcher.h" |
|
32 #include <memspy/engine/memspyengineobserver.h> |
|
33 #include "MemSpyEngineServer.h" |
|
34 #include <memspy/engine/memspyengineutils.h> |
|
35 #include "MemSpyEngineOutputSinkDebug.h" |
|
36 #include "MemSpyEngineOutputSinkFile.h" |
|
37 #include <memspy/engine/memspyenginehelperchunk.h> |
|
38 #include <memspy/engine/memspyenginehelpercodesegment.h> |
|
39 #include <memspy/engine/memspyenginehelperheap.h> |
|
40 #include <memspy/engine/memspyenginehelperstack.h> |
|
41 #include <memspy/engine/memspyenginehelperthread.h> |
|
42 #include <memspy/engine/memspyenginehelperserver.h> |
|
43 #include <memspy/engine/memspyenginehelperprocess.h> |
|
44 #include <memspy/engine/memspyenginehelperactiveobject.h> |
|
45 #include <memspy/engine/memspyenginehelperkernelcontainers.h> |
|
46 #include <memspy/engine/memspyenginehelperfilesystem.h> |
|
47 #include <memspy/engine/memspyenginehelperecom.h> |
|
48 #include <memspy/engine/memspyenginehelpersysmemtracker.h> |
|
49 #include <memspy/engine/memspyenginehelperfbserv.h> |
|
50 #include <memspy/engine/memspyenginehelperrom.h> |
|
51 #include <memspy/engine/memspyenginehelperram.h> |
|
52 #include <memspy/engine/memspyenginehelperwindowserver.h> |
|
53 #include <memspy/engine/memspyenginehelpercondvar.h> |
|
54 |
|
55 #ifdef _DEBUG |
|
56 #define LOG(args...) RDebug::Printf(args) |
|
57 #else |
|
58 #define LOG(args...) |
|
59 #endif |
|
60 |
|
61 CMemSpyEngineImp::CMemSpyEngineImp( RFs& aFsSession, CMemSpyEngine& aEngine ) |
|
62 : iFsSession( aFsSession ), iEngine( aEngine ) |
|
63 { |
|
64 } |
|
65 |
|
66 |
|
67 CMemSpyEngineImp::~CMemSpyEngineImp() |
|
68 { |
|
69 LOG( "CMemSpyEngineImp::~CMemSpyEngineImp() - START" ); |
|
70 |
|
71 if ( iMidwife ) |
|
72 { |
|
73 iMidwife->RemoveObserver( *this ); |
|
74 } |
|
75 |
|
76 LOG( "CMemSpyEngineImp::~CMemSpyEngineImp() - deleting helpers..." ); |
|
77 delete iHelperSysMemTracker; |
|
78 delete iServer; |
|
79 delete iHelperKernelContainers; |
|
80 delete iHelperFbServ; |
|
81 delete iHelperHeap; |
|
82 delete iHelperStack; |
|
83 delete iHelperCodeSegment; |
|
84 delete iHelperChunk; |
|
85 delete iHelperThread; |
|
86 delete iHelperProcess; |
|
87 delete iHelperServer; |
|
88 delete iHelperActiveObject; |
|
89 delete iHelperFileSystem; |
|
90 delete iHelperECom; |
|
91 delete iHelperROM; |
|
92 delete iHelperRAM; |
|
93 delete iHelperWindowServer; |
|
94 delete iHelperCondVar; |
|
95 |
|
96 iHelperWindowServerLoader.Close(); |
|
97 |
|
98 LOG( "CMemSpyEngineImp::~CMemSpyEngineImp() - deleting utilities..." ); |
|
99 delete iChunkWatcher; |
|
100 delete iUndertaker; |
|
101 delete iMidwife; |
|
102 |
|
103 LOG( "CMemSpyEngineImp::~CMemSpyEngineImp() - destroying containers..." ); |
|
104 iContainers.ResetAndDestroy(); |
|
105 iContainers.Close(); |
|
106 |
|
107 LOG( "CMemSpyEngineImp::~CMemSpyEngineImp() - destroying driver..." ); |
|
108 if ( iMemSpyDriver ) |
|
109 { |
|
110 iMemSpyDriver->Close(); |
|
111 delete iMemSpyDriver; |
|
112 } |
|
113 |
|
114 LOG( "CMemSpyEngineImp::~CMemSpyEngineImp() - destroying sink..." ); |
|
115 delete iSink; |
|
116 |
|
117 LOG( "CMemSpyEngineImp::~CMemSpyEngineImp() - END" ); |
|
118 } |
|
119 |
|
120 |
|
121 void CMemSpyEngineImp::ConstructL() |
|
122 { |
|
123 LOG( "CMemSpyEngineImp::ConstructL() - START" ); |
|
124 // |
|
125 iFsSession.SetSessionPath( _L("\\") ); |
|
126 |
|
127 iServer = CMemSpyEngineServer::NewL( iEngine ); |
|
128 |
|
129 iMemSpyDriver = new(ELeave) RMemSpyDriverClient(); |
|
130 const TInt error = Driver().Open(); |
|
131 User::LeaveIfError( error ); |
|
132 // |
|
133 InstallSinkL( ESinkTypeDebug ); |
|
134 // |
|
135 iUndertaker = CMemSpyEngineUndertaker::NewL( Driver() ); |
|
136 iUndertaker->AddObserverL( *this ); |
|
137 // |
|
138 iMidwife = CMemSpyEngineMidwife::NewL( Driver() ); |
|
139 // |
|
140 iChunkWatcher = CMemSpyEngineChunkWatcher::NewL( Driver() ); |
|
141 // |
|
142 CMemSpyEngineObjectContainer* container = CMemSpyEngineObjectContainer::NewL( iEngine ); |
|
143 CleanupStack::PushL( container ); |
|
144 iContainers.InsertL( container, 0 ); |
|
145 CleanupStack::Pop( container ); |
|
146 // |
|
147 ConstructHelpersL(); |
|
148 // |
|
149 iHelperSysMemTracker = CMemSpyEngineHelperSysMemTracker::NewL( iEngine ); |
|
150 iMidwife->AddObserverL( *this ); |
|
151 |
|
152 LOG( "CMemSpyEngineImp::ConstructL() - END" ); |
|
153 } |
|
154 |
|
155 |
|
156 void CMemSpyEngineImp::ConstructHelpersL() |
|
157 { |
|
158 LOG( "CMemSpyEngineImp::ConstructHelpersL() - START" ); |
|
159 |
|
160 LOG( "CMemSpyEngineImp::ConstructHelpersL() - Heap..." ); |
|
161 iHelperHeap = CMemSpyEngineHelperHeap::NewL( iEngine ); |
|
162 |
|
163 LOG( "CMemSpyEngineImp::ConstructHelpersL() - Stack..." ); |
|
164 iHelperStack = CMemSpyEngineHelperStack::NewL( iEngine ); |
|
165 |
|
166 LOG( "CMemSpyEngineImp::ConstructHelpersL() - Code Segments..." ); |
|
167 iHelperCodeSegment = CMemSpyEngineHelperCodeSegment::NewL( iEngine ); |
|
168 |
|
169 LOG( "CMemSpyEngineImp::ConstructHelpersL() - Chunk..." ); |
|
170 iHelperChunk = CMemSpyEngineHelperChunk::NewL( iEngine ); |
|
171 |
|
172 LOG( "CMemSpyEngineImp::ConstructHelpersL() - Thread..." ); |
|
173 iHelperThread = CMemSpyEngineHelperThread::NewL( iEngine ); |
|
174 |
|
175 LOG( "CMemSpyEngineImp::ConstructHelpersL() - Process..." ); |
|
176 iHelperProcess = CMemSpyEngineHelperProcess::NewL( iEngine ); |
|
177 |
|
178 LOG( "CMemSpyEngineImp::ConstructHelpersL() - Server..." ); |
|
179 iHelperServer = CMemSpyEngineHelperServer::NewL( iEngine ); |
|
180 |
|
181 LOG( "CMemSpyEngineImp::ConstructHelpersL() - AO..." ); |
|
182 iHelperActiveObject = CMemSpyEngineHelperActiveObject::NewL( iEngine ); |
|
183 |
|
184 LOG( "CMemSpyEngineImp::ConstructHelpersL() - Kernel Containers..." ); |
|
185 iHelperKernelContainers = CMemSpyEngineHelperKernelContainers::NewL( iEngine ); |
|
186 |
|
187 LOG( "CMemSpyEngineImp::ConstructHelpersL() - File System..." ); |
|
188 iHelperFileSystem = CMemSpyEngineHelperFileSystem::NewL( iEngine ); |
|
189 |
|
190 LOG( "CMemSpyEngineImp::ConstructHelpersL() - ECOM..." ); |
|
191 iHelperECom = CMemSpyEngineHelperECom::NewL( iEngine ); |
|
192 |
|
193 LOG( "CMemSpyEngineImp::ConstructHelpersL() - FBSERV..." ); |
|
194 iHelperFbServ = CMemSpyEngineHelperFbServ::NewL( iEngine ); |
|
195 |
|
196 LOG( "CMemSpyEngineImp::ConstructHelpersL() - ROM..." ); |
|
197 iHelperROM = CMemSpyEngineHelperROM::NewL( iEngine ); |
|
198 |
|
199 LOG( "CMemSpyEngineImp::ConstructHelpersL() - RAM..." ); |
|
200 iHelperRAM = CMemSpyEngineHelperRAM::NewL( iEngine ); |
|
201 |
|
202 LOG( "CMemSpyEngineImp::ConstructHelpersL() - WindowServer..." ); |
|
203 |
|
204 TInt err = iHelperWindowServerLoader.Load( _L("memspywindowserverhelper.dll") ); |
|
205 LOG( "CMemSpyEngineImp::ConstructHelpersL() - WindowServer load err: %d", err ); |
|
206 if ( !err ) |
|
207 { |
|
208 #ifdef __WINS__ // ordinal is different |
|
209 TLibraryFunction entry = iHelperWindowServerLoader.Lookup( 3 ); |
|
210 #else |
|
211 TLibraryFunction entry = iHelperWindowServerLoader.Lookup( 1 ); |
|
212 #endif |
|
213 if ( entry != NULL ) |
|
214 { |
|
215 typedef MMemSpyEngineHelperWindowServer* (*TEntryFn)(void); |
|
216 TRAP(err, iHelperWindowServer = ((TEntryFn)entry)()); |
|
217 if (err) |
|
218 { |
|
219 LOG("err from memspywindowserverhelper.dll - %d", err); |
|
220 } |
|
221 } |
|
222 } |
|
223 |
|
224 LOG( "CMemSpyEngineImp::ConstructHelpersL() - CondVar..." ); |
|
225 iHelperCondVar = CMemSpyEngineHelperCondVar::NewL( iEngine ); |
|
226 |
|
227 LOG( "CMemSpyEngineImp::ConstructHelpersL() - END" ); |
|
228 } |
|
229 |
|
230 |
|
231 RFs& CMemSpyEngineImp::FsSession() |
|
232 { |
|
233 return iFsSession; |
|
234 } |
|
235 |
|
236 |
|
237 CMemSpyEngineObjectContainer& CMemSpyEngineImp::Container() |
|
238 { |
|
239 __ASSERT_ALWAYS( iContainers.Count() >= 1, MemSpyEngineUtils::Panic( EMemSpyEnginePanicInvalidContainer1 ) ); |
|
240 CMemSpyEngineObjectContainer* headContainer = iContainers[ 0 ]; |
|
241 return *headContainer; |
|
242 } |
|
243 |
|
244 |
|
245 const CMemSpyEngineObjectContainer& CMemSpyEngineImp::Container() const |
|
246 { |
|
247 __ASSERT_ALWAYS( iContainers.Count() >= 1, MemSpyEngineUtils::Panic( EMemSpyEnginePanicInvalidContainer2 ) ); |
|
248 const CMemSpyEngineObjectContainer* headContainer = iContainers[ 0 ]; |
|
249 return *headContainer; |
|
250 } |
|
251 |
|
252 |
|
253 void CMemSpyEngineImp::SetObserver( MMemSpyEngineObserver* aObserver ) |
|
254 { |
|
255 iObserver = aObserver; |
|
256 } |
|
257 |
|
258 |
|
259 void CMemSpyEngineImp::NotifyContainerChangeL() |
|
260 { |
|
261 if ( iObserver ) |
|
262 { |
|
263 iObserver->HandleMemSpyEngineEventL( MMemSpyEngineObserver::EHandleThreadsOrProcessesChanged, &Container() ); |
|
264 } |
|
265 } |
|
266 |
|
267 |
|
268 void CMemSpyEngineImp::NotifyClientServerOperationRequestL( TInt aType ) |
|
269 { |
|
270 if ( iObserver ) |
|
271 { |
|
272 iObserver->HandleMemSpyEngineEventL( MMemSpyEngineObserver::EHandleClientServerOperationRequest, reinterpret_cast< TAny* >( aType ) ); |
|
273 } |
|
274 } |
|
275 |
|
276 |
|
277 CMemSpyEngineOutputSink& CMemSpyEngineImp::Sink() |
|
278 { |
|
279 return *iSink; |
|
280 } |
|
281 |
|
282 |
|
283 TMemSpySinkType CMemSpyEngineImp::SinkType() |
|
284 { |
|
285 return iSink->Type(); |
|
286 } |
|
287 |
|
288 void CMemSpyEngineImp::InstallSinkL( TMemSpySinkType aType ) |
|
289 { |
|
290 InstallSinkL( aType, KNullDesC ); |
|
291 } |
|
292 |
|
293 void CMemSpyEngineImp::InstallSinkL( TMemSpySinkType aType, const TDesC& aRootFolder ) |
|
294 { |
|
295 LOG( "CMemSpyEngineImp::InstallSinkL() - START - switching sink from %d to %d...", (iSink != NULL ? iSink->Type() : -1), aType ); |
|
296 // |
|
297 CMemSpyEngineOutputSink* sink = NULL; |
|
298 // |
|
299 switch( aType ) |
|
300 { |
|
301 case ESinkTypeDebug: |
|
302 sink = CMemSpyEngineOutputSinkDebug::NewL( iEngine ); |
|
303 break; |
|
304 case ESinkTypeFile: |
|
305 sink = CMemSpyEngineOutputSinkFile::NewL( iEngine, aRootFolder ); |
|
306 break; |
|
307 } |
|
308 // |
|
309 delete iSink; |
|
310 iSink = sink; |
|
311 // |
|
312 LOG( "CMemSpyEngineImp::InstallSinkL() - END - sink type: %d", iSink->Type() ); |
|
313 } |
|
314 |
|
315 |
|
316 void CMemSpyEngineImp::ListOpenFilesL() |
|
317 { |
|
318 HelperFileSystem().ListOpenFilesL(); |
|
319 } |
|
320 |
|
321 |
|
322 void CMemSpyEngineImp::GetVersion( TVersion& aVersion ) |
|
323 { |
|
324 iMemSpyDriver->GetVersion( aVersion ); |
|
325 } |
|
326 |
|
327 |
|
328 TBool CMemSpyEngineImp::IsHelperWindowServerSupported() |
|
329 { |
|
330 return iHelperWindowServer != NULL; |
|
331 } |
|
332 |
|
333 |
|
334 CMemSpyEngineMidwife& CMemSpyEngineImp::Midwife() |
|
335 { |
|
336 return *iMidwife; |
|
337 } |
|
338 |
|
339 |
|
340 CMemSpyEngineUndertaker& CMemSpyEngineImp::Undertaker() |
|
341 { |
|
342 return *iUndertaker; |
|
343 } |
|
344 |
|
345 |
|
346 CMemSpyEngineChunkWatcher& CMemSpyEngineImp::ChunkWatcher() |
|
347 { |
|
348 return *iChunkWatcher; |
|
349 } |
|
350 |
|
351 |
|
352 CMemSpyEngineHelperHeap& CMemSpyEngineImp::HelperHeap() |
|
353 { |
|
354 return *iHelperHeap; |
|
355 } |
|
356 |
|
357 |
|
358 CMemSpyEngineHelperStack& CMemSpyEngineImp::HelperStack() |
|
359 { |
|
360 return *iHelperStack; |
|
361 } |
|
362 |
|
363 |
|
364 CMemSpyEngineHelperCodeSegment& CMemSpyEngineImp::HelperCodeSegment() |
|
365 { |
|
366 return *iHelperCodeSegment; |
|
367 } |
|
368 |
|
369 |
|
370 CMemSpyEngineHelperChunk& CMemSpyEngineImp::HelperChunk() |
|
371 { |
|
372 return *iHelperChunk; |
|
373 } |
|
374 |
|
375 |
|
376 CMemSpyEngineHelperThread& CMemSpyEngineImp::HelperThread() |
|
377 { |
|
378 return *iHelperThread; |
|
379 } |
|
380 |
|
381 |
|
382 CMemSpyEngineHelperProcess& CMemSpyEngineImp::HelperProcess() |
|
383 { |
|
384 return *iHelperProcess; |
|
385 } |
|
386 |
|
387 |
|
388 CMemSpyEngineHelperServer& CMemSpyEngineImp::HelperServer() |
|
389 { |
|
390 return *iHelperServer; |
|
391 } |
|
392 |
|
393 |
|
394 CMemSpyEngineHelperActiveObject& CMemSpyEngineImp::HelperActiveObject() |
|
395 { |
|
396 return *iHelperActiveObject; |
|
397 } |
|
398 |
|
399 |
|
400 CMemSpyEngineHelperKernelContainers& CMemSpyEngineImp::HelperKernelContainers() |
|
401 { |
|
402 return *iHelperKernelContainers; |
|
403 } |
|
404 |
|
405 |
|
406 CMemSpyEngineHelperFileSystem& CMemSpyEngineImp::HelperFileSystem() |
|
407 { |
|
408 return *iHelperFileSystem; |
|
409 } |
|
410 |
|
411 |
|
412 CMemSpyEngineHelperECom& CMemSpyEngineImp::HelperECom() |
|
413 { |
|
414 return *iHelperECom; |
|
415 } |
|
416 |
|
417 |
|
418 CMemSpyEngineHelperSysMemTracker& CMemSpyEngineImp::HelperSysMemTracker() |
|
419 { |
|
420 return *iHelperSysMemTracker; |
|
421 } |
|
422 |
|
423 |
|
424 CMemSpyEngineHelperFbServ& CMemSpyEngineImp::HelperFbServ() |
|
425 { |
|
426 return *iHelperFbServ; |
|
427 } |
|
428 |
|
429 |
|
430 CMemSpyEngineHelperROM& CMemSpyEngineImp::HelperROM() |
|
431 { |
|
432 return *iHelperROM; |
|
433 } |
|
434 |
|
435 |
|
436 CMemSpyEngineHelperRAM& CMemSpyEngineImp::HelperRAM() |
|
437 { |
|
438 return *iHelperRAM; |
|
439 } |
|
440 |
|
441 |
|
442 MMemSpyEngineHelperWindowServer& CMemSpyEngineImp::HelperWindowServer() |
|
443 { |
|
444 return *iHelperWindowServer; |
|
445 } |
|
446 |
|
447 |
|
448 CMemSpyEngineHelperCondVar& CMemSpyEngineImp::HelperCondVar() |
|
449 { |
|
450 return *iHelperCondVar; |
|
451 } |
|
452 |
|
453 |
|
454 RMemSpyDriverClient& CMemSpyEngineImp::Driver() |
|
455 { |
|
456 return *iMemSpyDriver; |
|
457 } |
|
458 |
|
459 |
|
460 TInt CMemSpyEngineImp::ProcessSuspendAndGetErrorLC( TProcessId aId ) |
|
461 { |
|
462 __ASSERT_ALWAYS( iSuspendedProcess == aId || iSuspendedProcess == 0, MemSpyEngineUtils::Panic( EMemSpyEnginePanicSuspendRequest1 ) ); |
|
463 |
|
464 TInt errorOrCount = Driver().ProcessThreadsSuspend( aId ); |
|
465 if ( errorOrCount >= 0 ) |
|
466 { |
|
467 if ( errorOrCount == 1 ) |
|
468 { |
|
469 iSuspendedProcess = aId; |
|
470 } |
|
471 else |
|
472 { |
|
473 // Suspending already suspended process |
|
474 __ASSERT_ALWAYS( iSuspendedProcess == aId, MemSpyEngineUtils::Panic( EMemSpyEnginePanicSuspendRequest2 ) ); |
|
475 } |
|
476 // |
|
477 CleanupStack::PushL( TCleanupItem( ResumeSuspendedProcess, this ) ); |
|
478 |
|
479 if ( errorOrCount == 1 ) |
|
480 { |
|
481 iSink->ProcessSuspendedL( aId ); |
|
482 } |
|
483 |
|
484 // At this point, all was well |
|
485 errorOrCount = KErrNone; |
|
486 } |
|
487 |
|
488 return errorOrCount; |
|
489 } |
|
490 |
|
491 |
|
492 void CMemSpyEngineImp::ProcessSuspendLC( TProcessId aId ) |
|
493 { |
|
494 const TInt error = ProcessSuspendAndGetErrorLC( aId ); |
|
495 User::LeaveIfError( error ); |
|
496 } |
|
497 |
|
498 |
|
499 void CMemSpyEngineImp::ProcessResume() |
|
500 { |
|
501 const TUint id = iSuspendedProcess; |
|
502 // |
|
503 const TInt errorOrCount = Driver().ProcessThreadsResume( id ); |
|
504 // |
|
505 if ( errorOrCount == 0 ) |
|
506 { |
|
507 iSink->ProcessResumed( id ); |
|
508 iSuspendedProcess = 0; |
|
509 } |
|
510 } |
|
511 |
|
512 |
|
513 TProcessId CMemSpyEngineImp::SuspendedProcessId() const |
|
514 { |
|
515 return TProcessId( iSuspendedProcess ); |
|
516 } |
|
517 |
|
518 |
|
519 void CMemSpyEngineImp::ResumeSuspendedProcess( TAny* aSelf ) |
|
520 { |
|
521 CMemSpyEngineImp* self = reinterpret_cast< CMemSpyEngineImp* >( aSelf ); |
|
522 self->ProcessResume(); |
|
523 } |
|
524 |
|
525 |
|
526 void CMemSpyEngineImp::ThreadIsDeadL( const TThreadId& aId, const RThread& aThread ) |
|
527 { |
|
528 if ( aThread.Handle() != KNullHandle ) |
|
529 { |
|
530 const TFullName name( aThread.FullName() ); |
|
531 // |
|
532 TBuf<128> exitInfo; |
|
533 const TExitCategoryName exitCategory( aThread.ExitCategory() ); |
|
534 CMemSpyThread::AppendExitInfo( exitInfo, aThread.ExitType(), aThread.ExitReason(), exitCategory ); |
|
535 // |
|
536 _LIT( KMemSpyEventInfoText, "[MemSpy] Thread died: %S [%d - 0x%04x] %S" ); |
|
537 Sink().OutputLineFormattedL( KMemSpyEventInfoText, &name, (TUint32) aId, (TUint32) aId, &exitInfo ); |
|
538 } |
|
539 } |
|
540 |
|
541 |
|
542 void CMemSpyEngineImp::ProcessIsDeadL( const TProcessId& aId, const RProcess& aProcess ) |
|
543 { |
|
544 if ( aProcess.Handle() != KNullHandle ) |
|
545 { |
|
546 const TFullName name( aProcess.FullName() ); |
|
547 // |
|
548 TBuf<128> exitInfo; |
|
549 const TExitCategoryName exitCategory( aProcess.ExitCategory() ); |
|
550 CMemSpyThread::AppendExitInfo( exitInfo, aProcess.ExitType(), aProcess.ExitReason(), exitCategory ); |
|
551 // |
|
552 _LIT( KMemSpyEventInfoText, "[MemSpy] Process died: %S [%d - 0x%04x] %S" ); |
|
553 Sink().OutputLineFormattedL( KMemSpyEventInfoText, &name, (TUint32) aId, (TUint32) aId, &exitInfo ); |
|
554 } |
|
555 } |
|
556 |
|
557 |
|
558 void CMemSpyEngineImp::ThreadIsBornL( const TThreadId& aId, const RThread& aThread ) |
|
559 { |
|
560 if ( aThread.Handle() != KNullHandle ) |
|
561 { |
|
562 const TFullName name( aThread.FullName() ); |
|
563 // |
|
564 _LIT( KMemSpyEventInfoText, "[MemSpy] Thread created: %S (%d / 0x%08x)" ); |
|
565 Sink().OutputLineFormattedL( KMemSpyEventInfoText, &name, (TUint32) aId, (TUint32) aId ); |
|
566 } |
|
567 } |
|
568 |
|
569 |
|
570 void CMemSpyEngineImp::ProcessIsBornL( const TProcessId& aId, const RProcess& aProcess ) |
|
571 { |
|
572 if ( aProcess.Handle() != KNullHandle ) |
|
573 { |
|
574 const TFullName name( aProcess.FullName() ); |
|
575 // |
|
576 _LIT( KMemSpyEventInfoText, "[MemSpy] Process created: %S (%d / 0x%08x)" ); |
|
577 Sink().OutputLineFormattedL( KMemSpyEventInfoText, &name, (TUint32) aId, (TUint32) aId ); |
|
578 } |
|
579 } |
|
580 |
|
581 |
|
582 |