def generate_composite_event(name, fields, static_fields):
ev = CTFWriter.EventClass(name)
for f in static_fields.keys():
ev.add_field(CTFWriter.StringFieldDeclaration(), f)
for f in fields:
ev.add_field(CTFWriter.IntegerFieldDeclaration(32), f)
return ev
def convert(self, from_dir, to_dir):
tc = babeltrace.TraceCollection()
tc.add_trace(from_dir, "ctf")
clock = CTFWriter.Clock("clk")
writer = CTFWriter.Writer(to_dir)
writer.add_clock(clock)
stream_class = CTFWriter.StreamClass('trace')
stream_class.clock = clock
stream_class.packet_context_type.add_field(CTFWriter.IntegerFieldDeclaration(32), "cpu_id")
for id, clslst in self.handlers.items():
for cls in clslst:
for ev in cls.get_generated_events():
stream_class.add_event_class(ev)
stream = {}
for e in tc.events:
clock.time = e.timestamp
id = e["cpu_id"]
if id not in self.threads:
self.threads[id] = ThreadState(self.handlers)
stream[id] = writer.create_stream(stream_class)
stream[id].packet_context.field("cpu_id").value = id
evl = self.threads[id].consume(e)
for ev in evl:
stream[id].append_event(ev)
for s in stream.values():
s.flush()
def create_writer(self):
self.clock = CTFWriter.Clock("A_clock")
self.clock.description = "Simple clock"
self.writer = CTFWriter.Writer(self.trace_path)
self.writer.add_clock(self.clock)
self.writer.add_environment_field("Python_version",
str(sys.version_info))
self.writer.add_environment_field("tracer_major", 2)
self.writer.add_environment_field("tracer_minor", 8)
self.writer.add_environment_field("tracer_patchlevel", 0)
def define_base_types(self):
self.char8_type = CTFWriter.IntegerFieldDeclaration(8)
self.char8_type.signed = True
self.char8_type.encoding = CTFStringEncoding.UTF8
self.char8_type.alignment = 8
self.int16_type = CTFWriter.IntegerFieldDeclaration(16)
self.int16_type.signed = True
self.int16_type.alignment = 8
self.uint16_type = CTFWriter.IntegerFieldDeclaration(16)
self.uint16_type.signed = False
self.uint16_type.alignment = 8
self.int32_type = CTFWriter.IntegerFieldDeclaration(32)
self.int32_type.signed = True
self.int32_type.alignment = 8
self.uint32_type = CTFWriter.IntegerFieldDeclaration(32)
self.uint32_type.signed = False
self.uint32_type.alignment = 8
self.int64_type = CTFWriter.IntegerFieldDeclaration(64)
self.int64_type.signed = True
self.int64_type.alignment = 8
self.uint64_type = CTFWriter.IntegerFieldDeclaration(64)
self.uint64_type.signed = False
self.uint64_type.alignment = 8
self.array16_type = CTFWriter.ArrayFieldDeclaration(
self.char8_type, 16)
self.string_type = CTFWriter.StringFieldDeclaration()
def _create_writer(self):
self.writer = CTFWriter.Writer(self.trace_path)
self.clock = CTFWriter.Clock("A_clock")
self.clock.description = "Simple clock"
self.writer.add_clock(self.clock)
self.writer.add_environment_field("domain", "ust")
self.writer.add_environment_field("tracer_name", "lttng-ust")
self.writer.add_environment_field("tracer_major", 2)
self.writer.add_environment_field("tracer_minor", 8)
def define_lttng_ust_statedump_build_id(self):
self.lttng_ust_statedump_build_id = CTFWriter.EventClass(
"lttng_ust_statedump:build_id")
self.lttng_ust_statedump_build_id.add_field(self.uint64_hex_type,
"_baddr")
self.lttng_ust_statedump_build_id.add_field(self.uint64_type,
"__build_id_length")
build_id_type = CTFWriter.SequenceFieldDeclaration(
self.uint8_type, "__build_id_length")
self.lttng_ust_statedump_build_id.add_field(build_id_type, "_build_id")
self._define_event(self.lttng_ust_statedump_build_id)
def _define_stream_class(self):
self.stream_class = CTFWriter.StreamClass("test_stream")
self.stream_class.clock = self.clock
# Add cpu_ip to existing stream packet context type
t = self.stream_class.packet_context_type
t.add_field(self.uint32_type, "cpu_id")
# Define stream event context type
t = CTFWriter.StructureFieldDeclaration()
t.add_field(self.uint64_hex_type, "_ip")
t.add_field(self.int32_type, "_vpid")
self.stream_class.event_context_type = t
def write_syscall_read(self, time_ms, cpu_id, delay, fd, buf, count, ret):
event_entry = CTFWriter.Event(self.syscall_entry_read)
self.clock.time = time_ms * 1000000
self.set_int(event_entry.payload("_cpu_id"), cpu_id)
self.set_int(event_entry.payload("_fd"), fd)
self.set_int(event_entry.payload("_count"), count)
self.stream.append_event(event_entry)
event_exit = CTFWriter.Event(self.syscall_exit_read)
self.clock.time = (time_ms + delay) * 1000000
self.set_int(event_exit.payload("_cpu_id"), cpu_id)
self.set_int(event_exit.payload("_buf"), buf)
self.set_int(event_exit.payload("_ret"), ret)
self.stream.append_event(event_exit)
self.stream.flush()
def write_softirq_exit(self, time_ms, cpu_id, vec):
event = CTFWriter.Event(self.softirq_exit)
self.clock.time = time_ms * 1000000
self.set_int(event.payload("_cpu_id"), cpu_id)
self.set_int(event.payload("_vec"), vec)
self.stream.append_event(event)
self.stream.flush()
def define_net_dev_xmit(self):
self.net_dev_xmit = CTFWriter.EventClass("net_dev_xmit")
self.net_dev_xmit.add_field(self.uint64_type, "_skbaddr")
self.net_dev_xmit.add_field(self.int32_type, "_rc")
self.net_dev_xmit.add_field(self.uint32_type, "_len")
self.net_dev_xmit.add_field(self.string_type, "_name")
self.add_event(self.net_dev_xmit)
def define_sched_waking(self):
self.sched_waking = CTFWriter.EventClass("sched_waking")
self.sched_waking.add_field(self.array16_type, "_comm")
self.sched_waking.add_field(self.int32_type, "_tid")
self.sched_waking.add_field(self.int32_type, "_prio")
self.sched_waking.add_field(self.int32_type, "_target_cpu")
self.add_event(self.sched_waking)
def __init__(self, args, handle, traces):
self.args = args
self.handle = handle
self.traces = traces
self.clock = CTFWriter.Clock('monotonic')
self.clock.description = 'Monotonic Clock'
self.clock.freq = 1000000000
self.writer = CTFWriter.Writer(self.args.output)
self.writer.add_clock(self.clock)
self.stream_class = CTFWriter.StreamClass('test_stream')
self.stream_class.clock = self.clock
self.event_classes = {}
def define_sched_wakeup(self):
self.sched_wakeup = CTFWriter.EventClass("sched_wakeup")
self.sched_wakeup.add_field(self.array16_type, "_comm")
self.sched_wakeup.add_field(self.int32_type, "_tid")
self.sched_wakeup.add_field(self.int32_type, "_prio")
self.sched_wakeup.add_field(self.int32_type, "_success")
self.sched_wakeup.add_field(self.int32_type, "_target_cpu")
self.add_event(self.sched_wakeup)
def write_irq_handler_entry(self, time_ms, cpu_id, irq, name):
event = CTFWriter.Event(self.irq_handler_entry)
self.clock.time = time_ms * 1000000
self.set_int(event.payload("_cpu_id"), cpu_id)
self.set_int(event.payload("_irq"), irq)
self.set_string(event.payload("_name"), name)
self.stream.append_event(event)
self.stream.flush()
def write_irq_handler_exit(self, time_ms, cpu_id, irq, ret):
event = CTFWriter.Event(self.irq_handler_exit)
self.clock.time = time_ms * 1000000
self.set_int(event.payload("_cpu_id"), cpu_id)
self.set_int(event.payload("_irq"), irq)
self.set_int(event.payload("_ret"), ret)
self.stream.append_event(event)
self.stream.flush()
def write_syscall_open(self, time_ms, cpu_id, delay, filename, flags, mode,
ret):
event = CTFWriter.Event(self.syscall_entry_open)
self.clock.time = time_ms * 1000000
self.set_int(event.payload("_cpu_id"), cpu_id)
self.set_string(event.payload("_filename"), filename)
self.set_int(event.payload("_flags"), flags)
self.set_int(event.payload("_mode"), mode)
self.stream.append_event(event)
self.stream.flush()
event = CTFWriter.Event(self.syscall_exit_open)
self.clock.time = (time_ms + delay) * 1000000
self.set_int(event.payload("_cpu_id"), cpu_id)
self.set_int(event.payload("_ret"), ret)
self.stream.append_event(event)
self.stream.flush()
def _define_base_types(self):
self.int8_type = CTFWriter.IntegerFieldDeclaration(8)
self.int8_type.signed = True
self.int8_type.alignment = 8
self.uint8_type = CTFWriter.IntegerFieldDeclaration(8)
self.uint8_type.signed = False
self.uint8_type.alignment = 8
self.int32_type = CTFWriter.IntegerFieldDeclaration(32)
self.int32_type.signed = True
self.int32_type.alignment = 8
self.uint32_type = CTFWriter.IntegerFieldDeclaration(32)
self.uint32_type.signed = False
self.uint32_type.alignment = 8
self.uint64_type = CTFWriter.IntegerFieldDeclaration(64)
self.uint64_type.signed = False
self.uint64_type.alignment = 8
self.uint64_hex_type = CTFWriter.IntegerFieldDeclaration(64)
self.uint64_hex_type.signed = False
self.uint64_hex_type.alignment = 8
self.uint64_hex_type.base = 16
self.string_type = CTFWriter.StringFieldDeclaration()
def create_stream_file(streamfile_dest, my_deque):
writer = CTFWriter.Writer(streamfile_dest)
clock = CTFWriter.Clock("A_clock")
clock.description = "Simple clock"
writer.add_clock(clock)
writer.add_environment_field("Python_version", str(sys.version_info))
stream_class = CTFWriter.StreamClass("test_stream")
stream_class.clock = clock
event_class = CTFWriter.EventClass("SimpleEvent")
# Create a int32_t equivalent type
int32_type = CTFWriter.IntegerFieldDeclaration(32)
int32_type.signed = True
event_class.add_field(int32_type, "value")
# Create a int32_t equivalent type for the event_id_count
int32_type = CTFWriter.IntegerFieldDeclaration(32)
int32_type.signed = True
event_class.add_field(int32_type, "event_id_count")
stream_class.add_event_class(event_class)
stream = writer.create_stream(stream_class)
for item in my_deque:
event = CTFWriter.Event(event_class)
clock.time = item["timestamp"]
integer_field = event.payload("value")
integer_field.value = item["value"]
integer_field = event.payload("event_id_count")
integer_field.value = item["event_id_counter"]
stream.append_event(event)
stream.flush()
def write_lttng_ust_statedump_debug_link(self, time_ms, cpu_id, vpid,
baddr, crc, filename):
event = CTFWriter.Event(self.lttng_ust_statedump_debug_link)
event.payload("_baddr").value = baddr
event.payload("_crc").value = crc
event.payload("_filename").value = filename
self._write_event(event, time_ms, cpu_id, vpid, 0)
def define_lttng_ust_statedump_debug_link(self):
self.lttng_ust_statedump_debug_link = CTFWriter.EventClass(
"lttng_ust_statedump:debug_link")
self.lttng_ust_statedump_debug_link.add_field(self.uint64_hex_type,
"_baddr")
self.lttng_ust_statedump_debug_link.add_field(self.uint32_type, "_crc")
self.lttng_ust_statedump_debug_link.add_field(self.string_type,
"_filename")
self._define_event(self.lttng_ust_statedump_debug_link)
def write_netif_receive_skb(self, time_ms, cpu_id, skbaddr, len, name):
event = CTFWriter.Event(self.netif_receive_skb)
self.clock.time = time_ms * 1000000
self.set_int(event.payload("_cpu_id"), cpu_id)
self.set_int(event.payload("_skbaddr"), skbaddr)
self.set_int(event.payload("_len"), len)
self.set_string(event.payload("_name"), name)
self.stream.append_event(event)
self.stream.flush()
def define_sched_switch(self):
self.sched_switch = CTFWriter.EventClass("sched_switch")
self.sched_switch.add_field(self.array16_type, "_prev_comm")
self.sched_switch.add_field(self.int32_type, "_prev_tid")
self.sched_switch.add_field(self.int32_type, "_prev_prio")
self.sched_switch.add_field(self.int64_type, "_prev_state")
self.sched_switch.add_field(self.array16_type, "_next_comm")
self.sched_switch.add_field(self.int32_type, "_next_tid")
self.sched_switch.add_field(self.int32_type, "_next_prio")
self.add_event(self.sched_switch)
def define_block_rq_complete(self):
self.block_rq_complete = CTFWriter.EventClass("block_rq_complete")
self.block_rq_complete.add_field(self.uint32_type, "_dev")
self.block_rq_complete.add_field(self.uint64_type, "_sector")
self.block_rq_complete.add_field(self.uint32_type, "_nr_sector")
self.block_rq_complete.add_field(self.int32_type, "_errors")
self.block_rq_complete.add_field(self.uint32_type, "_rwbs")
self.block_rq_complete.add_field(self.uint64_type, "__cmd_length")
self.block_rq_complete.add_field(self.array16_type, "_cmd")
self.add_event(self.block_rq_complete)
def write_sched_waking(self, time_ms, cpu_id, comm, tid, prio, target_cpu):
event = CTFWriter.Event(self.sched_waking)
self.clock.time = time_ms * 1000000
self.set_int(event.payload("_cpu_id"), cpu_id)
self.set_char_array(event.payload("_comm"), comm)
self.set_int(event.payload("_tid"), tid)
self.set_int(event.payload("_prio"), prio)
self.set_int(event.payload("_target_cpu"), target_cpu)
self.stream.append_event(event)
self.stream.flush()
def consume(self, event):
ev = None
value = event["value"]
if value not in (10, 13):
self.str += chr(value)
if value == 10:
self.str += chr(0)
ev = CTFWriter.Event(event_printf)
ev.payload("str").value = self.str
self.str = ""
return ev
def consume(self, event):
ev = None
self.values.append(event["value"])
if len(self.values) == len(self.fields):
ev = CTFWriter.Event(CompositeHandler.event)
for name, value in self.static_fields.items():
ev.payload(name).value = value
for name, value in dict(zip(self.fields, self.values)).items():
ev.payload(name).value = value
return ev
def define_lttng_statedump_file_descriptor(self):
self.lttng_statedump_file_descriptor = CTFWriter.EventClass(
"lttng_statedump_file_descriptor")
self.lttng_statedump_file_descriptor.add_field(self.int32_type, "_pid")
self.lttng_statedump_file_descriptor.add_field(self.int32_type, "_fd")
self.lttng_statedump_file_descriptor.add_field(self.uint32_type,
"_flags")
self.lttng_statedump_file_descriptor.add_field(self.uint32_type,
"_fmode")
self.lttng_statedump_file_descriptor.add_field(self.string_type,
"_filename")
self.add_event(self.lttng_statedump_file_descriptor)
def write_lttng_statedump_file_descriptor(self, time_ms, cpu_id, pid, fd,
flags, fmode, filename):
event = CTFWriter.Event(self.lttng_statedump_file_descriptor)
self.clock.time = time_ms * 1000000
self.set_int(event.payload("_cpu_id"), cpu_id)
self.set_int(event.payload("_pid"), pid)
self.set_int(event.payload("_fd"), fd)
self.set_int(event.payload("_flags"), flags)
self.set_int(event.payload("_fmode"), fmode)
self.set_string(event.payload("_filename"), filename)
self.stream.append_event(event)
self.stream.flush()
def define_block_rq_issue(self):
self.block_rq_issue = CTFWriter.EventClass("block_rq_issue")
self.block_rq_issue.add_field(self.uint32_type, "_dev")
self.block_rq_issue.add_field(self.uint64_type, "_sector")
self.block_rq_issue.add_field(self.uint32_type, "_nr_sector")
self.block_rq_issue.add_field(self.uint32_type, "_bytes")
self.block_rq_issue.add_field(self.int32_type, "_tid")
self.block_rq_issue.add_field(self.uint32_type, "_rwbs")
self.block_rq_issue.add_field(self.uint64_type, "__cmd_length")
self.block_rq_issue.add_field(self.array16_type, "_cmd")
self.block_rq_issue.add_field(self.array16_type, "_comm")
self.add_event(self.block_rq_issue)
def process_event_metadata(self, event):
if self.args.discard and event.name == self.args.name\
or not self.args.discard and event.name != self.args.name:
return
if event.name not in self.event_classes.keys():
event_class = CTFWriter.EventClass(event.name)
for field in event.fields_scope(CTFScope.EVENT_FIELDS):
self.add_field(event_class, field)
self.event_classes[event.name] = event_class
self.stream_class.add_event_class(event_class)
