[apple/system_cmds.git] / kdprof / TraceFileAction.cpp

//
//  TraceFileAction.cpp
//  kdprof
//
//  Created by James McIlree on 4/15/13.
//  Copyright (c) 2013 Apple. All rights reserved.
//

#include "global.h"

#if 0
template <typename SIZE>
static void execute_arch_specific(Globals& globals, std::string path)
{
	//
	// Trace file looks roughly like:
	//
	// RAW_header
	// threadmap[thread_count]
	// wasted-space-to-align-to-next-4096-byte-boundary
	// KDEvents[]
	//

	MappedFile trace_data(path.c_str());
	if (TraceDataHeader<SIZE>* header = reinterpret_cast<TraceDataHeader<SIZE>*>(trace_data.address())) {

		KDThreadMapEntry<SIZE>* threadmap = NULL;
		uint32_t threadmap_count = 0;
		KDCPUMapEntry* cpumap = NULL;
		uint32_t cpumap_count = 0;
		KDEvent<SIZE>* events = NULL;
		
		if (header->version() != RAW_VERSION1) {
			// If the header is not a RAW_VERSION1, we must assume it is a
			// RAW_VERSION0. The difficulty here is that RAW_VERSION0 consists
			// of 4 bytes, which are the thread_count. We can't do much
			// sanity checking. The first four bytes are already read into
			// the existing header, reuse them. We must also reset the file
			// offset.

			threadmap_count = header->version();
			threadmap = reinterpret_cast<KDThreadMapEntry<SIZE>*>(trace_data.address() + 4);

			// Event data starts immediately following the threadmap
			size_t offset = 4 + threadmap_count * sizeof(KDThreadMapEntry<SIZE>);
			events = reinterpret_cast<KDEvent<SIZE>*>(trace_data.address() + offset);
		} else {
			//
			// RAW_VERSION1
			//
			threadmap_count = header->thread_count();
			threadmap = reinterpret_cast<KDThreadMapEntry<SIZE>*>(trace_data.address() + sizeof(TraceDataHeader<SIZE>));

			size_t threadmap_size_in_bytes = threadmap_count * sizeof(KDThreadMapEntry<SIZE>);
			size_t offset_to_event_data = (sizeof(TraceDataHeader<SIZE>) + threadmap_size_in_bytes + 4095) & ~4095;
			size_t offset_to_cpumap_data = sizeof(TraceDataHeader<SIZE>) + threadmap_size_in_bytes;
			size_t cpumap_bytes = offset_to_event_data - offset_to_cpumap_data;

			//
			// In a RAW_VERSION1, there *may* be a cpumap.
			// If it exists, it will be between the header and the page aligned offset
			// that event data begins at.
			//
			if (cpumap_bytes > sizeof(kd_cpumap_header) + sizeof(kd_cpumap)) {
				kd_cpumap_header* cpumap_header = reinterpret_cast<kd_cpumap_header*>(trace_data.address() + offset_to_cpumap_data);
				if (cpumap_header->version_no == RAW_VERSION1) {
					cpumap = (KDCPUMapEntry*)&cpumap_header[1];
					cpumap_count = cpumap_header->cpu_count;
				}
			}

			// Event data starts at the next PAGE alignment boundary.
			//
			// Hmm, this could be pretty awful in iOS...
			//
			// Kernel page size is 4k. Userspace page size is 16kb in 64b.
			// Kernel writes the data. Unless the kernel call fails, then userspace writes the data. Blech.
			events = reinterpret_cast<KDEvent<SIZE>*>(trace_data.address() + offset_to_event_data);
		}

		uintptr_t event_count = (uintptr_t)trace_data.size() - (reinterpret_cast<uintptr_t>(events) - reinterpret_cast<uintptr_t>(trace_data.address()));
		if (event_count % sizeof(KDEvent<SIZE>) != 0) {
			// We're probably looking at the wrong k32/k64. Throw and try the other size.
			THROW("Bytes in file does not match an even multiple of Event struct");
		}
		event_count /= sizeof(KDEvent<SIZE>);

		std::vector<KDCPUMapEntry> default_cpumap;

		if (cpumap == NULL || cpumap_count == 0) {			
			// No cpumap found, we need to fake one up using the default values.
			for (uint32_t i=0; i<globals.cpu_count(); ++i) {
				default_cpumap.emplace_back(i, 0, "AP-???");
			}
			uint32_t iop_limit = globals.cpu_count() + globals.iop_count();
			for (uint32_t i=globals.cpu_count(); i<iop_limit; ++i) {
				default_cpumap.emplace_back(i, KDBG_CPUMAP_IS_IOP, "IOP-???");
			}

			cpumap = default_cpumap.data();
			cpumap_count = (uint32_t)default_cpumap.size();
		}

		// IOP's have been producing .trace files with out of order events.
		// This is a hack fix to work around that. It costs a full copy of the data!
		MemoryBuffer<KDEvent<SIZE>> presorted_events;
		if (globals.should_presort_events() && event_count) {
			presorted_events.set_capacity(event_count);
			memcpy(presorted_events.data(), events, event_count * sizeof(KDEvent<SIZE>));
			events = presorted_events.data();
			std::sort(events, events + event_count, [](KDEvent<SIZE> const& p0, KDEvent<SIZE> const& p1) -> bool {
				return p0.timestamp() < p1.timestamp();
			});
		}

		Machine<SIZE> machine(cpumap, cpumap_count, threadmap, threadmap_count, events, event_count);

		if (!machine.lost_events()) {
			if (globals.should_zero_base_timestamps() && event_count) {
				globals.set_beginning_of_time(events[0].timestamp());
			} else {
				globals.set_beginning_of_time(AbsTime(0));
			}

			if (!globals.is_timebase_set()) {
				if (machine.is_ios()) {
					globals.set_timebase({ 125, 3 }, false);
				} else {
					globals.set_timebase({ 1, 1 }, false);
				}
			}

			if (globals.is_verbose()) {
				dprintf(globals.output_fd(), "\n%s\n", path.c_str());
				print_verbose_machine_info(globals, machine, threadmap_count, (default_cpumap.empty()) ? cpumap_count : 0);
			}

			if (globals.should_print_events()) {
				print_machine_events(globals, machine);
			}

			if (globals.should_print_summary()) {
				print_machine_summary(globals, machine);
			}

			if (globals.should_print_csv_summary()) {
				print_machine_csv_summary(globals, machine);
			}
			
			if (globals.should_print_process_start_stop_timestamps()) {
				print_process_start_stop_timestamps(globals, machine);
			}
		} else {
			log_msg(ASL_LEVEL_WARNING, "The trace data indicates that events were lost, the file cannot be processed\n");
		}
	} else {
		log_msg(ASL_LEVEL_ERR, "Unable to read from %s\n", path.c_str());
		exit(1);
	}
}

void TraceFileAction::execute(Globals& globals) {
	if (globals.is_kernel_size_set()) {
		try {
			if (globals.kernel_size() == KernelSize::k32)
				execute_arch_specific<Kernel32>(globals, _path);
			else
				execute_arch_specific<Kernel64>(globals, _path);
		} catch (Exception& e) {
			log_msg(ASL_LEVEL_ERR, "An exception was raised: %s", e.what());
			log_msg(ASL_LEVEL_ERR, "An explicit kernel size was set, you may want to try not forcing the size to a single value\n");
			log_msg(ASL_LEVEL_ERR, "You may also want to check the number of cpus and iops configured if the file is from a device and does not have a cpumap\n");
		}
	} else {
		// Try em both!
		try {
			execute_arch_specific<Kernel64>(globals, _path);
		} catch (Exception& e) {
			execute_arch_specific<Kernel32>(globals, _path);
		}
	}
}

#endif

template <typename SIZE>
static void execute_arch_specific(Globals& globals, TraceFile& file, std::string& path)
{
	Machine<SIZE> machine(file);

	if (!machine.lost_events()) {
		if (globals.should_zero_base_timestamps() && machine.event_count()) {
			globals.set_beginning_of_time(machine.events()[0].timestamp());
		} else {
			globals.set_beginning_of_time(AbsTime(0));
		}

		if (!globals.is_timebase_set()) {
			if (machine.is_ios()) {
				globals.set_timebase({ 125, 3 }, false);
			} else {
				globals.set_timebase({ 1, 1 }, false);
			}
		}

		if (globals.is_verbose()) {
			dprintf(globals.output_fd(), "\n%s\n", path.c_str());
			print_verbose_machine_info(globals, machine, file.threadmap_count(), file.cpumap_count());
		}

		if (globals.should_print_events()) {
			print_machine_events(globals, machine);
		}

		if (globals.should_print_summary()) {
			print_machine_summary(globals, machine);
		}

		if (globals.should_print_csv_summary()) {
			print_machine_csv_summary(globals, machine);
		}

		if (globals.should_print_process_start_stop_timestamps()) {
			print_process_start_stop_timestamps(globals, machine);
		}
	} else {
		log_msg(ASL_LEVEL_WARNING, "The trace data indicates that events were lost, the file cannot be processed\n");
	}
}

void TraceFileAction::execute(Globals& globals) {
        TraceFile file(_path.c_str(), globals.should_presort_events(), globals.cpu_count(), globals.iop_count());
        if (globals.is_kernel_size_set()) {
                try {
                        if (globals.kernel_size() == KernelSize::k32)
                                execute_arch_specific<Kernel32>(globals, file, _path);
                        else
                                execute_arch_specific<Kernel64>(globals, file, _path);
                } catch (Exception& e) {
                        log_msg(ASL_LEVEL_ERR, "An exception was raised: %s", e.what());
                        log_msg(ASL_LEVEL_ERR, "An explicit kernel size was set, you may want to try not forcing the size to a single value\n");
                        log_msg(ASL_LEVEL_ERR, "You may also want to check the number of cpus and iops configured if the file is from a device and does not have a cpumap\n");
                }
        } else {
                if (file.is_valid()) {
                        if (file.is_64_bit()) {
                                execute_arch_specific<Kernel64>(globals, file, _path);
                        } else {
                                execute_arch_specific<Kernel32>(globals, file, _path);
                        }
                } else {
			if (file.mmap_failed()) {
				log_msg(ASL_LEVEL_ERR, "Unable to mmap %s, it may exceed this devices memory limits\n", _path.c_str());
			} else {
				log_msg(ASL_LEVEL_ERR, "%s does not appear to be a valid trace file\n", _path.c_str());
			}
                }
        }
}
Commit	Line	Data
bd6521f0 A	1	//
	2	// TraceFileAction.cpp
	3	// kdprof
	4	//
	5	// Created by James McIlree on 4/15/13.
	6	// Copyright (c) 2013 Apple. All rights reserved.
	7	//
	8
	9	#include "global.h"
	10
	11	#if 0
	12	template <typename SIZE>
	13	static void execute_arch_specific(Globals& globals, std::string path)
	14	{
	15	//
	16	// Trace file looks roughly like:
	17	//
	18	// RAW_header
	19	// threadmap[thread_count]
	20	// wasted-space-to-align-to-next-4096-byte-boundary
	21	// KDEvents[]
	22	//
	23
	24	MappedFile trace_data(path.c_str());
	25	if (TraceDataHeader<SIZE>* header = reinterpret_cast<TraceDataHeader<SIZE>*>(trace_data.address())) {
	26
	27	KDThreadMapEntry<SIZE>* threadmap = NULL;
	28	uint32_t threadmap_count = 0;
	29	KDCPUMapEntry* cpumap = NULL;
	30	uint32_t cpumap_count = 0;
	31	KDEvent<SIZE>* events = NULL;
	32
	33	if (header->version() != RAW_VERSION1) {
	34	// If the header is not a RAW_VERSION1, we must assume it is a
	35	// RAW_VERSION0. The difficulty here is that RAW_VERSION0 consists
	36	// of 4 bytes, which are the thread_count. We can't do much
	37	// sanity checking. The first four bytes are already read into
	38	// the existing header, reuse them. We must also reset the file
	39	// offset.
	40
	41	threadmap_count = header->version();
	42	threadmap = reinterpret_cast<KDThreadMapEntry<SIZE>*>(trace_data.address() + 4);
	43
	44	// Event data starts immediately following the threadmap
	45	size_t offset = 4 + threadmap_count * sizeof(KDThreadMapEntry<SIZE>);
	46	events = reinterpret_cast<KDEvent<SIZE>*>(trace_data.address() + offset);
	47	} else {
	48	//
	49	// RAW_VERSION1
	50	//
	51	threadmap_count = header->thread_count();
	52	threadmap = reinterpret_cast<KDThreadMapEntry<SIZE>*>(trace_data.address() + sizeof(TraceDataHeader<SIZE>));
	53
	54	size_t threadmap_size_in_bytes = threadmap_count * sizeof(KDThreadMapEntry<SIZE>);
	55	size_t offset_to_event_data = (sizeof(TraceDataHeader<SIZE>) + threadmap_size_in_bytes + 4095) & ~4095;
	56	size_t offset_to_cpumap_data = sizeof(TraceDataHeader<SIZE>) + threadmap_size_in_bytes;
	57	size_t cpumap_bytes = offset_to_event_data - offset_to_cpumap_data;
	58
	59	//
	60	// In a RAW_VERSION1, there may be a cpumap.
	61	// If it exists, it will be between the header and the page aligned offset
	62	// that event data begins at.
	63	//
	64	if (cpumap_bytes > sizeof(kd_cpumap_header) + sizeof(kd_cpumap)) {
65	kd_cpumap_header* cpumap_header = reinterpret_cast<kd_cpumap_header*>(trace_data.address() + offset_to_cpumap_data);
66	if (cpumap_header->version_no == RAW_VERSION1) {
67	cpumap = (KDCPUMapEntry*)&cpumap_header[1];
68	cpumap_count = cpumap_header->cpu_count;
69	}
70	}
71
72	// Event data starts at the next PAGE alignment boundary.
73	//
74	// Hmm, this could be pretty awful in iOS...
75	//
76	// Kernel page size is 4k. Userspace page size is 16kb in 64b.
77	// Kernel writes the data. Unless the kernel call fails, then userspace writes the data. Blech.
78	events = reinterpret_cast<KDEvent<SIZE>*>(trace_data.address() + offset_to_event_data);
79	}
80
81	uintptr_t event_count = (uintptr_t)trace_data.size() - (reinterpret_cast<uintptr_t>(events) - reinterpret_cast<uintptr_t>(trace_data.address()));
82	if (event_count % sizeof(KDEvent<SIZE>) != 0) {
83	// We're probably looking at the wrong k32/k64. Throw and try the other size.
84	THROW("Bytes in file does not match an even multiple of Event struct");
85	}
86	event_count /= sizeof(KDEvent<SIZE>);
87
88	std::vector<KDCPUMapEntry> default_cpumap;
89
90	if (cpumap == NULL \|\| cpumap_count == 0) {
91	// No cpumap found, we need to fake one up using the default values.
92	for (uint32_t i=0; i<globals.cpu_count(); ++i) {
93	default_cpumap.emplace_back(i, 0, "AP-???");
94	}
95	uint32_t iop_limit = globals.cpu_count() + globals.iop_count();
96	for (uint32_t i=globals.cpu_count(); i<iop_limit; ++i) {
97	default_cpumap.emplace_back(i, KDBG_CPUMAP_IS_IOP, "IOP-???");
98	}
99
100	cpumap = default_cpumap.data();
101	cpumap_count = (uint32_t)default_cpumap.size();
102	}
103
104	// IOP's have been producing .trace files with out of order events.
105	// This is a hack fix to work around that. It costs a full copy of the data!
106	MemoryBuffer<KDEvent<SIZE>> presorted_events;
107	if (globals.should_presort_events() && event_count) {
108	presorted_events.set_capacity(event_count);
109	memcpy(presorted_events.data(), events, event_count * sizeof(KDEvent<SIZE>));
110	events = presorted_events.data();
111	std::sort(events, events + event_count, [](KDEvent<SIZE> const& p0, KDEvent<SIZE> const& p1) -> bool {
112	return p0.timestamp() < p1.timestamp();
113	});
114	}
115
116	Machine<SIZE> machine(cpumap, cpumap_count, threadmap, threadmap_count, events, event_count);
117
118	if (!machine.lost_events()) {
119	if (globals.should_zero_base_timestamps() && event_count) {
120	globals.set_beginning_of_time(events[0].timestamp());
121	} else {
122	globals.set_beginning_of_time(AbsTime(0));
123	}
124
125	if (!globals.is_timebase_set()) {
126	if (machine.is_ios()) {
127	globals.set_timebase({ 125, 3 }, false);
128	} else {
129	globals.set_timebase({ 1, 1 }, false);
130	}
131	}
132
133	if (globals.is_verbose()) {
134	dprintf(globals.output_fd(), "\n%s\n", path.c_str());
135	print_verbose_machine_info(globals, machine, threadmap_count, (default_cpumap.empty()) ? cpumap_count : 0);
136	}
137
138	if (globals.should_print_events()) {
139	print_machine_events(globals, machine);
140	}
141
142	if (globals.should_print_summary()) {
143	print_machine_summary(globals, machine);
144	}
145
146	if (globals.should_print_csv_summary()) {
147	print_machine_csv_summary(globals, machine);
148	}
149
150	if (globals.should_print_process_start_stop_timestamps()) {
151	print_process_start_stop_timestamps(globals, machine);
152	}
153	} else {
154	log_msg(ASL_LEVEL_WARNING, "The trace data indicates that events were lost, the file cannot be processed\n");
155	}
156	} else {
157	log_msg(ASL_LEVEL_ERR, "Unable to read from %s\n", path.c_str());
158	exit(1);
159	}
160	}
161
162	void TraceFileAction::execute(Globals& globals) {
163	if (globals.is_kernel_size_set()) {
164	try {
165	if (globals.kernel_size() == KernelSize::k32)
166	execute_arch_specific<Kernel32>(globals, _path);
167	else
168	execute_arch_specific<Kernel64>(globals, _path);
169	} catch (Exception& e) {
170	log_msg(ASL_LEVEL_ERR, "An exception was raised: %s", e.what());
171	log_msg(ASL_LEVEL_ERR, "An explicit kernel size was set, you may want to try not forcing the size to a single value\n");
172	log_msg(ASL_LEVEL_ERR, "You may also want to check the number of cpus and iops configured if the file is from a device and does not have a cpumap\n");
173	}
174	} else {
175	// Try em both!
176	try {
177	execute_arch_specific<Kernel64>(globals, _path);
178	} catch (Exception& e) {
179	execute_arch_specific<Kernel32>(globals, _path);
180	}
181	}
182	}
183
184	#endif
185
186	template <typename SIZE>
187	static void execute_arch_specific(Globals& globals, TraceFile& file, std::string& path)
188	{
189	Machine<SIZE> machine(file);
190
191	if (!machine.lost_events()) {
192	if (globals.should_zero_base_timestamps() && machine.event_count()) {
193	globals.set_beginning_of_time(machine.events()[0].timestamp());
194	} else {
195	globals.set_beginning_of_time(AbsTime(0));
196	}
197
198	if (!globals.is_timebase_set()) {
199	if (machine.is_ios()) {
200	globals.set_timebase({ 125, 3 }, false);
201	} else {
202	globals.set_timebase({ 1, 1 }, false);
203	}
204	}
205
206	if (globals.is_verbose()) {
207	dprintf(globals.output_fd(), "\n%s\n", path.c_str());
208	print_verbose_machine_info(globals, machine, file.threadmap_count(), file.cpumap_count());
209	}
210
211	if (globals.should_print_events()) {
212	print_machine_events(globals, machine);
213	}
214
215	if (globals.should_print_summary()) {
216	print_machine_summary(globals, machine);
217	}
218
219	if (globals.should_print_csv_summary()) {
220	print_machine_csv_summary(globals, machine);
221	}
222
223	if (globals.should_print_process_start_stop_timestamps()) {
224	print_process_start_stop_timestamps(globals, machine);
225	}
226	} else {
227	log_msg(ASL_LEVEL_WARNING, "The trace data indicates that events were lost, the file cannot be processed\n");
228	}
229	}
230
231	void TraceFileAction::execute(Globals& globals) {
232	TraceFile file(_path.c_str(), globals.should_presort_events(), globals.cpu_count(), globals.iop_count());
233	if (globals.is_kernel_size_set()) {
234	try {
235	if (globals.kernel_size() == KernelSize::k32)
236	execute_arch_specific<Kernel32>(globals, file, _path);
237	else
238	execute_arch_specific<Kernel64>(globals, file, _path);
239	} catch (Exception& e) {
240	log_msg(ASL_LEVEL_ERR, "An exception was raised: %s", e.what());
241	log_msg(ASL_LEVEL_ERR, "An explicit kernel size was set, you may want to try not forcing the size to a single value\n");
242	log_msg(ASL_LEVEL_ERR, "You may also want to check the number of cpus and iops configured if the file is from a device and does not have a cpumap\n");
243	}
244	} else {
245	if (file.is_valid()) {
246	if (file.is_64_bit()) {
247	execute_arch_specific<Kernel64>(globals, file, _path);
248	} else {
249	execute_arch_specific<Kernel32>(globals, file, _path);
250	}
251	} else {
252	if (file.mmap_failed()) {
253	log_msg(ASL_LEVEL_ERR, "Unable to mmap %s, it may exceed this devices memory limits\n", _path.c_str());
254	} else {
255	log_msg(ASL_LEVEL_ERR, "%s does not appear to be a valid trace file\n", _path.c_str());
256	}
257	}
258	}
259	}
260