projects / deliverable / tracecompass.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Monster fix: TMF model update + corresponding LTTng adaptations + JUnits
[deliverable/tracecompass.git] / org.eclipse.linuxtools.lttng.tests / src / org / eclipse / linuxtools / lttng / state / handlers / after / StateAfterUpdateHandlers.java
1 /*******************************************************************************
2 * Copyright (c) 2009 Ericsson
3 *
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
8 *
9 * Contributors:
10 * Alvaro Sanchez-Leon (alvsan09@gmail.com) - Initial API and implementation
11 *******************************************************************************/
12 package org.eclipse.linuxtools.lttng.state.handlers.after;
13
14
15
16 import org.eclipse.linuxtools.lttng.TraceDebug;
17 import org.eclipse.linuxtools.lttng.event.LttngEvent;
18 import org.eclipse.linuxtools.lttng.state.StateStrings.Events;
19 import org.eclipse.linuxtools.lttng.state.StateStrings.ExecutionMode;
20 import org.eclipse.linuxtools.lttng.state.evProcessor.IEventProcessing;
21 import org.eclipse.linuxtools.lttng.state.handlers.AbsStateUpdate;
22 import org.eclipse.linuxtools.lttng.state.model.LttngExecutionState;
23 import org.eclipse.linuxtools.lttng.state.model.LttngProcessState;
24 import org.eclipse.linuxtools.lttng.state.model.LttngTraceState;
25
26 /**
27 * Process the system call entry event
28 *
29 * @author alvaro
30 *
31 */
32 class StateAfterUpdateHandlers {
33
34 final IEventProcessing getSyscallEntryHandler() {
35 AbsStateUpdate handler = new AbsStateUpdate() {
36
37 private Events eventType = Events.LTT_EVENT_SYSCALL_ENTRY;
38
39 // @Override
40 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
41 // TraceDebug.debug("After event called");
42
43 Long cpu = trcEvent.getCpuId();
44
45 // No syscall_entry update for initialization process
46 LttngProcessState process = traceSt.getRunning_process().get(
47 cpu);
48
49 if (pid != process.getPid()) {
50 TraceDebug
51 .debug("pid values don't match from before and after verification check");
52 }
53
54 if (process.getPid() == 0L) {
55 return true;
56 }
57
58 // Make sure the top of the stack and the state of the stack are
59 // set to the
60 // same object.
61 LttngExecutionState stackState = process.peekFromExecutionStack();
62 if (stackState != process.getState()) {
63 TraceDebug
64 .debug("The top of the stack does not match to the process state");
65 }
66
67 if (stackState.getExec_mode().getInName() != ExecutionMode.LTTV_STATE_SYSCALL
68 .getInName()) {
69 TraceDebug.debug("Unexpected ExecutionMode: "
70 + stackState.getExec_mode().getInName()
71 + " Expected: "
72 + ExecutionMode.LTTV_STATE_SYSCALL.getInName());
73 }
74
75 if (stackState.getEntry_LttTime() != trcEvent.getTimestamp().getValue()) {
76 TraceDebug.debug("Unexpected Entry time: "
77 + trcEvent.getTimestamp() + " Expected: "
78 + stackState.getEntry_LttTime());
79 }
80
81 return false;
82 }
83
84 // @Override
85 public Events getEventHandleType() {
86 return eventType;
87 }
88 };
89 return handler;
90 }
91
92 final IEventProcessing getsySyscallExitHandler() {
93 AbsStateUpdate handler = new AbsStateUpdate() {
94
95 private Events eventType = Events.LTT_EVENT_SYSCALL_EXIT;
96
97 // @Override
98 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
99
100 // TraceDebug.debug("Syscall Exit After event called");
101 Long cpu = trcEvent.getCpuId();
102 LttngProcessState process = traceSt.getRunning_process().get(
103 cpu);
104
105 /* There can be no system call from PID 0 : unknown state */
106 if (process.getPid() == 0L) {
107 if (pid != 0L) {
108 TraceDebug
109 .debug("Unexpected pid from before and after verfication methods, before pid: "
110 + pid
111 + " after pid: "
112 + process.getPid_time());
113 }
114 return true;
115 }
116
117 //
118 // pop_state(cpu, StateStrings.ExecutionMode.LTTV_STATE_SYSCALL,
119 // traceSt, trcEvent.getTimestamp());
120 return false;
121
122 }
123
124 // @Override
125 public Events getEventHandleType() {
126 return eventType;
127 }
128 };
129 return handler;
130 }
131
132 /**
133 * Update stacks related to the parsing of an LttngEvent
134 *
135 * @return
136 */
137 final IEventProcessing getTrapEntryHandler() {
138 AbsStateUpdate handler = new AbsStateUpdate() {
139
140 private Events eventType = Events.LTT_EVENT_TRAP_ENTRY;
141
142 // @Override
143 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
144 // Long cpu = trcEvent.getCpuId();
145 //
146 // Long trap = getAFieldLong(trcEvent, traceSt,
147 // Fields.LTT_FIELD_TRAP_ID);
148 // if (trap == null) {
149 // return true;
150 // }
151 //
152 // String submode = traceSt.getSyscall_names()
153 // .get(trap);
154 //
155 // if (submode == null) {
156 // submode = ExecutionSubMode.LTTV_STATE_SUBMODE_UNKNOWN
157 // .getInName();
158 // }
159 //
160 // /* update process state */
161 // push_state(cpu, StateStrings.ExecutionMode.LTTV_STATE_TRAP,
162 // submode, trcEvent.getTimestamp(), traceSt);
163 //
164 // /* update cpu status */
165 // LTTngCPUState cpust = traceSt.getCpu_states().get(cpu);
166 // cpu_push_mode(cpust, StateStrings.CpuMode.LTTV_CPU_TRAP);
167 // cpust.setLast_trap(trap); /* update trap status */
168 //
169 // // update Trap State
170 // LttngTrapState trap_state = traceSt.getTrap_states().get(
171 // trap);
172 // trap_state.incrementRunning();
173
174 return false;
175
176 }
177
178 // @Override
179 public Events getEventHandleType() {
180 return eventType;
181 }
182 };
183 return handler;
184 }
185
186 /**
187 *
188 * @return
189 */
190 final IEventProcessing getTrapExitHandler() {
191 AbsStateUpdate handler = new AbsStateUpdate() {
192
193 private Events eventType = Events.LTT_EVENT_TRAP_EXIT;
194
195 // @Override
196 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
197 //
198 // Long cpu = trcEvent.getCpuId();
199 // LTTngCPUState cpust = traceSt.getCpu_states().get(cpu);
200 // Long trap = cpust.getLast_trap();
201 //
202 // pop_state(cpu, ExecutionMode.LTTV_STATE_TRAP, traceSt,
203 // trcEvent
204 // .getTimestamp());
205 //
206 // /* update cpu status */
207 // cpu_pop_mode(cpust);
208 //
209 // /* update trap status */
210 // if (trap != -1L) {
211 // traceSt.getTrap_states().get(trap).decrementRunning();
212 // }
213 return false;
214
215 }
216
217 // @Override
218 public Events getEventHandleType() {
219 return eventType;
220 }
221 };
222 return handler;
223 }
224
225 /**
226 *
227 * @return
228 */
229 final IEventProcessing getIrqEntryHandler() {
230 AbsStateUpdate handler = new AbsStateUpdate() {
231
232 private Events eventType = Events.LTT_EVENT_IRQ_ENTRY;
233
234 // @Override
235 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
236 //
237 // Long cpu = trcEvent.getCpuId();
238 //
239 // Long irq = getAFieldLong(trcEvent, traceSt,
240 // Fields.LTT_FIELD_IRQ_ID);
241 // if (irq == null) {
242 // return true;
243 // }
244 //
245 // String submode;
246 // submode = traceSt.getIrq_names().get(irq);
247 //
248 // if (submode == null) {
249 // submode =
250 // ExecutionSubMode.LTTV_STATE_SUBMODE_UNKNOWN.getInName();
251 // }
252 //
253 // /*
254 // * Do something with the info about being in user or system
255 // mode
256 // * when int?
257 // */
258 // push_state(cpu, ExecutionMode.LTTV_STATE_IRQ, submode,
259 // trcEvent
260 // .getTimestamp(), traceSt);
261 //
262 // /* update cpu state */
263 // LTTngCPUState cpust = traceSt.getCpu_states().get(cpu);
264 // cpu_push_mode(cpust, CpuMode.LTTV_CPU_IRQ); /* mode stack */
265 // cpust.setLast_irq(irq); /* last irq */
266 //
267 // /* udpate irq state */
268 // irq_push_mode(traceSt.getIrq_states().get(irq),
269 // IRQMode.LTTV_IRQ_BUSY);
270 return false;
271
272 }
273
274 public Events getEventHandleType() {
275 return eventType;
276 }
277 };
278 return handler;
279 }
280
281 /**
282 *
283 * @return
284 */
285 final IEventProcessing getSoftIrqExitHandler() {
286 AbsStateUpdate handler = new AbsStateUpdate() {
287
288 private Events eventType = Events.LTT_EVENT_SOFT_IRQ_EXIT;
289
290 // @Override
291 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
292 //
293 // Long cpu = trcEvent.getCpuId();
294 // LTTngCPUState cpust = traceSt.getCpu_states().get(cpu);
295 // Long softirq = cpust.getLast_soft_irq();
296 // pop_state(cpu, ExecutionMode.LTTV_STATE_SOFT_IRQ, traceSt,
297 // trcEvent.getTimestamp());
298 //
299 // /* update softirq status */
300 // if (softirq != -1) {
301 // LttngSoftIRQState softIrqstate = traceSt
302 // .getSoft_irq_states().get(softirq);
303 // softIrqstate.decrementRunning();
304 // }
305 //
306 // /* update cpu status */
307 // cpu_pop_mode(cpust);
308
309 return false;
310 }
311
312 // @Override
313 public Events getEventHandleType() {
314 return eventType;
315 }
316 };
317 return handler;
318 }
319
320 /**
321 *
322 * @return
323 */
324 final IEventProcessing getIrqExitHandler() {
325 AbsStateUpdate handler = new AbsStateUpdate() {
326
327 private Events eventType = Events.LTT_EVENT_IRQ_EXIT;
328
329 // @Override
330 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
331 //
332 // Long cpu = trcEvent.getCpuId();
333 //
334 // /* update process state */
335 // pop_state(cpu, ExecutionMode.LTTV_STATE_IRQ, traceSt,
336 // trcEvent
337 // .getTimestamp());
338 //
339 // /* update cpu status */
340 // LTTngCPUState cpust = traceSt.getCpu_states().get(cpu);
341 // cpu_pop_mode(cpust);
342 //
343 // /* update irq status */
344 // Long last_irq = cpust.getLast_irq();
345 // if (last_irq != -1L) {
346 // LttngIRQState irq_state = traceSt.getIrq_states().get(
347 // last_irq);
348 // irq_pop_mode(irq_state);
349 // }
350
351 return false;
352
353 }
354
355 // @Override
356 public Events getEventHandleType() {
357 return eventType;
358 }
359 };
360 return handler;
361 }
362
363 /**
364 *
365 * @return
366 */
367 final IEventProcessing getSoftIrqRaiseHandler() {
368 AbsStateUpdate handler = new AbsStateUpdate() {
369
370 private Events eventType = Events.LTT_EVENT_SOFT_IRQ_RAISE;
371
372 // @Override
373 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
374 //
375 // // Long cpu = trcEvent.getCpuId();
376 //
377 // // get event field
378 // Long softirq = getAFieldLong(trcEvent, traceSt,
379 // Fields.LTT_FIELD_SOFT_IRQ_ID);
380 //
381 // if (softirq == null) {
382 // return true;
383 // }
384 //
385 // // String submode;
386 // // String[] softIrqNames = traceSt.getSoft_irq_names();
387 // // if (softirq < softIrqNames.length) {
388 // // submode = softIrqNames[softirq];
389 // // } else {
390 // // submode = "softirq " + softirq;
391 // // }
392 //
393 // /* update softirq status */
394 // /* a soft irq raises are not cumulative */
395 // LttngSoftIRQState irqState =
396 // traceSt.getSoft_irq_states().get(
397 // softirq);
398 // if (irqState != null) {
399 // irqState.setPending(1L);
400 // } else {
401 // TraceDebug
402 // .debug("unexpected soft irq id value: " + softirq);
403 // }
404
405 return false;
406
407 }
408
409 // @Override
410 public Events getEventHandleType() {
411 return eventType;
412 }
413 };
414 return handler;
415 }
416
417 /**
418 *
419 * @return
420 */
421 final IEventProcessing getSoftIrqEntryHandler() {
422 AbsStateUpdate handler = new AbsStateUpdate() {
423
424 private Events eventType = Events.LTT_EVENT_SOFT_IRQ_ENTRY;
425
426 // @Override
427 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
428 //
429 // // obtrain cpu
430 // Long cpu = trcEvent.getCpuId();
431 //
432 // // get event field
433 // Long softirq = getAFieldLong(trcEvent, traceSt,
434 // Fields.LTT_FIELD_SOFT_IRQ_ID);
435 //
436 // if (softirq == null) {
437 // return true;
438 // }
439 //
440 // // obtain submode
441 // Map<Long, String> softIrqNames = traceSt.getSoft_irq_names();
442 // String submode = softIrqNames.get(softirq);
443 // if (submode == null) {
444 // submode = "softirq " + softirq;
445 // softIrqNames.put(softirq, submode);
446 // }
447 //
448 // /* update softirq status */
449 // LttngSoftIRQState irqState =
450 // traceSt.getSoft_irq_states().get(
451 // softirq);
452 // if (irqState != null) {
453 // irqState.decrementPending();
454 // irqState.incrementRunning();
455 // } else {
456 // TraceDebug
457 // .debug("unexpected soft irq id value: " + softirq);
458 // }
459 //
460 // /* update cpu state */
461 // LTTngCPUState cpu_state = traceSt.getCpu_states().get(cpu);
462 // cpu_state.setLast_soft_irq(softirq);
463 // cpu_push_mode(cpu_state, CpuMode.LTTV_CPU_SOFT_IRQ);
464 //
465 // /* update process execution mode state stack */
466 // push_state(cpu, ExecutionMode.LTTV_STATE_SOFT_IRQ, submode,
467 // trcEvent.getTimestamp(), traceSt);
468
469 return false;
470
471 }
472
473 // @Override
474 public Events getEventHandleType() {
475 return eventType;
476 }
477 };
478 return handler;
479 }
480
481 /**
482 * Method to handle the event: LTT_EVENT_LIST_INTERRRUPT
483 *
484 * @return
485 */
486 final IEventProcessing getEnumInterruptHandler() {
487 AbsStateUpdate handler = new AbsStateUpdate() {
488
489 private Events eventType = Events.LTT_EVENT_LIST_INTERRUPT;
490
491 // @Override
492 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
493 // String action = getAFieldString(trcEvent, traceSt,
494 // Fields.LTT_FIELD_ACTION);
495 // Long irq = getAFieldLong(trcEvent, traceSt,
496 // Fields.LTT_FIELD_IRQ_ID);
497 //
498 // Map<Long, String> irq_names = traceSt.getIrq_names();
499 //
500 // irq_names.put(irq, action);
501 return false;
502
503 }
504
505 // @Override
506 public Events getEventHandleType() {
507 return eventType;
508 }
509 };
510 return handler;
511 }
512
513 /**
514 * Handle the event LTT_EVENT_REQUEST_ISSUE
515 *
516 * @return
517 */
518 final IEventProcessing getBdevRequestIssueHandler() {
519 AbsStateUpdate handler = new AbsStateUpdate() {
520
521 private Events eventType = Events.LTT_EVENT_REQUEST_ISSUE;
522
523 // @Override
524 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
525 //
526 // // Get Fields
527 // Long major = getAFieldLong(trcEvent, traceSt,
528 // Fields.LTT_FIELD_MAJOR);
529 // Long minor = getAFieldLong(trcEvent, traceSt,
530 // Fields.LTT_FIELD_MINOR);
531 // Long operation = getAFieldLong(trcEvent, traceSt,
532 // Fields.LTT_FIELD_OPERATION);
533 //
534 // // calculate bdevcode
535 // Long devcode = mkdev(major, minor);
536 //
537 // if (devcode == null) {
538 // TraceDebug
539 // .debug("incorrect calcualtion of bdevcode input( major: "
540 // + major
541 // + " minor: "
542 // + minor
543 // + " operation: " + operation);
544 // return true;
545 // }
546 //
547 // Map<Long, LttngBdevState> bdev_states = traceSt
548 // .getBdev_states();
549 // // Get the instance
550 // LttngBdevState bdevState = bdev_states.get(devcode);
551 // if (bdevState == null) {
552 // bdevState = new LttngBdevState();
553 // }
554 //
555 // // update the mode in the stack
556 // if (operation == 0L) {
557 // bdevState.getMode_stack().push(
558 // BdevMode.LTTV_BDEV_BUSY_READING);
559 // } else {
560 // bdevState.getMode_stack().push(
561 // BdevMode.LTTV_BDEV_BUSY_WRITING);
562 // }
563 //
564 // // make sure it is included in the set
565 // bdev_states.put(devcode, bdevState);
566 return false;
567
568 }
569
570 // @Override
571 public Events getEventHandleType() {
572 return eventType;
573 }
574 };
575 return handler;
576 }
577
578 /**
579 * <p>
580 * Handling event: LTT_EVENT_REQUEST_COMPLETE
581 * </p>
582 * <p>
583 * FIELDS(LTT_FIELD_MAJOR, LTT_FIELD_MINOR, LTT_FIELD_OPERATION
584 * </p>
585 *
586 * @return
587 */
588 final IEventProcessing getBdevRequestCompleteHandler() {
589 AbsStateUpdate handler = new AbsStateUpdate() {
590
591 private Events eventType = Events.LTT_EVENT_REQUEST_COMPLETE;
592
593 // @Override
594 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
595 //
596 // // Get Fields
597 // Long major = getAFieldLong(trcEvent, traceSt,
598 // Fields.LTT_FIELD_MAJOR);
599 // Long minor = getAFieldLong(trcEvent, traceSt,
600 // Fields.LTT_FIELD_MINOR);
601 // Long operation = getAFieldLong(trcEvent, traceSt,
602 // Fields.LTT_FIELD_OPERATION);
603 //
604 // // calculate bdevcode
605 // Long devcode = mkdev(major, minor);
606 //
607 // if (devcode == null) {
608 // TraceDebug
609 // .debug("incorrect calcualtion of bdevcode input( major: "
610 // + major
611 // + " minor: "
612 // + minor
613 // + " operation: " + operation);
614 // return true;
615 // }
616 //
617 // Map<Long, LttngBdevState> bdev_states = traceSt
618 // .getBdev_states();
619 // // Get the instance
620 // LttngBdevState bdevState = bdev_states.get(devcode);
621 // if (bdevState == null) {
622 // bdevState = new LttngBdevState();
623 // }
624 //
625 // /* update block device */
626 // bdev_pop_mode(bdevState);
627
628 return false;
629
630 }
631
632 // @Override
633 public Events getEventHandleType() {
634 return eventType;
635 }
636 };
637 return handler;
638 }
639
640 /**
641 * <p>
642 * Handles event: LTT_EVENT_FUNCTION_ENTRY
643 * </p>
644 * <p>
645 * FIELDS: LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE
646 * </p>
647 *
648 * @return
649 */
650 final IEventProcessing getFunctionEntryHandler() {
651 AbsStateUpdate handler = new AbsStateUpdate() {
652
653 private Events eventType = Events.LTT_EVENT_FUNCTION_ENTRY;
654
655 // @Override
656 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
657 // Long cpu = trcEvent.getCpuId();
658 // Long funcptr = getAFieldLong(trcEvent, traceSt,
659 // Fields.LTT_FIELD_THIS_FN);
660 //
661 // push_function(traceSt, funcptr, cpu);
662 return false;
663
664 }
665
666 // @Override
667 public Events getEventHandleType() {
668 return eventType;
669 }
670 };
671 return handler;
672 }
673
674 /**
675 *
676 * @return
677 */
678 final IEventProcessing getFunctionExitHandler() {
679 AbsStateUpdate handler = new AbsStateUpdate() {
680
681 private Events eventType = Events.LTT_EVENT_FUNCTION_EXIT;
682
683 // @Override
684 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
685 //
686 // Long funcptr = getAFieldLong(trcEvent, traceSt,
687 // Fields.LTT_FIELD_THIS_FN);
688 //
689 // pop_function(traceSt, trcEvent, funcptr);
690 return false;
691
692 }
693
694 // @Override
695 public Events getEventHandleType() {
696 return eventType;
697 }
698 };
699 return handler;
700 }
701
702 /**
703 * <p>
704 * process event: LTT_EVENT_SYS_CALL_TABLE
705 * </p>
706 * <p>
707 * fields: LTT_FIELD_ID, LTT_FIELD_ADDRESS, LTT_FIELD_SYMBOL
708 * </p>
709 *
710 * @return
711 */
712 final IEventProcessing getDumpSyscallHandler() {
713 AbsStateUpdate handler = new AbsStateUpdate() {
714
715 private Events eventType = Events.LTT_EVENT_SYS_CALL_TABLE;
716
717 // @Override
718 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
719 // // obtain the syscall id
720 // Long id = getAFieldLong(trcEvent, traceSt,
721 // Fields.LTT_FIELD_ID);
722 //
723 // // Long address = getAFieldLong(trcEvent, traceSt,
724 // // Fields.LTT_FIELD_ADDRESS);
725 //
726 // // Obtain the symbol
727 // String symbol = getAFieldString(trcEvent, traceSt,
728 // Fields.LTT_FIELD_SYMBOL);
729 //
730 // // fill the symbol to the sycall_names collection
731 // traceSt.getSyscall_names().put(id, symbol);
732
733 return false;
734 }
735
736 // @Override
737 public Events getEventHandleType() {
738 return eventType;
739 }
740 };
741 return handler;
742 }
743
744 /**
745 * <p>
746 * Handles event: LTT_EVENT_KPROBE_TABLE
747 * </p>
748 * <p>
749 * Fields: LTT_FIELD_IP, LTT_FIELD_SYMBOL
750 * </p>
751 *
752 * @return
753 */
754 final IEventProcessing getDumpKprobeHandler() {
755 AbsStateUpdate handler = new AbsStateUpdate() {
756
757 private Events eventType = Events.LTT_EVENT_KPROBE_TABLE;
758
759 // @Override
760 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
761 //
762 // Long ip = getAFieldLong(trcEvent, traceSt,
763 // Fields.LTT_FIELD_IP);
764 // String symbol = getAFieldString(trcEvent, traceSt,
765 // Fields.LTT_FIELD_SYMBOL);
766 //
767 // traceSt.getKprobe_table().put(ip, symbol);
768
769 return false;
770
771 }
772
773 // @Override
774 public Events getEventHandleType() {
775 return eventType;
776 }
777 };
778 return handler;
779 }
780
781 /**
782 * <p>
783 * Handles: LTT_EVENT_SOFTIRQ_VEC
784 * </p>
785 * <p>
786 * Fields: LTT_FIELD_ID, LTT_FIELD_ADDRESS, LTT_FIELD_SYMBOL
787 * </p>
788 *
789 * @return
790 */
791 final IEventProcessing getDumpSoftIrqHandler() {
792 AbsStateUpdate handler = new AbsStateUpdate() {
793
794 private Events eventType = Events.LTT_EVENT_SOFTIRQ_VEC;
795
796 // @Override
797 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
798 //
799 // // Get id
800 // Long id = getAFieldLong(trcEvent, traceSt,
801 // Fields.LTT_FIELD_ID);
802 //
803 // // Address not needed
804 // // Long address = ltt_event_get_long_unsigned(e,
805 // // lttv_trace_get_hook_field(th,
806 // // 1));
807 //
808 // // Get symbol
809 // String symbol = getAFieldString(trcEvent, traceSt,
810 // Fields.LTT_FIELD_SYMBOL);
811 //
812 // // Register the soft irq name
813 // traceSt.getSoft_irq_names().put(id, symbol);
814 return false;
815
816 }
817
818 // @Override
819 public Events getEventHandleType() {
820 return eventType;
821 }
822 };
823 return handler;
824 }
825
826 /**
827 * <p>
828 * Handles: LTT_EVENT_SCHED_SCHEDULE
829 * </p>
830 * <p>
831 * Fields: LTT_FIELD_PREV_PID, LTT_FIELD_NEXT_PID, LTT_FIELD_PREV_STATE
832 * </p>
833 *
834 * @return
835 */
836 final IEventProcessing getSchedChangeHandler() {
837 AbsStateUpdate handler = new AbsStateUpdate() {
838
839 private Events eventType = Events.LTT_EVENT_SCHED_SCHEDULE;
840
841 // @Override
842 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
843 //
844 // Long cpu = trcEvent.getCpuId();
845 // TmfTimestamp eventTime = trcEvent.getTimestamp();
846 //
847 // LttngProcessState process = traceSt.getRunning_process().get(
848 // cpu);
849 //
850 // Long pid_out = getAFieldLong(trcEvent, traceSt,
851 // Fields.LTT_FIELD_PREV_PID);
852 // Long pid_in = getAFieldLong(trcEvent, traceSt,
853 // Fields.LTT_FIELD_NEXT_PID);
854 // Long state_out = getAFieldLong(trcEvent, traceSt,
855 // Fields.LTT_FIELD_PREV_STATE);
856 //
857 // if (process != null) {
858 //
859 // /*
860 // * We could not know but it was not the idle process
861 // * executing. This should only happen at the beginning,
862 // * before the first schedule event, and when the initial
863 // * information (current process for each CPU) is missing. It
864 // * is not obvious how we could, after the fact, compensate
865 // * the wrongly attributed statistics.
866 // */
867 //
868 // // This test only makes sense once the state is known and if
869 // // there
870 // // is no
871 // // missing events. We need to silently ignore schedchange
872 // // coming
873 // // after a
874 // // process_free, or it causes glitches. (FIXME)
875 // // if(unlikely(process->pid != pid_out)) {
876 // // g_assert(process->pid == 0);
877 // // }
878 // if (process.getPid() == 0
879 // && process.getState().getExec_mode() ==
880 // ExecutionMode.LTTV_STATE_MODE_UNKNOWN) {
881 // if (pid_out == 0) {
882 // /*
883 // * Scheduling out of pid 0 at beginning of the trace
884 // * : we know for sure it is in syscall mode at this
885 // * point.
886 // */
887 // int stackSize = process.getExecution_stack().size();
888 // if (stackSize != 1) {
889 // TraceDebug
890 // .debug("unpexpected process execution stack size, expected 1, received: ");
891 // }
892 //
893 // process.getState().setExec_mode(
894 // ExecutionMode.LTTV_STATE_SYSCALL);
895 // process.getState().setProc_status(
896 // ProcessStatus.LTTV_STATE_WAIT);
897 // process.getState().setChage_Time(
898 // trcEvent.getTimestamp());
899 // process.getState().setEntry_Time(
900 // trcEvent.getTimestamp());
901 // }
902 // } else {
903 // if (process.getState().getProc_status() ==
904 // ProcessStatus.LTTV_STATE_EXIT) {
905 // process.getState().setProc_status(
906 // ProcessStatus.LTTV_STATE_ZOMBIE);
907 // process.getState().setChage_Time(
908 // trcEvent.getTimestamp());
909 // } else {
910 // if (state_out == 0L) {
911 // process.getState().setProc_status(
912 // ProcessStatus.LTTV_STATE_WAIT_CPU);
913 // } else {
914 // process.getState().setProc_status(
915 // ProcessStatus.LTTV_STATE_WAIT);
916 // }
917 //
918 // process.getState().setChage_Time(
919 // trcEvent.getTimestamp());
920 // }
921 //
922 // if (state_out == 32L || state_out == 64L) { /*
923 // * EXIT_DEAD
924 // * ||
925 // * TASK_DEAD
926 // */
927 // /* see sched.h for states */
928 // if (!exit_process(traceSt, process)) {
929 // process.getState().setProc_status(
930 // ProcessStatus.LTTV_STATE_DEAD);
931 // process.getState().setChage_Time(
932 // trcEvent.getTimestamp());
933 // }
934 // }
935 // }
936 // }
937 // process = lttv_state_find_process_or_create(traceSt, cpu,
938 // pid_in, eventTime);
939 //
940 // traceSt.getRunning_process().put(cpu, process);
941 //
942 // process.getState().setProc_status(ProcessStatus.LTTV_STATE_RUN);
943 // process.getState().setChage_Time(eventTime);
944 // process.setCpu(cpu);
945 // // process->state->s = LTTV_STATE_RUN;
946 // // if(process->usertrace)
947 // // process->usertrace->cpu = cpu;
948 // // process->last_cpu_index =
949 // // ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
950 //
951 // // process->state->change = s->parent.timestamp;
952 //
953 // LTTngCPUState cpu_state = traceSt.getCpu_states().get(cpu);
954 // /* update cpu status */
955 // if (pid_in == 0) {
956 //
957 // /* going to idle task */
958 // cpu_set_base_mode(cpu_state, CpuMode.LTTV_CPU_IDLE);
959 // } else {
960 // /*
961 // * scheduling a real task. we must be careful here: if we
962 // * just schedule()'ed to a process that is in a trap, we
963 // * must put the cpu in trap mode
964 // */
965 // cpu_set_base_mode(cpu_state, CpuMode.LTTV_CPU_BUSY);
966 // if (process.getState().getExec_mode() ==
967 // ExecutionMode.LTTV_STATE_TRAP) {
968 // cpu_push_mode(cpu_state, CpuMode.LTTV_CPU_TRAP);
969 // }
970 // }
971 return false;
972
973 }
974
975 // @Override
976 public Events getEventHandleType() {
977 return eventType;
978 }
979 };
980 return handler;
981 }
982
983 /**
984 * <p>
985 * Handles: LTT_EVENT_PROCESS_FORK
986 * </p>
987 * <p>
988 * Fields: FIELD_ARRAY(LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID,
989 * LTT_FIELD_CHILD_TGID)
990 * </p>
991 *
992 * @return
993 */
994 final IEventProcessing getProcessForkHandler() {
995 AbsStateUpdate handler = new AbsStateUpdate() {
996
997 private Events eventType = Events.LTT_EVENT_PROCESS_FORK;
998
999 // @Override
1000 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
1001 //
1002 // Long cpu = trcEvent.getCpuId();
1003 // LttngProcessState process = traceSt.getRunning_process().get(
1004 // cpu);
1005 // TmfTimestamp timeStamp = trcEvent.getTimestamp();
1006 //
1007 // // /* Parent PID */
1008 // // Long parent_pid = getAFieldLong(trcEvent, traceSt,
1009 // // Fields.LTT_FIELD_PARENT_PID);
1010 //
1011 // /* Child PID */
1012 // /* In the Linux Kernel, there is one PID per thread. */
1013 // Long child_pid = getAFieldLong(trcEvent, traceSt,
1014 // Fields.LTT_FIELD_CHILD_PID);
1015 //
1016 // /* Child TGID */
1017 // /* tgid in the Linux kernel is the "real" POSIX PID. */
1018 // Long child_tgid = getAFieldLong(trcEvent, traceSt,
1019 // Fields.LTT_FIELD_CHILD_TGID);
1020 // if (child_tgid == null) {
1021 // child_tgid = 0L;
1022 // }
1023 //
1024 // /*
1025 // * Mathieu : it seems like the process might have been
1026 // scheduled
1027 // * in before the fork, and, in a rare case, might be the
1028 // current
1029 // * process. This might happen in a SMP case where we don't
1030 // have
1031 // * enough precision on the clocks.
1032 // *
1033 // * Test reenabled after precision fixes on time. (Mathieu)
1034 // */
1035 // // #if 0
1036 // // zombie_process = lttv_state_find_process(ts, ANY_CPU,
1037 // // child_pid);
1038 // //
1039 // // if(unlikely(zombie_process != NULL)) {
1040 // // /* Reutilisation of PID. Only now we are sure that the old
1041 // // PID
1042 // // * has been released. FIXME : should know when release_task
1043 // // happens
1044 // // instead.
1045 // // */
1046 // // guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t);
1047 // // guint i;
1048 // // for(i=0; i< num_cpus; i++) {
1049 // // g_assert(zombie_process != ts->running_process[i]);
1050 // // }
1051 // //
1052 // // exit_process(s, zombie_process);
1053 // // }
1054 // // #endif //0
1055 //
1056 // if (process.getPid() == child_pid) {
1057 // TraceDebug
1058 // .debug("Unexpected, process pid equal to child pid: "
1059 // + child_pid
1060 // + " Event Time: "
1061 // + trcEvent.getTimestamp());
1062 // }
1063 //
1064 // // g_assert(process->pid != child_pid);
1065 // // FIXME : Add this test in the "known state" section
1066 // // g_assert(process->pid == parent_pid);
1067 // LttngProcessState child_process = lttv_state_find_process(
1068 // traceSt, ANY_CPU, child_pid);
1069 // if (child_process == null) {
1070 // child_process = create_process(traceSt, cpu, child_pid,
1071 // child_tgid, timeStamp);
1072 // } else {
1073 // /*
1074 // * The process has already been created : due to time
1075 // * imprecision between multiple CPUs : it has been scheduled
1076 // * in before creation. Note that we shouldn't have this kind
1077 // * of imprecision.
1078 // *
1079 // * Simply put a correct parent.
1080 // */
1081 // StringBuilder sb = new StringBuilder("Process " + child_pid);
1082 // sb.append(" has been created at ["
1083 // + child_process.getCration_time() + "] ");
1084 // sb.append("and inserted at ["
1085 // + child_process.getInsertion_time() + "] ");
1086 // sb.append("before \nfork on cpu " + cpu + " Event time: ["
1087 // + trcEvent + "]\n.");
1088 // sb
1089 // .append("Probably an unsynchronized TSD problem on the traced machine.");
1090 // TraceDebug.debug(sb.toString());
1091 //
1092 // // g_assert(0); /* This is a problematic case : the process
1093 // // has
1094 // // beencreated
1095 // // before the fork event */
1096 // child_process.setPpid(process.getPid());
1097 // child_process.setTgid(child_tgid);
1098 // }
1099 //
1100 // if (!child_process.getName().equals(
1101 // ProcessStatus.LTTV_STATE_UNNAMED.getInName())) {
1102 // TraceDebug.debug("Unexpected child process status: "
1103 // + child_process.getName());
1104 // }
1105 //
1106 // child_process.setName(process.getName());
1107 // child_process.setBrand(process.getBrand());
1108
1109 return false;
1110
1111 }
1112
1113 // @Override
1114 public Events getEventHandleType() {
1115 return eventType;
1116 }
1117 };
1118 return handler;
1119 }
1120
1121 /**
1122 * <p>
1123 * Handles: LTT_EVENT_KTHREAD_CREATE
1124 * </p>
1125 * <p>
1126 * Fields: LTT_FIELD_PID
1127 * </p>
1128 *
1129 * @return
1130 */
1131 final IEventProcessing getProcessKernelThreadHandler() {
1132 AbsStateUpdate handler = new AbsStateUpdate() {
1133
1134 private Events eventType = Events.LTT_EVENT_KTHREAD_CREATE;
1135
1136 // @Override
1137 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
1138 // /*
1139 // * We stamp a newly created process as kernel_thread. The
1140 // thread
1141 // * should not be running yet.
1142 // */
1143 //
1144 // LttngExecutionState exState;
1145 // Long pid;
1146 // LttngProcessState process;
1147 //
1148 // /* PID */
1149 // pid = getAFieldLong(trcEvent, traceSt, Fields.LTT_FIELD_PID);
1150 // // s->parent.target_pid = pid;
1151 //
1152 // process = lttv_state_find_process_or_create(traceSt, ANY_CPU,
1153 // pid, new TmfTimestamp());
1154 //
1155 // if (!process.getState().getProc_status().equals(
1156 // ProcessStatus.LTTV_STATE_DEAD)) {
1157 // // Leave only the first element in the stack with execution
1158 // // mode to
1159 // // syscall
1160 // Stack<LttngExecutionState> processExStack = process
1161 // .getExecution_stack();
1162 // exState = processExStack.firstElement();
1163 // exState.setExec_mode(ExecutionMode.LTTV_STATE_SYSCALL);
1164 // if (processExStack.size() > 1) {
1165 // processExStack.clear();
1166 // processExStack.add(exState);
1167 // }
1168 //
1169 // // update the process state to the only one in the stack
1170 // process.setState(exState);
1171 // }
1172 //
1173 // process.setType(ProcessType.LTTV_STATE_KERNEL_THREAD);
1174
1175 return false;
1176
1177 }
1178
1179 // @Override
1180 public Events getEventHandleType() {
1181 return eventType;
1182 }
1183 };
1184 return handler;
1185 }
1186
1187 /**
1188 * <p>
1189 * Handles: LTT_EVENT_PROCESS_EXIT
1190 * </p>
1191 * <p>
1192 * LTT_FIELD_PID
1193 * </p>
1194 *
1195 * @return
1196 */
1197 final IEventProcessing getProcessExitHandler() {
1198 AbsStateUpdate handler = new AbsStateUpdate() {
1199
1200 private Events eventType = Events.LTT_EVENT_PROCESS_EXIT;
1201
1202 // @Override
1203 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
1204 //
1205 // Long pid;
1206 // LttngProcessState process;
1207 //
1208 // pid = getAFieldLong(trcEvent, traceSt,
1209 // Fields.LTT_FIELD_PID);
1210 // // s->parent.target_pid = pid;
1211 //
1212 // // FIXME : Add this test in the "known state" section
1213 // // g_assert(process->pid == pid);
1214 //
1215 // process = lttv_state_find_process(traceSt, ANY_CPU, pid);
1216 // if (process != null) {
1217 // process.getState().setProc_status(
1218 // ProcessStatus.LTTV_STATE_EXIT);
1219 // }
1220 return false;
1221
1222 }
1223
1224 // @Override
1225 public Events getEventHandleType() {
1226 return eventType;
1227 }
1228 };
1229 return handler;
1230 }
1231
1232 /**
1233 * <p>
1234 * Handles: LTT_EVENT_PROCESS_FREE
1235 * </p>
1236 * <p>
1237 * Fields: LTT_FIELD_PID
1238 * </p>
1239 *
1240 * @return
1241 */
1242 final IEventProcessing getProcessFreeHandler() {
1243 AbsStateUpdate handler = new AbsStateUpdate() {
1244
1245 private Events eventType = Events.LTT_EVENT_PROCESS_FREE;
1246
1247 // @Override
1248 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
1249 //
1250 // Long release_pid;
1251 // LttngProcessState process;
1252 //
1253 // /* PID of the process to release */
1254 // release_pid = getAFieldLong(trcEvent, traceSt,
1255 // Fields.LTT_FIELD_PID);
1256 // // s->parent.target_pid = release_pid;
1257 //
1258 // if (release_pid == 0) {
1259 // TraceDebug.debug("Unexpected release_pid: 0, Event time: "
1260 // + trcEvent.getTimestamp());
1261 // }
1262 //
1263 // process = lttv_state_find_process(traceSt, ANY_CPU,
1264 // release_pid);
1265 // if (process != null) {
1266 // exit_process(traceSt, process);
1267 // }
1268
1269 return false;
1270 // DISABLED
1271 // if(process != null) {
1272 /*
1273 * release_task is happening at kernel level : we can now safely
1274 * release the data structure of the process
1275 */
1276 // This test is fun, though, as it may happen that
1277 // at time t : CPU 0 : process_free
1278 // at time t+150ns : CPU 1 : schedule out
1279 // Clearly due to time imprecision, we disable it. (Mathieu)
1280 // If this weird case happen, we have no choice but to put the
1281 // Currently running process on the cpu to 0.
1282 // I re-enable it following time precision fixes. (Mathieu)
1283 // Well, in the case where an process is freed by a process on
1284 // another
1285 // CPU
1286 // and still scheduled, it happens that this is the schedchange
1287 // that
1288 // will
1289 // drop the last reference count. Do not free it here!
1290
1291 // int num_cpus = ltt_trace_get_num_cpu(ts->parent.t);
1292 // guint i;
1293 // for(i=0; i< num_cpus; i++) {
1294 // //g_assert(process != ts->running_process[i]);
1295 // if(process == ts->running_process[i]) {
1296 // //ts->running_process[i] = lttv_state_find_process(ts, i, 0);
1297 // break;
1298 // }
1299 // }
1300 // if(i == num_cpus) /* process is not scheduled */
1301 // exit_process(s, process);
1302 // }
1303 //
1304 // return false;
1305
1306 }
1307
1308 // @Override
1309 public Events getEventHandleType() {
1310 return eventType;
1311 }
1312 };
1313 return handler;
1314 }
1315
1316 /**
1317 * <p>
1318 * Handles: LTT_EVENT_EXEC
1319 * </p>
1320 * <p>
1321 * FIELDS: LTT_FIELD_FILENAME
1322 * </p>
1323 *
1324 * @return
1325 */
1326 final IEventProcessing getProcessExecHandler() {
1327 AbsStateUpdate handler = new AbsStateUpdate() {
1328
1329 private Events eventType = Events.LTT_EVENT_EXEC;
1330
1331 // @Override
1332 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
1333 //
1334 // Long cpu = trcEvent.getCpuId();
1335 // LttngProcessState process = traceSt.getRunning_process().get(
1336 // cpu);
1337 //
1338 // // #if 0//how to use a sequence that must be transformed in a
1339 // // string
1340 // // /* PID of the process to release */
1341 // // guint64 name_len = ltt_event_field_element_number(e,
1342 // // lttv_trace_get_hook_field(th, 0));
1343 // // //name = ltt_event_get_string(e,
1344 // // lttv_trace_get_hook_field(th, 0));
1345 // // LttField *child = ltt_event_field_element_select(e,
1346 // // lttv_trace_get_hook_field(th, 0), 0);
1347 // // gchar *name_begin =
1348 // // (gchar*)(ltt_event_data(e)+ltt_event_field_offset(e,
1349 // child));
1350 // // gchar *null_term_name = g_new(gchar, name_len+1);
1351 // // memcpy(null_term_name, name_begin, name_len);
1352 // // null_term_name[name_len] = '\0';
1353 // // process->name = g_quark_from_string(null_term_name);
1354 // // #endif //0
1355 //
1356 // process.setName(getAFieldString(trcEvent, traceSt,
1357 // Fields.LTT_FIELD_FILENAME));
1358 // process.setBrand(StateStrings.LTTV_STATE_UNBRANDED);
1359 return false;
1360
1361 }
1362
1363 // @Override
1364 public Events getEventHandleType() {
1365 return eventType;
1366 }
1367 };
1368 return handler;
1369 }
1370
1371 /**
1372 * <p>
1373 * LTT_EVENT_THREAD_BRAND
1374 * </p>
1375 * <p>
1376 * FIELDS: LTT_FIELD_NAME
1377 * </p>
1378 *
1379 * @return
1380 */
1381 final IEventProcessing GetThreadBrandHandler() {
1382 AbsStateUpdate handler = new AbsStateUpdate() {
1383
1384 private Events eventType = Events.LTT_EVENT_THREAD_BRAND;
1385
1386 // @Override
1387 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
1388 //
1389 // String name;
1390 // Long cpu = trcEvent.getCpuId();
1391 // LttngProcessState process = traceSt.getRunning_process().get(
1392 // cpu);
1393 //
1394 // name = getAFieldString(trcEvent, traceSt,
1395 // Fields.LTT_FIELD_NAME);
1396 // process.setBrand(name);
1397 return false;
1398
1399 }
1400
1401 // @Override
1402 public Events getEventHandleType() {
1403 return eventType;
1404 }
1405 };
1406 return handler;
1407 }
1408
1409 /**
1410 * @return
1411 */
1412 final IEventProcessing getStateDumpEndHandler() {
1413 AbsStateUpdate handler = new AbsStateUpdate() {
1414
1415 private Events eventType = Events.LTT_EVENT_STATEDUMP_END;
1416
1417 // @Override
1418 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
1419 //
1420 // /* For all processes */
1421 // /*
1422 // * if kernel thread, if stack[0] is unknown, set to syscall
1423 // * mode, wait
1424 // */
1425 // /* else, if stack[0] is unknown, set to user mode, running */
1426 // List<LttngProcessState> processes = traceSt.getProcesses();
1427 // TmfTimestamp time = trcEvent.getTimestamp();
1428 //
1429 // for (LttngProcessState process : processes) {
1430 // fix_process(process, time);
1431 // }
1432
1433 return false;
1434
1435 }
1436
1437 // @Override
1438 public Events getEventHandleType() {
1439 return eventType;
1440 }
1441 };
1442 return handler;
1443 }
1444
1445 /**
1446 * Private method used to establish the first execution state in the stack
1447 * for a given process
1448 *
1449 * @param process
1450 * @param timestamp
1451 */
1452 // private void fix_process(LttngProcessState process,
1453 // TmfTimestamp timestamp) {
1454 //
1455 // LttngExecutionState es;
1456 // Stack<LttngExecutionState> procStack = process
1457 // .getExecution_stack();
1458 //
1459 // if (process.getType() == ProcessType.LTTV_STATE_KERNEL_THREAD) {
1460 // es = procStack.firstElement();
1461 //
1462 // if (es.getExec_mode() == ExecutionMode.LTTV_STATE_MODE_UNKNOWN) {
1463 // es.setExec_mode(ExecutionMode.LTTV_STATE_SYSCALL);
1464 // es
1465 // .setExec_submode(ExecutionSubMode.LTTV_STATE_SUBMODE_NONE
1466 // .getInName());
1467 // es.setEntry_Time(timestamp);
1468 // es.setChage_Time(timestamp);
1469 // es.setCum_cpu_time(0L);
1470 // if (es.getProc_status() == ProcessStatus.LTTV_STATE_UNNAMED) {
1471 // es.setProc_status(ProcessStatus.LTTV_STATE_WAIT);
1472 // }
1473 // }
1474 // } else {
1475 // es = procStack.firstElement();
1476 // if (es.getExec_mode() == ExecutionMode.LTTV_STATE_MODE_UNKNOWN) {
1477 // es.setExec_mode(ExecutionMode.LTTV_STATE_USER_MODE);
1478 // es
1479 // .setExec_submode(ExecutionSubMode.LTTV_STATE_SUBMODE_NONE
1480 // .getInName());
1481 // es.setEntry_Time(timestamp);
1482 // es.setChage_Time(timestamp);
1483 // es.setCum_cpu_time(0L);
1484 // if (es.getProc_status() == ProcessStatus.LTTV_STATE_UNNAMED) {
1485 // es.setProc_status(ProcessStatus.LTTV_STATE_RUN);
1486 // }
1487 //
1488 // if (procStack.size() == 1) {
1489 // /*
1490 // * Still in bottom unknown mode, means never did a
1491 // * system call May be either in user mode, syscall
1492 // * mode, running or waiting.
1493 // */
1494 // /*
1495 // * FIXME : we may be tagging syscall mode when being
1496 // * user mode
1497 // */
1498 // // Get a new execution State
1499 // es = new LttngExecutionState();
1500 //
1501 // // initialize values
1502 // es.setExec_mode(ExecutionMode.LTTV_STATE_SYSCALL);
1503 // es
1504 // .setExec_submode(ExecutionSubMode.LTTV_STATE_SUBMODE_NONE
1505 // .getInName());
1506 // es.setEntry_Time(timestamp);
1507 // es.setChage_Time(timestamp);
1508 // es.setCum_cpu_time(0L);
1509 // es.setProc_status(ProcessStatus.LTTV_STATE_UNNAMED);
1510 //
1511 // // Push the new state to the stack
1512 // procStack.push(es);
1513 // }
1514 // }
1515 // }
1516 // }
1517 // };
1518 // return handler;
1519 // }
1520
1521 /**
1522 * <p>
1523 * Handles: LTT_EVENT_PROCESS_STATE
1524 * </p>
1525 * <p>
1526 * FIELDS: LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME,
1527 * LTT_FIELD_TYPE, LTT_FIELD_MODE, LTT_FIELD_SUBMODE, LTT_FIELD_STATUS,
1528 * LTT_FIELD_TGID
1529 * </p>
1530 *
1531 * @return
1532 */
1533 final IEventProcessing getEnumProcessStateHandler() {
1534 AbsStateUpdate handler = new AbsStateUpdate() {
1535
1536 private Events eventType = Events.LTT_EVENT_PROCESS_STATE;
1537
1538 // @Override
1539 public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
1540 //
1541 // Long parent_pid;
1542 // Long pid;
1543 // Long tgid;
1544 // String command;
1545 // Long cpu = trcEvent.getCpuId();
1546 // LttngProcessState process = traceSt.getRunning_process().get(
1547 // cpu);
1548 // LttngProcessState parent_process;
1549 // String type;
1550 // // String mode, submode, status;
1551 // LttngExecutionState es;
1552 //
1553 // /* PID */
1554 // pid = getAFieldLong(trcEvent, traceSt, Fields.LTT_FIELD_PID);
1555 //
1556 // /* Parent PID */
1557 // parent_pid = getAFieldLong(trcEvent, traceSt,
1558 // Fields.LTT_FIELD_PARENT_PID);
1559 //
1560 // /* Command name */
1561 // command = getAFieldString(trcEvent, traceSt,
1562 // Fields.LTT_FIELD_NAME);
1563 //
1564 // /* TODO: type field, Values need to be verified */
1565 // /* type */
1566 // Long typeVal = getAFieldLong(trcEvent, traceSt,
1567 // Fields.LTT_FIELD_TYPE);
1568 // if (typeVal == 0L) {
1569 // type = ProcessType.LTTV_STATE_KERNEL_THREAD.getInName();
1570 // } else {
1571 // type = ProcessType.LTTV_STATE_USER_THREAD.getInName();
1572 // }
1573 //
1574 // // FIXME: type is rarely used, enum must match possible
1575 // types.
1576 //
1577 // // /* mode */
1578 // // mode = getAFieldString(trcEvent, traceSt,
1579 // // Fields.LTT_FIELD_MODE);
1580 // //
1581 // // /* submode */
1582 // // submode = getAFieldString(trcEvent, traceSt,
1583 // // Fields.LTT_FIELD_SUBMODE);
1584 // //
1585 // // /* status */
1586 // // status = getAFieldString(trcEvent, traceSt,
1587 // // Fields.LTT_FIELD_STATUS);
1588 //
1589 // /* TGID */
1590 // tgid = getAFieldLong(trcEvent, traceSt,
1591 // Fields.LTT_FIELD_TGID);
1592 // if (tgid == null) {
1593 // tgid = 0L;
1594 // }
1595 //
1596 // if (pid == 0) {
1597 // for (Long acpu : traceSt.getCpu_states().keySet()) {
1598 // process = lttv_state_find_process(traceSt, acpu, pid);
1599 // if (process != null) {
1600 // process.setPpid(parent_pid);
1601 // process.setTgid(tgid);
1602 // process.setName(command);
1603 // process
1604 // .setType(ProcessType.LTTV_STATE_KERNEL_THREAD);
1605 // } else {
1606 // StringBuilder sb = new StringBuilder(
1607 // "Unexpected, null process read from the TraceState list of processes, event time: "
1608 // + trcEvent.getTimestamp());
1609 // TraceDebug.debug(sb.toString());
1610 // }
1611 // }
1612 // } else {
1613 // /*
1614 // * The process might exist if a process was forked while
1615 // * performing the state dump.
1616 // */
1617 // process = lttv_state_find_process(traceSt, ANY_CPU, pid);
1618 // if (process == null) {
1619 // parent_process = lttv_state_find_process(traceSt,
1620 // ANY_CPU, parent_pid);
1621 // process = create_process(traceSt, cpu, pid, tgid,
1622 // command, trcEvent.getTimestamp());
1623 // if (parent_process != null) {
1624 // process.setPpid(parent_process.getPid());
1625 // }
1626 //
1627 // /* Keep the stack bottom : a running user mode */
1628 // /*
1629 // * Disabled because of inconsistencies in the current
1630 // * statedump states.
1631 // */
1632 // if (type.equals(ProcessType.LTTV_STATE_KERNEL_THREAD
1633 // .getInName())) {
1634 // /*
1635 // * FIXME Kernel thread : can be in syscall or
1636 // * interrupt or trap.
1637 // */
1638 // /*
1639 // * Will cause expected trap when in fact being
1640 // * syscall (even after end of statedump event) Will
1641 // * cause expected interrupt when being syscall.
1642 // * (only before end of statedump event)
1643 // */
1644 // process
1645 // .setType(ProcessType.LTTV_STATE_KERNEL_THREAD);
1646 //
1647 // // #if 0
1648 // // es->t = LTTV_STATE_SYSCALL;
1649 // // es->s = status;
1650 // // es->n = submode;
1651 // // #endif //0
1652 // } else {
1653 // /*
1654 // * User space process : bottom : user mode either
1655 // * currently running or scheduled out. can be
1656 // * scheduled out because interrupted in (user mode
1657 // * or in syscall) or because of an explicit call to
1658 // * the scheduler in syscall. Note that the scheduler
1659 // * call comes after the irq_exit, so never in
1660 // * interrupt context.
1661 // */
1662 // // temp workaround : set size to 1 : only have user
1663 // // mode
1664 // // bottom of stack.
1665 // // will cause g_info message of expected syscall
1666 // // mode when
1667 // // in fact being
1668 // // in user mode. Can also cause expected trap when
1669 // // in fact
1670 // // being user
1671 // // mode in the event of a page fault reenabling
1672 // // interrupts
1673 // // in the handler.
1674 // // Expected syscall and trap can also happen after
1675 // // the end
1676 // // of statedump
1677 // // This will cause a
1678 // // "popping last state on stack, ignoring it."
1679 //
1680 // // process->execution_stack =
1681 // // g_array_set_size(process->execution_stack, 1);
1682 // // es = process->state =
1683 // // &g_array_index(process->execution_stack,
1684 // // LttvExecutionState, 0);
1685 // // a new process must have only one state in the
1686 // // stack and
1687 // // be the same as the current state
1688 // // es = process.getState();
1689 // // es.setExec_mode(ExecutionMode.LTTV_STATE_MODE_UNKNOWN);
1690 // // es.setProc_status(ProcessStatus.LTTV_STATE_UNNAMED);
1691 // // es
1692 // //
1693 // .setExec_submode(ExecutionSubMode.LTTV_STATE_SUBMODE_UNKNOWN
1694 // // .getInName());
1695 //
1696 // // #if 0
1697 // // es->t = LTTV_STATE_USER_MODE;
1698 // // es->s = status;
1699 // // es->n = submode;
1700 // // #endif //0
1701 // }
1702 // // TODO: clean up comments above: Moved repeated code
1703 // // from both
1704 // // if / else blocks above,
1705 // // comments left temporarily for easier visualization
1706 // // and
1707 // // comparision with c code
1708 // es = process.getState();
1709 // es.setExec_mode(ExecutionMode.LTTV_STATE_MODE_UNKNOWN);
1710 // es.setProc_status(ProcessStatus.LTTV_STATE_UNNAMED);
1711 // es
1712 // .setExec_submode(ExecutionSubMode.LTTV_STATE_SUBMODE_UNKNOWN
1713 // .getInName());
1714 // // #if 0
1715 // // /* UNKNOWN STATE */
1716 // // {
1717 // // es = process->state =
1718 // // &g_array_index(process->execution_stack,
1719 // // LttvExecutionState, 1);
1720 // // es->t = LTTV_STATE_MODE_UNKNOWN;
1721 // // es->s = LTTV_STATE_UNNAMED;
1722 // // es->n = LTTV_STATE_SUBMODE_UNKNOWN;
1723 // // }
1724 // // #endif //0
1725 // } else {
1726 // /*
1727 // * The process has already been created : Probably was
1728 // * forked while dumping the process state or was simply
1729 // * scheduled in prior to get the state dump event.
1730 // */
1731 // process.setPpid(parent_pid);
1732 // process.setTgid(tgid);
1733 // process.setName(command);
1734 // if (type.equals(ProcessType.LTTV_STATE_KERNEL_THREAD
1735 // .getInName())) {
1736 // process
1737 // .setType(ProcessType.LTTV_STATE_KERNEL_THREAD);
1738 // } else {
1739 // process.setType(ProcessType.LTTV_STATE_USER_THREAD);
1740 // }
1741 //
1742 // // es =
1743 // // &g_array_index(process->execution_stack,
1744 // // LttvExecutionState,
1745 // // 0);
1746 // // #if 0
1747 // // if(es->t == LTTV_STATE_MODE_UNKNOWN) {
1748 // // if(type == LTTV_STATE_KERNEL_THREAD)
1749 // // es->t = LTTV_STATE_SYSCALL;
1750 // // else
1751 // // es->t = LTTV_STATE_USER_MODE;
1752 // // }
1753 // // #endif //0
1754 // /*
1755 // * Don't mess around with the stack, it will eventually
1756 // * become ok after the end of state dump.
1757 // */
1758 // }
1759 // }
1760
1761 return false;
1762
1763 }
1764
1765 // @Override
1766 public Events getEventHandleType() {
1767 return eventType;
1768 }
1769 };
1770 return handler;
1771 }
1772
1773 }
Tracecompass - Deliverables
This page took 0.07403 seconds and 5 git commands to generate.