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