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)