7 from babeltrace
import CTFWriter
, CTFStringEncoding
11 def __init__(self
, delete_trace
=True):
12 self
.delete_trace
= delete_trace
13 self
._trace
_root
= tempfile
.mkdtemp()
14 self
.trace_path
= os
.path
.join(self
.trace_root
, "kernel")
16 self
.create_stream_class()
17 self
.define_base_types()
27 return self
._trace
_root
30 shutil
.rmtree(self
.trace_root
)
33 self
.writer
.flush_metadata()
36 def create_writer(self
):
37 self
.clock
= CTFWriter
.Clock("A_clock")
38 self
.clock
.description
= "Simple clock"
39 self
.writer
= CTFWriter
.Writer(self
.trace_path
)
40 self
.writer
.add_clock(self
.clock
)
41 self
.writer
.add_environment_field("Python_version",
42 str(sys
.version_info
))
43 self
.writer
.add_environment_field("tracer_major", 2)
44 self
.writer
.add_environment_field("tracer_minor", 8)
45 self
.writer
.add_environment_field("tracer_patchlevel", 0)
47 def create_stream_class(self
):
48 self
.stream_class
= CTFWriter
.StreamClass("test_stream")
49 self
.stream_class
.clock
= self
.clock
51 def define_base_types(self
):
52 self
.char8_type
= CTFWriter
.IntegerFieldDeclaration(8)
53 self
.char8_type
.signed
= True
54 self
.char8_type
.encoding
= CTFStringEncoding
.UTF8
55 self
.char8_type
.alignment
= 8
57 self
.int16_type
= CTFWriter
.IntegerFieldDeclaration(16)
58 self
.int16_type
.signed
= True
59 self
.int16_type
.alignment
= 8
61 self
.uint16_type
= CTFWriter
.IntegerFieldDeclaration(16)
62 self
.uint16_type
.signed
= False
63 self
.uint16_type
.alignment
= 8
65 self
.int32_type
= CTFWriter
.IntegerFieldDeclaration(32)
66 self
.int32_type
.signed
= True
67 self
.int32_type
.alignment
= 8
69 self
.uint32_type
= CTFWriter
.IntegerFieldDeclaration(32)
70 self
.uint32_type
.signed
= False
71 self
.uint32_type
.alignment
= 8
73 self
.int64_type
= CTFWriter
.IntegerFieldDeclaration(64)
74 self
.int64_type
.signed
= True
75 self
.int64_type
.alignment
= 8
77 self
.uint64_type
= CTFWriter
.IntegerFieldDeclaration(64)
78 self
.uint64_type
.signed
= False
79 self
.uint64_type
.alignment
= 8
81 self
.array16_type
= CTFWriter
.ArrayFieldDeclaration(self
.char8_type
,
84 self
.string_type
= CTFWriter
.StringFieldDeclaration()
86 def add_event(self
, event
):
87 event
.add_field(self
.uint32_type
, "_cpu_id")
88 self
.stream_class
.add_event_class(event
)
90 def define_sched_switch(self
):
91 self
.sched_switch
= CTFWriter
.EventClass("sched_switch")
92 self
.sched_switch
.add_field(self
.array16_type
, "_prev_comm")
93 self
.sched_switch
.add_field(self
.int32_type
, "_prev_tid")
94 self
.sched_switch
.add_field(self
.int32_type
, "_prev_prio")
95 self
.sched_switch
.add_field(self
.int64_type
, "_prev_state")
96 self
.sched_switch
.add_field(self
.array16_type
, "_next_comm")
97 self
.sched_switch
.add_field(self
.int32_type
, "_next_tid")
98 self
.sched_switch
.add_field(self
.int32_type
, "_next_prio")
99 self
.add_event(self
.sched_switch
)
101 def define_softirq_raise(self
):
102 self
.softirq_raise
= CTFWriter
.EventClass("softirq_raise")
103 self
.softirq_raise
.add_field(self
.uint32_type
, "_vec")
104 self
.add_event(self
.softirq_raise
)
106 def define_softirq_entry(self
):
107 self
.softirq_entry
= CTFWriter
.EventClass("softirq_entry")
108 self
.softirq_entry
.add_field(self
.uint32_type
, "_vec")
109 self
.add_event(self
.softirq_entry
)
111 def define_softirq_exit(self
):
112 self
.softirq_exit
= CTFWriter
.EventClass("softirq_exit")
113 self
.softirq_exit
.add_field(self
.uint32_type
, "_vec")
114 self
.add_event(self
.softirq_exit
)
116 def define_irq_handler_entry(self
):
117 self
.irq_handler_entry
= CTFWriter
.EventClass("irq_handler_entry")
118 self
.irq_handler_entry
.add_field(self
.int32_type
, "_irq")
119 self
.irq_handler_entry
.add_field(self
.string_type
, "_name")
120 self
.add_event(self
.irq_handler_entry
)
122 def define_irq_handler_exit(self
):
123 self
.irq_handler_exit
= CTFWriter
.EventClass("irq_handler_exit")
124 self
.irq_handler_exit
.add_field(self
.int32_type
, "_irq")
125 self
.irq_handler_exit
.add_field(self
.int32_type
, "_ret")
126 self
.add_event(self
.irq_handler_exit
)
128 def define_syscall_entry_write(self
):
129 self
.syscall_entry_write
= CTFWriter
.EventClass("syscall_entry_write")
130 self
.syscall_entry_write
.add_field(self
.uint32_type
, "_fd")
131 self
.syscall_entry_write
.add_field(self
.uint64_type
, "_buf")
132 self
.syscall_entry_write
.add_field(self
.uint64_type
, "_count")
133 self
.add_event(self
.syscall_entry_write
)
135 def define_syscall_exit_write(self
):
136 self
.syscall_exit_write
= CTFWriter
.EventClass("syscall_exit_write")
137 self
.syscall_exit_write
.add_field(self
.int64_type
, "_ret")
138 self
.add_event(self
.syscall_exit_write
)
140 def define_syscall_entry_read(self
):
141 self
.syscall_entry_read
= CTFWriter
.EventClass("syscall_entry_read")
142 self
.syscall_entry_read
.add_field(self
.uint32_type
, "_fd")
143 self
.syscall_entry_read
.add_field(self
.uint64_type
, "_count")
144 self
.add_event(self
.syscall_entry_read
)
146 def define_syscall_exit_read(self
):
147 self
.syscall_exit_read
= CTFWriter
.EventClass("syscall_exit_read")
148 self
.syscall_exit_read
.add_field(self
.uint64_type
, "_buf")
149 self
.syscall_exit_read
.add_field(self
.int64_type
, "_ret")
150 self
.add_event(self
.syscall_exit_read
)
152 def define_syscall_entry_open(self
):
153 self
.syscall_entry_open
= CTFWriter
.EventClass("syscall_entry_open")
154 self
.syscall_entry_open
.add_field(self
.string_type
, "_filename")
155 self
.syscall_entry_open
.add_field(self
.int32_type
, "_flags")
156 self
.syscall_entry_open
.add_field(self
.uint16_type
, "_mode")
157 self
.add_event(self
.syscall_entry_open
)
159 def define_syscall_exit_open(self
):
160 self
.syscall_exit_open
= CTFWriter
.EventClass("syscall_exit_open")
161 self
.syscall_exit_open
.add_field(self
.int64_type
, "_ret")
162 self
.add_event(self
.syscall_exit_open
)
164 def define_lttng_statedump_process_state(self
):
165 self
.lttng_statedump_process_state
= CTFWriter
.EventClass(
166 "lttng_statedump_process_state")
167 self
.lttng_statedump_process_state
.add_field(self
.int32_type
, "_tid")
168 self
.lttng_statedump_process_state
.add_field(self
.int32_type
, "_vtid")
169 self
.lttng_statedump_process_state
.add_field(self
.int32_type
, "_pid")
170 self
.lttng_statedump_process_state
.add_field(self
.int32_type
, "_vpid")
171 self
.lttng_statedump_process_state
.add_field(self
.int32_type
, "_ppid")
172 self
.lttng_statedump_process_state
.add_field(self
.int32_type
, "_vppid")
173 self
.lttng_statedump_process_state
.add_field(self
.array16_type
,
175 self
.lttng_statedump_process_state
.add_field(self
.int32_type
, "_type")
176 self
.lttng_statedump_process_state
.add_field(self
.int32_type
, "_mode")
177 self
.lttng_statedump_process_state
.add_field(self
.int32_type
,
179 self
.lttng_statedump_process_state
.add_field(self
.int32_type
,
181 self
.lttng_statedump_process_state
.add_field(self
.int32_type
,
183 self
.add_event(self
.lttng_statedump_process_state
)
185 def define_lttng_statedump_file_descriptor(self
):
186 self
.lttng_statedump_file_descriptor
= CTFWriter
.EventClass(
187 "lttng_statedump_file_descriptor")
188 self
.lttng_statedump_file_descriptor
.add_field(self
.int32_type
, "_pid")
189 self
.lttng_statedump_file_descriptor
.add_field(self
.int32_type
, "_fd")
190 self
.lttng_statedump_file_descriptor
.add_field(self
.uint32_type
,
192 self
.lttng_statedump_file_descriptor
.add_field(self
.uint32_type
,
194 self
.lttng_statedump_file_descriptor
.add_field(self
.string_type
,
196 self
.add_event(self
.lttng_statedump_file_descriptor
)
198 def define_sched_wakeup(self
):
199 self
.sched_wakeup
= CTFWriter
.EventClass("sched_wakeup")
200 self
.sched_wakeup
.add_field(self
.array16_type
, "_comm")
201 self
.sched_wakeup
.add_field(self
.int32_type
, "_tid")
202 self
.sched_wakeup
.add_field(self
.int32_type
, "_prio")
203 self
.sched_wakeup
.add_field(self
.int32_type
, "_success")
204 self
.sched_wakeup
.add_field(self
.int32_type
, "_target_cpu")
205 self
.add_event(self
.sched_wakeup
)
207 def define_sched_waking(self
):
208 self
.sched_waking
= CTFWriter
.EventClass("sched_waking")
209 self
.sched_waking
.add_field(self
.array16_type
, "_comm")
210 self
.sched_waking
.add_field(self
.int32_type
, "_tid")
211 self
.sched_waking
.add_field(self
.int32_type
, "_prio")
212 self
.sched_waking
.add_field(self
.int32_type
, "_target_cpu")
213 self
.add_event(self
.sched_waking
)
215 def define_block_rq_complete(self
):
216 self
.block_rq_complete
= CTFWriter
.EventClass("block_rq_complete")
217 self
.block_rq_complete
.add_field(self
.uint32_type
, "_dev")
218 self
.block_rq_complete
.add_field(self
.uint64_type
, "_sector")
219 self
.block_rq_complete
.add_field(self
.uint32_type
, "_nr_sector")
220 self
.block_rq_complete
.add_field(self
.int32_type
, "_errors")
221 self
.block_rq_complete
.add_field(self
.uint32_type
, "_rwbs")
222 self
.block_rq_complete
.add_field(self
.uint64_type
, "__cmd_length")
223 self
.block_rq_complete
.add_field(self
.array16_type
, "_cmd")
224 self
.add_event(self
.block_rq_complete
)
226 def define_block_rq_issue(self
):
227 self
.block_rq_issue
= CTFWriter
.EventClass("block_rq_issue")
228 self
.block_rq_issue
.add_field(self
.uint32_type
, "_dev")
229 self
.block_rq_issue
.add_field(self
.uint64_type
, "_sector")
230 self
.block_rq_issue
.add_field(self
.uint32_type
, "_nr_sector")
231 self
.block_rq_issue
.add_field(self
.uint32_type
, "_bytes")
232 self
.block_rq_issue
.add_field(self
.int32_type
, "_tid")
233 self
.block_rq_issue
.add_field(self
.uint32_type
, "_rwbs")
234 self
.block_rq_issue
.add_field(self
.uint64_type
, "__cmd_length")
235 self
.block_rq_issue
.add_field(self
.array16_type
, "_cmd")
236 self
.block_rq_issue
.add_field(self
.array16_type
, "_comm")
237 self
.add_event(self
.block_rq_issue
)
239 def define_net_dev_xmit(self
):
240 self
.net_dev_xmit
= CTFWriter
.EventClass("net_dev_xmit")
241 self
.net_dev_xmit
.add_field(self
.uint64_type
, "_skbaddr")
242 self
.net_dev_xmit
.add_field(self
.int32_type
, "_rc")
243 self
.net_dev_xmit
.add_field(self
.uint32_type
, "_len")
244 self
.net_dev_xmit
.add_field(self
.string_type
, "_name")
245 self
.add_event(self
.net_dev_xmit
)
247 def define_netif_receive_skb(self
):
248 self
.netif_receive_skb
= CTFWriter
.EventClass("netif_receive_skb")
249 self
.netif_receive_skb
.add_field(self
.uint64_type
, "_skbaddr")
250 self
.netif_receive_skb
.add_field(self
.uint32_type
, "_len")
251 self
.netif_receive_skb
.add_field(self
.string_type
, "_name")
252 self
.add_event(self
.netif_receive_skb
)
254 def define_events(self
):
255 self
.define_sched_switch()
256 self
.define_softirq_raise()
257 self
.define_softirq_entry()
258 self
.define_softirq_exit()
259 self
.define_irq_handler_entry()
260 self
.define_irq_handler_exit()
261 self
.define_syscall_entry_write()
262 self
.define_syscall_exit_write()
263 self
.define_syscall_entry_read()
264 self
.define_syscall_exit_read()
265 self
.define_syscall_entry_open()
266 self
.define_syscall_exit_open()
267 self
.define_lttng_statedump_process_state()
268 self
.define_lttng_statedump_file_descriptor()
269 self
.define_sched_wakeup()
270 self
.define_sched_waking()
271 self
.define_block_rq_complete()
272 self
.define_block_rq_issue()
273 self
.define_net_dev_xmit()
274 self
.define_netif_receive_skb()
276 def create_stream(self
):
277 self
.stream
= self
.writer
.create_stream(self
.stream_class
)
279 def set_char_array(self
, event
, string
):
281 string
= string
[0:16]
283 string
= "%s" % (string
+ "\0" * (16 - len(string
)))
285 for i
, char
in enumerate(string
):
286 event
.field(i
).value
= ord(char
)
288 def set_int(self
, event
, value
):
291 def set_string(self
, event
, value
):
294 def write_softirq_raise(self
, time_ms
, cpu_id
, vec
):
295 event
= CTFWriter
.Event(self
.softirq_raise
)
296 self
.clock
.time
= time_ms
* 1000000
297 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
298 self
.set_int(event
.payload("_vec"), vec
)
299 self
.stream
.append_event(event
)
302 def write_softirq_entry(self
, time_ms
, cpu_id
, vec
):
303 event
= CTFWriter
.Event(self
.softirq_entry
)
304 self
.clock
.time
= time_ms
* 1000000
305 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
306 self
.set_int(event
.payload("_vec"), vec
)
307 self
.stream
.append_event(event
)
310 def write_softirq_exit(self
, time_ms
, cpu_id
, vec
):
311 event
= CTFWriter
.Event(self
.softirq_exit
)
312 self
.clock
.time
= time_ms
* 1000000
313 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
314 self
.set_int(event
.payload("_vec"), vec
)
315 self
.stream
.append_event(event
)
318 def write_irq_handler_entry(self
, time_ms
, cpu_id
, irq
, name
):
319 event
= CTFWriter
.Event(self
.irq_handler_entry
)
320 self
.clock
.time
= time_ms
* 1000000
321 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
322 self
.set_int(event
.payload("_irq"), irq
)
323 self
.set_string(event
.payload("_name"), name
)
324 self
.stream
.append_event(event
)
327 def write_irq_handler_exit(self
, time_ms
, cpu_id
, irq
, ret
):
328 event
= CTFWriter
.Event(self
.irq_handler_exit
)
329 self
.clock
.time
= time_ms
* 1000000
330 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
331 self
.set_int(event
.payload("_irq"), irq
)
332 self
.set_int(event
.payload("_ret"), ret
)
333 self
.stream
.append_event(event
)
336 def write_syscall_write(self
, time_ms
, cpu_id
, delay
, fd
, buf
, count
, ret
):
337 event_entry
= CTFWriter
.Event(self
.syscall_entry_write
)
338 self
.clock
.time
= time_ms
* 1000000
339 self
.set_int(event_entry
.payload("_cpu_id"), cpu_id
)
340 self
.set_int(event_entry
.payload("_fd"), fd
)
341 self
.set_int(event_entry
.payload("_buf"), buf
)
342 self
.set_int(event_entry
.payload("_count"), count
)
343 self
.stream
.append_event(event_entry
)
345 event_exit
= CTFWriter
.Event(self
.syscall_exit_write
)
346 self
.clock
.time
= (time_ms
+ delay
) * 1000000
347 self
.set_int(event_exit
.payload("_cpu_id"), cpu_id
)
348 self
.set_int(event_exit
.payload("_ret"), ret
)
349 self
.stream
.append_event(event_exit
)
352 def write_syscall_read(self
, time_ms
, cpu_id
, delay
, fd
, buf
, count
, ret
):
353 event_entry
= CTFWriter
.Event(self
.syscall_entry_read
)
354 self
.clock
.time
= time_ms
* 1000000
355 self
.set_int(event_entry
.payload("_cpu_id"), cpu_id
)
356 self
.set_int(event_entry
.payload("_fd"), fd
)
357 self
.set_int(event_entry
.payload("_count"), count
)
358 self
.stream
.append_event(event_entry
)
360 event_exit
= CTFWriter
.Event(self
.syscall_exit_read
)
361 self
.clock
.time
= (time_ms
+ delay
) * 1000000
362 self
.set_int(event_exit
.payload("_cpu_id"), cpu_id
)
363 self
.set_int(event_exit
.payload("_buf"), buf
)
364 self
.set_int(event_exit
.payload("_ret"), ret
)
365 self
.stream
.append_event(event_exit
)
368 def write_syscall_open(self
, time_ms
, cpu_id
, delay
, filename
, flags
,
370 event
= CTFWriter
.Event(self
.syscall_entry_open
)
371 self
.clock
.time
= time_ms
* 1000000
372 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
373 self
.set_string(event
.payload("_filename"), filename
)
374 self
.set_int(event
.payload("_flags"), flags
)
375 self
.set_int(event
.payload("_mode"), mode
)
376 self
.stream
.append_event(event
)
379 event
= CTFWriter
.Event(self
.syscall_exit_open
)
380 self
.clock
.time
= (time_ms
+ delay
) * 1000000
381 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
382 self
.set_int(event
.payload("_ret"), ret
)
383 self
.stream
.append_event(event
)
386 def write_lttng_statedump_file_descriptor(self
, time_ms
, cpu_id
, pid
, fd
,
387 flags
, fmode
, filename
):
388 event
= CTFWriter
.Event(self
.lttng_statedump_file_descriptor
)
389 self
.clock
.time
= time_ms
* 1000000
390 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
391 self
.set_int(event
.payload("_pid"), pid
)
392 self
.set_int(event
.payload("_fd"), fd
)
393 self
.set_int(event
.payload("_flags"), flags
)
394 self
.set_int(event
.payload("_fmode"), fmode
)
395 self
.set_string(event
.payload("_filename"), filename
)
396 self
.stream
.append_event(event
)
399 def write_lttng_statedump_process_state(self
, time_ms
, cpu_id
, tid
, vtid
,
400 pid
, vpid
, ppid
, vppid
, name
, type,
401 mode
, submode
, status
, ns_level
):
402 event
= CTFWriter
.Event(self
.lttng_statedump_process_state
)
403 self
.clock
.time
= time_ms
* 1000000
404 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
405 self
.set_int(event
.payload("_tid"), tid
)
406 self
.set_int(event
.payload("_vtid"), vtid
)
407 self
.set_int(event
.payload("_pid"), pid
)
408 self
.set_int(event
.payload("_vpid"), vpid
)
409 self
.set_int(event
.payload("_ppid"), ppid
)
410 self
.set_int(event
.payload("_vppid"), vppid
)
411 self
.set_char_array(event
.payload("_name"), name
)
412 self
.set_int(event
.payload("_type"), type)
413 self
.set_int(event
.payload("_mode"), mode
)
414 self
.set_int(event
.payload("_submode"), submode
)
415 self
.set_int(event
.payload("_status"), status
)
416 self
.set_int(event
.payload("_ns_level"), ns_level
)
417 self
.stream
.append_event(event
)
420 def write_sched_wakeup(self
, time_ms
, cpu_id
, comm
, tid
, prio
, target_cpu
):
421 event
= CTFWriter
.Event(self
.sched_wakeup
)
422 self
.clock
.time
= time_ms
* 1000000
423 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
424 self
.set_char_array(event
.payload("_comm"), comm
)
425 self
.set_int(event
.payload("_tid"), tid
)
426 self
.set_int(event
.payload("_prio"), prio
)
427 self
.set_int(event
.payload("_target_cpu"), target_cpu
)
428 self
.stream
.append_event(event
)
431 def write_sched_waking(self
, time_ms
, cpu_id
, comm
, tid
, prio
, target_cpu
):
432 event
= CTFWriter
.Event(self
.sched_waking
)
433 self
.clock
.time
= time_ms
* 1000000
434 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
435 self
.set_char_array(event
.payload("_comm"), comm
)
436 self
.set_int(event
.payload("_tid"), tid
)
437 self
.set_int(event
.payload("_prio"), prio
)
438 self
.set_int(event
.payload("_target_cpu"), target_cpu
)
439 self
.stream
.append_event(event
)
442 def write_block_rq_complete(self
, time_ms
, cpu_id
, dev
, sector
, nr_sector
,
443 errors
, rwbs
, _cmd_length
, cmd
):
444 event
= CTFWriter
.Event(self
.block_rq_complete
)
445 self
.clock
.time
= time_ms
* 1000000
446 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
447 self
.set_int(event
.payload("_dev"), dev
)
448 self
.set_int(event
.payload("_sector"), sector
)
449 self
.set_int(event
.payload("_nr_sector"), nr_sector
)
450 self
.set_int(event
.payload("_errors"), errors
)
451 self
.set_int(event
.payload("_rwbs"), rwbs
)
452 self
.set_int(event
.payload("__cmd_length"), _cmd_length
)
453 self
.set_char_array(event
.payload("_cmd"), cmd
)
454 self
.stream
.append_event(event
)
457 def write_block_rq_issue(self
, time_ms
, cpu_id
, dev
, sector
, nr_sector
,
458 bytes
, tid
, rwbs
, _cmd_length
, cmd
, comm
):
459 event
= CTFWriter
.Event(self
.block_rq_issue
)
460 self
.clock
.time
= time_ms
* 1000000
461 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
462 self
.set_int(event
.payload("_dev"), dev
)
463 self
.set_int(event
.payload("_sector"), sector
)
464 self
.set_int(event
.payload("_nr_sector"), nr_sector
)
465 self
.set_int(event
.payload("_bytes"), bytes
)
466 self
.set_int(event
.payload("_tid"), tid
)
467 self
.set_int(event
.payload("_rwbs"), rwbs
)
468 self
.set_int(event
.payload("__cmd_length"), _cmd_length
)
469 self
.set_char_array(event
.payload("_cmd"), cmd
)
470 self
.set_char_array(event
.payload("_comm"), comm
)
471 self
.stream
.append_event(event
)
474 def write_net_dev_xmit(self
, time_ms
, cpu_id
, skbaddr
, rc
, len, name
):
475 event
= CTFWriter
.Event(self
.net_dev_xmit
)
476 self
.clock
.time
= time_ms
* 1000000
477 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
478 self
.set_int(event
.payload("_skbaddr"), skbaddr
)
479 self
.set_int(event
.payload("_rc"), rc
)
480 self
.set_int(event
.payload("_len"), len)
481 self
.set_string(event
.payload("_name"), name
)
482 self
.stream
.append_event(event
)
485 def write_netif_receive_skb(self
, time_ms
, cpu_id
, skbaddr
, len, name
):
486 event
= CTFWriter
.Event(self
.netif_receive_skb
)
487 self
.clock
.time
= time_ms
* 1000000
488 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
489 self
.set_int(event
.payload("_skbaddr"), skbaddr
)
490 self
.set_int(event
.payload("_len"), len)
491 self
.set_string(event
.payload("_name"), name
)
492 self
.stream
.append_event(event
)
495 def write_sched_switch(self
, time_ms
, cpu_id
, prev_comm
, prev_tid
,
496 next_comm
, next_tid
, prev_prio
=20, prev_state
=1,
498 event
= CTFWriter
.Event(self
.sched_switch
)
499 self
.clock
.time
= time_ms
* 1000000
500 self
.set_char_array(event
.payload("_prev_comm"), prev_comm
)
501 self
.set_int(event
.payload("_prev_tid"), prev_tid
)
502 self
.set_int(event
.payload("_prev_prio"), prev_prio
)
503 self
.set_int(event
.payload("_prev_state"), prev_state
)
504 self
.set_char_array(event
.payload("_next_comm"), next_comm
)
505 self
.set_int(event
.payload("_next_tid"), next_tid
)
506 self
.set_int(event
.payload("_next_prio"), next_prio
)
507 self
.set_int(event
.payload("_cpu_id"), cpu_id
)
508 self
.stream
.append_event(event
)
511 def sched_switch_50pc(self
, start_time_ms
, end_time_ms
, cpu_id
, period
,
512 comm1
, tid1
, comm2
, tid2
):
513 current
= start_time_ms
514 while current
< end_time_ms
:
515 self
.write_sched_switch(current
, cpu_id
, comm1
, tid1
, comm2
, tid2
)
517 self
.write_sched_switch(current
, cpu_id
, comm2
, tid2
, comm1
, tid1
)
520 def compare_output(self
, cmd
, expected
):
522 result
= subprocess
.getoutput(cmd
)
523 diff
= difflib
.ndiff(expected
.split(line_sep
), result
.split(line_sep
))
527 # result doesn't match expected. Print the diff and
529 print(line_sep
.join(diff
))
535 class AnalysesTest():
536 def __init__(self
, delete_trace
=True, verbose
=False):
537 self
.verbose
= verbose
538 self
.t
= TraceTest(delete_trace
=delete_trace
)
539 self
.common_options
= '--no-progress --skip-validation'
541 self
.log('Trace in %s' % (self
.t
.trace_root
))
547 def compare_output(self
, cmd
, expected
):
548 return self
.t
.compare_output(cmd
, expected
)
553 for t
in self
.test_list
:
555 self
.log('%s: %s' % (t
[0], ret
))