+//
+// Machine.mutable-impl.hpp
+// KDBG
+//
+// Created by James McIlree on 10/30/12.
+// Copyright (c) 2014 Apple. All rights reserved.
+//
+
+#include "KDebug.h"
+
+template <typename SIZE>
+MachineProcess<SIZE>* Machine<SIZE>::create_process(pid_t pid, const char* name, AbsTime create_timestamp, kMachineProcessFlag flags) {
+ ASSERT(name, "Sanity");
+
+ // Validate that we are not creating a process that already exists
+ DEBUG_ONLY({
+ ASSERT(_processes_by_pid.size() == _processes_by_name.size(), "Sanity");
+ ASSERT(_processes_by_pid.size() == _processes_by_time.size(), "Sanity");
+
+ auto by_pid_range = _processes_by_pid.equal_range(pid);
+ for (auto it = by_pid_range.first; it != by_pid_range.second; ++it) {
+ MachineProcess<SIZE>& process = it->second;
+ ASSERT(!process.timespan().contains(create_timestamp), "Creating a process that overlaps an existing process");
+ }
+
+ auto by_name_range = _processes_by_name.equal_range(name);
+ for (auto it = by_name_range.first; it != by_name_range.second; ++it) {
+ MachineProcess<SIZE>& process = *it->second;
+ ASSERT((process.pid() != pid) || (!process.timespan().contains(create_timestamp)), "Creating a process that overlaps an existing process");
+ }
+
+ // The "by time" vector is unsorted during construction, we have to look at everything.
+ for (MachineProcess<SIZE>* process : _processes_by_time) {
+ if (process->pid() == pid) {
+ ASSERT(!process->timespan().contains(create_timestamp), "Creating a process that overlaps an existing process");
+ }
+ }
+ })
+
+ if (MachineProcess<SIZE>* about_to_be_reused_process = youngest_mutable_process(pid)) {
+ // If this process is still alive, we're going to be replacing it.
+ // The only legal way of doing that is an exec. Validate.
+ if (!about_to_be_reused_process->is_trace_terminated()) {
+ DEBUG_ONLY({
+ ASSERT((uint32_t)flags & ((uint32_t)kMachineProcessFlag::CreatedByForkExecEvent | (uint32_t)kMachineProcessFlag::CreatedByExecEvent),
+ "Replacing existing process without exec or fork-exec");
+ })
+ //
+ // Exit by exec is unique in that we will have two processes/threads
+ // back to back in the timeline. We do not want them to overlap, and
+ // the new process timeline is half open , and will have this time as
+ // its creation. Pass a 1 mabs older time to exit to prevent overlap
+ about_to_be_reused_process->set_exit_by_exec(create_timestamp - AbsTime(1));
+ }
+ ASSERT(about_to_be_reused_process->is_trace_terminated(), "Sanity");
+ }
+
+ MachineProcess<SIZE>* process = &_processes_by_pid.emplace(pid, MachineProcess<SIZE>(pid, name, create_timestamp, flags))->second;
+ _processes_by_name.emplace(process->name(), process);
+ _processes_by_time.push_back(process);
+
+ return process;
+}
+
+template <typename SIZE>
+MachineThread<SIZE>* Machine<SIZE>::create_thread(MachineProcess<SIZE>* process, typename SIZE::ptr_t tid, MachineVoucher<SIZE>* voucher, AbsTime create_timestamp, kMachineThreadFlag flags) {
+ ASSERT(process, "Sanity");
+
+ // Validate that we are not creating a thread that already exists
+ DEBUG_ONLY({
+ ASSERT(_threads_by_tid.size() == _threads_by_time.size(), "Sanity");
+
+ auto by_tid_range = _threads_by_tid.equal_range(tid);
+ for (auto it = by_tid_range.first; it != by_tid_range.second; ++it) {
+ MachineThread<SIZE>& thread = it->second;
+ ASSERT(!thread.timespan().contains(create_timestamp), "Creating a thread that overlaps an existing thread");
+ }
+
+ // The "by time" vector is unsorted during construction, we have to look at everything
+ for (MachineThread<SIZE>* thread : _threads_by_time) {
+ if (thread->tid() == tid) {
+ ASSERT(!thread->timespan().contains(create_timestamp), "Creating a thread that overlaps an existing thread");
+ }
+ }
+ })
+
+ // Currently the only way we intentionally re-use live threads is via exec/fork-exec.
+ // The exec/fork-exec code calls create_process first, which should mark all existing
+ // threads as trace-terminated. So we should NEVER see a live thread at this point.
+ // validate.
+ DEBUG_ONLY({
+ if (MachineThread<SIZE>* about_to_be_reused_thread = youngest_mutable_thread(tid)) {
+ ASSERT(about_to_be_reused_thread->is_trace_terminated(), "Expected this thread to be terminated");
+ }
+ });
+
+ MachineThread<SIZE>* thread = &_threads_by_tid.emplace(tid, MachineThread<SIZE>(process, tid, voucher, create_timestamp, flags))->second;
+ _threads_by_time.push_back(thread);
+
+ return thread;
+}
+
+template <typename SIZE>
+MachineVoucher<SIZE>* Machine<SIZE>::create_voucher(typename SIZE::ptr_t address, AbsTime create_timestamp, kMachineVoucherFlag flags, uint32_t content_bytes_capacity) {
+ ASSERT(address, "Should not be NULL");
+ ASSERT(content_bytes_capacity < 4096, "Probably an error"); // This is a guesstimate, may need re-evaluation
+
+ MachineVoucher<SIZE>* voucher;
+
+ ASSERT(_voucher_nursery.find(address) == _voucher_nursery.end(), "Attempt to create an already live voucher (<rdar://problem/16898190>)");
+ //
+ // There is no real workaround for this. Other tracepoints will use the address, bad things happen. You can't fix ordering bugs with cleverness outside the lock :-).
+ //
+ // <rdar://problem/16898190> voucher create / destroy tracepoints are outside the hashtable lock
+
+ auto workaround_it = _voucher_nursery.find(address);
+ if (workaround_it != _voucher_nursery.end()) {
+ // We've hit a race condition, this voucher was used before the create event was posted.
+ // We want to update the content_bytes_capacity, but not the create_timestamp.
+ voucher = workaround_it->second.get();
+ voucher->workaround_16898190(flags, content_bytes_capacity);
+ } else {
+ auto it = _voucher_nursery.emplace(address, std::make_unique<MachineVoucher<SIZE>>(address, AbsInterval(create_timestamp, AbsTime(0)), flags, content_bytes_capacity));
+ ASSERT(it.second, "Voucher emplace in nursery failed");
+ voucher = it.first->second.get();
+ }
+
+ ASSERT(voucher->is_live(), "Sanity");
+ ASSERT(!voucher->is_null(), "Sanity");
+ ASSERT(!voucher->is_unset(), "Sanity");
+
+ return voucher;
+}
+
+template <typename SIZE>
+void Machine<SIZE>::destroy_voucher(typename SIZE::ptr_t address, AbsTime timestamp) {
+ ASSERT(address, "Should not be NULL");
+
+ auto nursery_it = _voucher_nursery.find(address);
+
+ // We need a voucher for every reference, so we are in the odd position
+ // of creating a voucher so we can destroy it.
+ if (nursery_it == _voucher_nursery.end()) {
+ create_voucher(address, AbsTime(0), kMachineVoucherFlag::CreatedByFirstUse, 0);
+ nursery_it = _voucher_nursery.find(address);
+ }
+
+ MachineVoucher<SIZE>* voucher = nursery_it->second.get();
+
+ voucher->set_destroyed(timestamp);
+
+ // First find the "row" for this address.
+ auto by_addr_it = _vouchers_by_addr.find(address);
+ if (by_addr_it == _vouchers_by_addr.end()) {
+ // No address entry case
+ //std::vector<std::unique_ptr<MachineVoucher<SIZE>>> row(std::move(nursery_it->second));
+ std::vector<std::unique_ptr<MachineVoucher<SIZE>>> row;
+ row.emplace_back(std::move(nursery_it->second));
+ _vouchers_by_addr.emplace(address, std::move(row));
+ } else {
+ auto& row = by_addr_it->second;
+
+ // Make sure these are sorted and non-overlapping
+ ASSERT(row.back()->timespan() < voucher->timespan(), "Sanity");
+ ASSERT(!row.back()->timespan().intersects(voucher->timespan()), "Sanity");
+
+ row.emplace_back(std::move(nursery_it->second));
+ }
+
+ _voucher_nursery.erase(nursery_it);
+}
+
+//
+// This function handles looking up a voucher by address. If neccessary, it will create a new voucher.
+// NOTE! Does not update voucher timestamps, that is only done at voucher destroy.
+//
+
+template <typename SIZE>
+MachineVoucher<SIZE>* Machine<SIZE>::process_event_voucher_lookup(typename SIZE::ptr_t address, uint32_t msgh_bits) {
+ // NOTE! There is a subtle race here, we *MUST* test msgh_bits before
+ // checking for a 0 address. An unset voucher may have address 0...
+ if (MACH_MSGH_BITS_VOUCHER(msgh_bits) == MACH_MSGH_BITS_ZERO)
+ return &UnsetVoucher;
+
+ if (address == 0)
+ return &NullVoucher;
+
+ auto nursery_it = _voucher_nursery.find(address);
+ if (nursery_it == _voucher_nursery.end()) {
+ // If no voucher exists, create a default (no-contents!) voucher.
+ return create_voucher(address, AbsTime(0), kMachineVoucherFlag::CreatedByFirstUse, 0);
+ }
+
+ return nursery_it->second.get();
+}
+
+template <typename SIZE>
+MachineVoucher<SIZE>* Machine<SIZE>::thread_forwarding_voucher_lookup(const MachineVoucher<SIZE>* previous_machine_state_voucher) {
+ ASSERT(previous_machine_state_voucher, "Sanity");
+
+ if (previous_machine_state_voucher == &UnsetVoucher)
+ return &UnsetVoucher;
+
+ if (previous_machine_state_voucher == &NullVoucher)
+ return &NullVoucher;
+
+ auto nursery_it = _voucher_nursery.find(previous_machine_state_voucher->address());
+ if (nursery_it == _voucher_nursery.end()) {
+ ASSERT(false, "Should not ever have a thread forwarding a voucher not in the nursery");
+ return &UnsetVoucher;
+ }
+
+ return nursery_it->second.get();
+}
+
+//
+// This is used by processes that are being fork-exec'd / exec'd. They must be
+// created with some name, but it isn't their final name. For now, we are
+// heavily ASSERTING state to only allow processes which are fork-exec'd /
+// exec'd to set their name.
+//
+template <typename SIZE>
+void Machine<SIZE>::set_process_name(MachineProcess<SIZE>* process, const char* name) {
+ ASSERT(process, "Sanity");
+ ASSERT(process->is_created_by_fork_exec() || process->is_created_by_exec(), "Sanity");
+ ASSERT(process->threads().size() == 1, "Sanity");
+ ASSERT(process->is_fork_exec_in_progress() || process->is_exec_in_progress(), "Sanity");
+ ASSERT(name, "Sanity");
+
+ auto by_name_range = _processes_by_name.equal_range(process->name());
+ for (auto it = by_name_range.first; it != by_name_range.second; ++it) {
+ if (process == it->second) {
+ _processes_by_name.erase(it);
+ process->set_name(name);
+ _processes_by_name.emplace(process->name(), process);
+ return;
+ }
+ }
+
+ ASSERT(false, "Attempt to rename did not find a matching process");
+}
+
+//
+// The "youngest" process/thread lookups are used during event processing,
+// where we often must look up a process/thread that hasn't been updated
+// to reflect current timespans. A time based lookup would fail.
+//
+template <typename SIZE>
+MachineProcess<SIZE>* Machine<SIZE>::youngest_mutable_process(pid_t pid) {
+ MachineProcess<SIZE>* youngest_process = nullptr;
+ auto by_pid_range = _processes_by_pid.equal_range(pid);
+ for (auto it = by_pid_range.first; it != by_pid_range.second; ++it) {
+ MachineProcess<SIZE>& process = it->second;
+ // Larger times are newer (younger)
+ if (!youngest_process || process.timespan().location() > youngest_process->timespan().location()) {
+ youngest_process = &process;
+ }
+ }
+
+ return youngest_process;
+}
+
+template <typename SIZE>
+MachineThread<SIZE>* Machine<SIZE>::youngest_mutable_thread(typename SIZE::ptr_t tid) {
+ MachineThread<SIZE>* youngest_thread = nullptr;
+ auto by_tid_range = _threads_by_tid.equal_range(tid);
+ for (auto it = by_tid_range.first; it != by_tid_range.second; ++it) {
+ MachineThread<SIZE>& thread = it->second;
+ // Larger times are newer (younger)
+ if (!youngest_thread || thread.timespan().location() > youngest_thread->timespan().location()) {
+ youngest_thread = &thread;
+ }
+ }
+
+ return youngest_thread;
+}
+
+//
+// This function handles looking up a thread by tid. If neccessary, it will create a new thread
+// and process. Any thread / process that are looked up or created will have their timestamps updated.
+//
+template <typename SIZE>
+MachineThread<SIZE>* Machine<SIZE>::process_event_tid_lookup(typename SIZE::ptr_t tid, AbsTime now) {
+ MachineThread<SIZE>* thread = youngest_mutable_thread(tid);
+
+ if (!thread) {
+ // This is an "unknown" thread. We have no information about its name or parent process.
+ char unknown_process_name[20];
+ snprintf(unknown_process_name, sizeof(unknown_process_name), "unknown-%llX", (uint64_t)tid);
+
+ //
+ // Strongly considering just requiring this to be valid, and never allowing an unknown thread.
+ //
+ printf("UNKNOWN TID FAIL! unknonwn tid %llx\n", (int64_t)tid);
+ ASSERT(false, "unknown TID fail");
+
+ MachineProcess<SIZE>* unknown_process = create_process(next_unknown_pid(), unknown_process_name, now, kMachineProcessFlag::IsUnknownProcess);
+ thread = create_thread(unknown_process, tid, &UnsetVoucher, now, kMachineThreadFlag::CreatedByUnknownTidInTrace);
+ unknown_process->add_thread(thread);
+ }
+
+ ASSERT(thread, "Sanity");
+ ASSERT(!thread->is_trace_terminated(), "Event tid seen after trace termination");
+ ASSERT(!thread->process().is_trace_terminated(), "Event pid seen after trace termination");
+
+ return thread;
+}
+
+//
+// See comments in task_policy.c for full explanation of trequested_0 & trequested_1.
+//
+// process_trequested_task means that the tracepoint either had a NULL thread, or specified that the tracepoint was targeted at task level.
+// This only matters in 32 bit traces, where it takes both trequested_0 and trequested_1 to carry task or thread requested data.
+//
+// For now, there is nothing we want to see in thread_requested data.
+//
+template <typename SIZE>
+void Machine<SIZE>::process_trequested_task(pid_t pid, typename SIZE::ptr_t trequested_0, typename SIZE::ptr_t trequested_1) {
+ TaskRequestedPolicy task_requested = (SIZE::is_64_bit) ? TaskRequestedPolicy(trequested_0) : TaskRequestedPolicy((Kernel32::ptr_t)trequested_0, (Kernel32::ptr_t)trequested_1);
+
+ if (uint32_t apptype = (uint32_t)task_requested.as_struct().t_apptype) {
+ if (pid) {
+ if (MachineProcess<SIZE>* target = youngest_mutable_process(pid)) {
+ target->set_apptype_from_trequested(apptype);
+ }
+ }
+ }
+}
+
+template <typename SIZE>
+void Machine<SIZE>::process_trequested_thread(typename SIZE::ptr_t tid, typename SIZE::ptr_t trequested_0, typename SIZE::ptr_t trequested_1) {
+ TaskRequestedPolicy task_requested = (SIZE::is_64_bit) ? TaskRequestedPolicy(trequested_0) : TaskRequestedPolicy((Kernel32::ptr_t)trequested_0, (Kernel32::ptr_t)trequested_1);
+
+ if (uint32_t apptype = (uint32_t)task_requested.as_struct().t_apptype) {
+ if (MachineThread<SIZE>* target_thread = youngest_mutable_thread(tid)) {
+ target_thread->mutable_process().set_apptype_from_trequested(apptype);
+ }
+ }
+}
+
+#define AST_PREEMPT 0x01
+#define AST_QUANTUM 0x02
+#define AST_URGENT 0x04
+#define AST_HANDOFF 0x08
+#define AST_YIELD 0x10
+
+#define TRACE_DATA_NEWTHREAD 0x07000004
+#define TRACE_STRING_NEWTHREAD 0x07010004
+#define TRACE_DATA_EXEC 0x07000008
+#define TRACE_STRING_EXEC 0x07010008
+#define TRACE_LOST_EVENTS 0x07020008
+
+// From ./osfmk/i386/mp.c
+#define TRACE_MP_CPU_DEACTIVATE MACHDBG_CODE(DBG_MACH_MP, 7)
+
+// From osfmk/kern/task.h
+#define TASK_POLICY_TASK 0x4
+#define TASK_POLICY_THREAD 0x8
+
+template <typename SIZE>
+bool Machine<SIZE>::process_event(const KDEvent<SIZE>& event)
+{
+ ASSERT(!lost_events(), "Should not be processing events after TRACE_LOST_EVENTS");
+
+ AbsTime now = event.timestamp();
+ ASSERT(event.cpu() > -1 && event.cpu() < _cpus.size(), "cpu_id out of range");
+ MachineCPU<SIZE>& cpu = _cpus[event.cpu()];
+
+ if (!cpu.is_iop()) {
+ //
+ // If we have lost events, immediately bail.
+ //
+ // Pre-process events known to have bogus TID's:
+ //
+ // DBG_TRACE_INFO events may not have a valid TID.
+ // MACH_IPC_VOUCHER_CREATE_ATTR_DATA do not have a valid TID,
+ //
+
+ switch (event.dbg_cooked()) {
+ case TRACEDBG_CODE(DBG_TRACE_INFO, 1): // kernel_debug_early_end()
+ case TRACEDBG_CODE(DBG_TRACE_INFO, 4): // kernel_debug_string()
+ return true;
+
+ case TRACEDBG_CODE(DBG_TRACE_INFO, 2): // TRACE_LOST_EVENTS
+ set_flags(kMachineFlag::LostEvents);
+ return false;
+
+ case MACHDBG_CODE(DBG_MACH_IPC, MACH_IPC_VOUCHER_CREATE_ATTR_DATA):
+ // trace event data is
+ // data, data, data, data
+ //
+ // event tid is voucher address!
+ if (auto voucher = process_event_voucher_lookup(event.tid(), UINT32_MAX)) {
+ voucher->add_content_bytes(event.arg1_as_pointer());
+ }
+ return true;
+
+ default:
+ break;
+ }
+
+ MachineThread<SIZE>* event_thread = process_event_tid_lookup(event.tid(), now);
+
+ switch (event.dbg_cooked()) {
+ case BSDDBG_CODE(DBG_BSD_PROC, BSD_PROC_EXIT): // the exit syscall never returns, use this instead
+ // arg1 == pid exiting
+ // arg2 == exit code
+ if (event.is_func_end()) {
+ // can BSD_PROC_EXIT can be called from another context?
+ ASSERT((pid_t)event.arg1() == event_thread->process().pid(), "proc_exit pid does not match context pid");
+ event_thread->mutable_process().set_exit_by_syscall(now, (int32_t)event.arg2());
+ }
+ break;
+
+ case TRACE_DATA_NEWTHREAD: {
+ ASSERT(event.is_func_none(), "TRACE_DATA_NEWTHREAD event has start/end bit set. Should be func_none.");
+ //
+ // This is called by the thread creating the new thread.
+ //
+ // The thread id of the new thread is in arg1.
+ // The pid of the process creating the new thread is in arg2.
+ //
+ // NOTE! This event carries enough information to create a thread, which we do.
+ // However, the immediately following TRACE_STRING_NEWTHREAD does not have the
+ // newly_created thread's tid. We cannot assume that we will always be able to
+ // read these events as a pair, they may be split by a particularly unlucky
+ // buffer snapshot.
+ //
+ // We have a "thread nursery" which we use to associate the tid of the new
+ // thread with the creating thread.
+ //
+ // (During fork operations, the "parent" may appear different than the child,
+ // this is why we cannot reuse the parent's name and ignore the STRING event.)
+ //
+ auto new_thread_id = (typename SIZE::ptr_t)event.arg1();
+ auto new_thread_pid = (int32_t)event.arg2();
+
+ MachineProcess<SIZE>* new_process = youngest_mutable_process(new_thread_pid);
+ kMachineThreadFlag new_thread_flags;
+
+ //
+ // Okay, it looks like we cannot pay much attention to the source of thread
+ // creates, the system will create a thread for anyone at any time, in any
+ // place. The new model is to lookup the pid of the new thread, and if it
+ // exists and is live, use that. Otherwise, fork-exec a new process.
+ //
+
+ if (new_process) {
+ new_thread_flags = kMachineThreadFlag::CreatedByTraceDataNewThread;
+ } else {
+ new_thread_flags = (kMachineThreadFlag)((uint32_t)kMachineThreadFlag::CreatedByForkExecEvent |
+ (uint32_t)kMachineThreadFlag::IsMain);
+
+ auto new_process_flags = (kMachineProcessFlag)((uint32_t)kMachineProcessFlag::CreatedByForkExecEvent |
+ (uint32_t)kMachineProcessFlag::IsForkExecInProgress);
+
+ // Create the new process
+ new_process = create_process(new_thread_pid, "###Fork#Exec###", now, new_process_flags);
+ }
+ ASSERT(new_process, "Sanity");
+ ASSERT(!new_process->is_trace_terminated(), "Sanity");
+ ASSERT(new_thread_pid != 0 || new_process == _kernel_task, "Sanity");
+ new_process->add_thread(create_thread(new_process, new_thread_id, &UnsetVoucher, now, new_thread_flags));
+ break;
+ }
+
+ case TRACEDBG_CODE(DBG_TRACE_DATA, TRACE_DATA_THREAD_TERMINATE): {
+ ASSERT(event.is_func_none(), "Sanity");
+ typename SIZE::ptr_t terminated_tid = event.arg1();
+ // If tid == terminated_tid, we need to handle the lookup below differently
+ ASSERT(event.tid() != terminated_tid, "Should not be possible");
+ MachineThread<SIZE>* terminated_thread = process_event_tid_lookup(terminated_tid, now);
+ terminated_thread->set_trace_terminated(now);
+
+ // Was this the last thread for a given process?
+ bool all_threads_trace_terminated = true;
+ MachineProcess<SIZE>& process = terminated_thread->mutable_process();
+ for (auto thread : process.threads()) {
+ if (!thread->is_trace_terminated()) {
+ all_threads_trace_terminated = false;
+ break;
+ }
+ }
+
+ if (all_threads_trace_terminated) {
+ process.set_trace_terminated(now);
+ }
+ break;
+ }
+
+ case TRACE_DATA_EXEC: {
+ ASSERT(event.is_func_none(), "TRACE_DATA_EXEC event has start/end bit set. Should be func_none.");
+
+ ASSERT(!event_thread->is_trace_terminated(), "Thread that is trace terminated is exec'ing");
+ ASSERT(!event_thread->process().is_kernel(), "Kernel process is exec'ing");
+ ASSERT(!event_thread->is_idle_thread(), "IDLE thread is exec'ing");
+
+ // arg1 == pid
+ int32_t exec_pid = (int32_t)event.arg1();
+ ASSERT(exec_pid != -1, "Kernel thread is exec'ing");
+ ASSERT(exec_pid == event_thread->process().pid() || event_thread->process().is_unknown(), "Pids should match. If not, maybe vfork?");
+
+ if (event_thread->process().is_fork_exec_in_progress()) {
+ ASSERT(event_thread->process().threads().size() == 1, "Fork invariant violated");
+ // event_thread->mutable_process().clear_fork_exec_in_progress();
+
+ // Hmmm.. Do we need to propagate an apptype here?
+ } else {
+ //
+ // Creating a new process will automagically clean up the
+ // existing one, setting the last known timestamp, and "PidReused"
+ //
+ auto exec_thread_flags = (kMachineThreadFlag)((uint32_t)kMachineThreadFlag::CreatedByExecEvent |
+ (uint32_t)kMachineThreadFlag::IsMain);
+
+ auto exec_process_flags = (kMachineProcessFlag)((uint32_t)kMachineProcessFlag::CreatedByExecEvent |
+ (uint32_t)kMachineProcessFlag::IsExecInProgress);
+
+ auto exec_process = create_process(exec_pid, "###Exec###", now, exec_process_flags);
+ MachineThread<SIZE>* exec_thread = create_thread(exec_process, event_thread->tid(), &UnsetVoucher, now, exec_thread_flags);
+ exec_process->add_thread(exec_thread);
+
+ int32_t apptype = event_thread->process().apptype();
+ if (apptype != -1) {
+ exec_process->set_apptype(apptype);
+ }
+ }
+ break;
+ }
+
+ case TRACE_STRING_EXEC: {
+ ASSERT(event.is_func_none(), "TRACE_STRING_EXEC event has start/end bit set. Should be func_none.");
+ ASSERT(event_thread->mutable_process().is_exec_in_progress() ||
+ event_thread->mutable_process().is_fork_exec_in_progress(), "Must be exec or fork-exec in progress to be here");
+
+ set_process_name(&event_thread->mutable_process(), event.all_args_as_string().c_str());
+
+ if (event_thread->process().is_exec_in_progress())
+ event_thread->mutable_process().clear_exec_in_progress();
+ else
+ event_thread->mutable_process().clear_fork_exec_in_progress();
+ break;
+ }
+
+ case MACHDBG_CODE(DBG_MACH_EXCP_INTR, 0):
+ if (event.is_func_start()) {
+ cpu.set_intr(now);
+ } else {
+ cpu.clear_intr(now);
+ }
+ break;
+
+ case MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED):
+ case MACHDBG_CODE(DBG_MACH_SCHED, MACH_STACK_HANDOFF): {
+ // The is deactivate switch to idle thread should have happened before we see an actual
+ // context switch for this cpu.
+ ASSERT(!cpu.is_deactivate_switch_to_idle_thread(), "State machine fail");
+
+ typename SIZE::ptr_t handoff_tid = event.arg2();
+ // If the handoff tid and the event_tid are the same, the lookup will fail an assert due to timestamps going backwards.
+ MachineThread<SIZE>* handoff_thread = (handoff_tid == event.tid()) ? event_thread : process_event_tid_lookup(handoff_tid, now);
+ ASSERT(handoff_thread, "Sanity");
+
+ // If we marked a given thread as unrunnable in idle, or the MKRUNNABLE wasn't emitted, make sure we
+ // mark the thread as runnable now.
+ handoff_thread->make_runnable(now);
+ cpu.context_switch(handoff_thread, event_thread, now);
+
+ if (!event_thread->is_idle_thread()) {
+ if (event_thread->tid() != event.arg2()) {
+ if ((event.arg1() & (AST_PREEMPT | AST_QUANTUM | AST_URGENT | AST_HANDOFF | AST_YIELD)) == 0) {
+ event_thread->make_unrunnable(now);
+ }
+ }
+ }
+ break;
+ }
+
+ //
+ // There is a rare case of:
+ //
+ // event[795176] { timestamp=4b8074fa6bb5, arg1=0, arg2=0, arg3=0, arg4=0, tid=8ab77, end MP_CPU_DEACTIVATE, cpu=1 }
+ // event[795177] { timestamp=4b8074fa70bd, arg1=8ab77, arg2=ffffffffffffffff, arg3=0, arg4=4, tid=2d, --- MACH_SCHED_CHOOSE_PROCESSOR, cpu=1 }
+ //
+ // When a cpu shuts down via MP_CPU_DEACTIVATE, on reactivation, the cpu does a forced switch to its idle thread,
+ // without dropping a MACH_SCHED or MACH_STACK_HANDOFF. We want to catch this and update the cpu correctly, as
+ // well as marking the idle thread.
+ //
+ // This is a desktop only codepath, TRACE_MP_CPU_DEACTIVATE is defined in ./osfmk/i386/mp.c
+ //
+ case TRACE_MP_CPU_DEACTIVATE:
+ ASSERT(event_thread == cpu.thread() || !cpu.is_thread_state_initialized(), "Sanity");
+ if (event.is_func_end()) {
+ cpu.set_deactivate_switch_to_idle_thread();
+ }
+ break;
+
+ case MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_CHOOSE_PROCESSOR):
+ //
+ // I have seen a sequence of events like this, where it appears that multiple threads get re-dispatched:
+ //
+ // event[254871] { timestamp=332dd22319b, arg1=0, arg2=0, arg3=0, arg4=0, tid=1b8ab, end MP_CPU_DEACTIVATE, cpu=7 }
+ // event[254876] { timestamp=332dd22387a, arg1=1b7d9, arg2=ffffffffffffffff, arg3=e, arg4=4, tid=1b8ab, --- MACH_SCHED_CHOOSE_PROCESSOR, cpu=7 }
+ // event[254877] { timestamp=332dd223c44, arg1=e, arg2=0, arg3=0, arg4=0, tid=1b8ab, --- MACH_SCHED_REMOTE_AST, cpu=7 }
+ // event[254887] { timestamp=332dd22441c, arg1=1b8ab, arg2=ffffffffffffffff, arg3=4, arg4=4, tid=53, --- MACH_SCHED_CHOOSE_PROCESSOR, cpu=7 }
+ //
+ // We will wait until we see a tid mismatch before clearing the deactivate_switch state
+ //
+ if (cpu.is_deactivate_switch_to_idle_thread()) {
+ if (cpu.thread() == NULL || event_thread->tid() != cpu.thread()->tid()) {
+ // The choose tracepoint has the tid of the thread on cpu when it deactivated.
+ ASSERT(cpu.thread() == NULL || cpu.thread()->tid() == event.arg1(), "Sanity");
+
+ cpu.clear_deactivate_switch_to_idle_thread();
+ event_thread->set_is_idle_thread();
+ event_thread->make_runnable(now);
+ cpu.context_switch(event_thread, cpu.thread(), now);
+ }
+ }
+ break;
+
+ case MACHDBG_CODE(DBG_MACH_SCHED, MACH_MAKE_RUNNABLE):
+ event_thread->make_runnable(now);
+ break;
+
+ case MACHDBG_CODE(DBG_MACH_SCHED, MACH_IDLE):
+ if (event.is_func_start()) {
+ cpu.set_idle(now);
+ } else {
+ cpu.clear_idle(now);
+ }
+ break;
+
+ case MACHDBG_CODE(DBG_MACH_VM, 2 /* MACH_vmfault is hardcoded as 2 */):
+ if (event.is_func_start())
+ event_thread->begin_vm_fault(now);
+ else
+ event_thread->end_vm_fault(now);
+ break;
+
+ case BSDDBG_CODE(DBG_BSD_MEMSTAT, BSD_MEMSTAT_JETSAM):
+ case BSDDBG_CODE(DBG_BSD_MEMSTAT, BSD_MEMSTAT_JETSAM_HIWAT):
+ if (event.is_func_end()) {
+ if (pid_t pid = (pid_t)event.arg2()) {
+ //
+ // The time for this kill is already covered by the MEMSTAT_scan.
+ // We still want to mark the victim process as jetsam killed, though.
+ // We need to look up the victim, which is the pid in arg2.
+ //
+ if (MachineProcess<SIZE>* victim = youngest_mutable_process(pid)) {
+ ASSERT(!victim->is_exiting(), "Jetsam killing already dead process");
+ // This isn't technically impossible, but as a practical matter it is more likely
+ // signalling a bug than we were able to wrap the pid counter and reuse this pid
+ ASSERT(!victim->is_kernel(), "Cannot jetsam kernel");
+ victim->set_exit_by_jetsam(now);
+ } else {
+ ASSERT(false, "Unable to find jetsam victim pid");
+ }
+ }
+ }
+ break;
+
+ case BSDDBG_CODE(DBG_BSD_MEMSTAT, BSD_MEMSTAT_SCAN):
+ case BSDDBG_CODE(DBG_BSD_MEMSTAT, BSD_MEMSTAT_UPDATE):
+ case BSDDBG_CODE(DBG_BSD_MEMSTAT, BSD_MEMSTAT_FREEZE):
+ if (event.is_func_start())
+ event_thread->begin_jetsam_activity(event.dbg_cooked(), now);
+ else
+ event_thread->end_jetsam_activity(event.dbg_cooked(), now);
+ break;
+
+ //
+ // IMP_TASK_APPTYPE trace args are:
+ //
+ // start:
+ // target_pid, trequested_0, trequested_1, apptype
+ // end:
+ // target_pid, trequested_0, trequested_1, is_importance_receiver
+ case IMPORTANCE_CODE(IMP_TASK_APPTYPE, TASK_APPTYPE_NONE):
+ case IMPORTANCE_CODE(IMP_TASK_APPTYPE, TASK_APPTYPE_DAEMON_INTERACTIVE):
+ case IMPORTANCE_CODE(IMP_TASK_APPTYPE, TASK_APPTYPE_DAEMON_STANDARD):
+ case IMPORTANCE_CODE(IMP_TASK_APPTYPE, TASK_APPTYPE_DAEMON_ADAPTIVE):
+ case IMPORTANCE_CODE(IMP_TASK_APPTYPE, TASK_APPTYPE_DAEMON_BACKGROUND):
+ case IMPORTANCE_CODE(IMP_TASK_APPTYPE, TASK_APPTYPE_APP_DEFAULT):
+ case IMPORTANCE_CODE(IMP_TASK_APPTYPE, TASK_APPTYPE_APP_TAL):
+ //
+ // We want to set the explicit apptype now, and trequested will not have the
+ // apptype data until the end event.
+ //
+ if (event.is_func_start()) {
+ if (pid_t pid = (pid_t)event.arg1()) {
+ if (MachineProcess<SIZE>* target = youngest_mutable_process(pid)) {
+ target->set_apptype((uint32_t)event.arg4());
+ }
+ }
+ }
+ process_trequested_task((pid_t)event.arg1(), event.arg2(), event.arg3());
+ break;
+
+ // Trace data is
+ // self_pid, audit_token_pid_from_task(task), trequested_0(task, NULL), trequested_1(task, NULL)
+ case IMPORTANCE_CODE(IMP_TASK_SUPPRESSION, 0):
+ case IMPORTANCE_CODE(IMP_TASK_SUPPRESSION, 1):
+ case IMPORTANCE_CODE(IMP_BOOST, IMP_BOOSTED):
+ case IMPORTANCE_CODE(IMP_BOOST, IMP_UNBOOSTED):
+ process_trequested_task((pid_t)event.arg2(), event.arg3(), event.arg4());
+ break;
+
+ case MACHDBG_CODE(DBG_MACH_IPC, MACH_THREAD_SET_VOUCHER): {
+ //
+ // This can be invoked against another thread; you must use arg1 as the tid.
+ //
+ // thread-tid, name, voucher, callsite-id
+ //
+ auto set_thread_tid = event.arg1();
+ MachineThread<SIZE>* set_thread = (set_thread_tid == event.tid()) ? event_thread : process_event_tid_lookup(set_thread_tid, now);
+ set_thread->set_voucher(process_event_voucher_lookup(event.arg3(), UINT32_MAX), now);
+ break;
+ }
+
+ case MACHDBG_CODE(DBG_MACH_IPC, MACH_IPC_VOUCHER_CREATE):
+ // trace event data is
+ // voucher address, voucher table size, system voucher count, voucher content bytes
+ create_voucher(event.arg1(), now, kMachineVoucherFlag::CreatedByVoucherCreate, (uint32_t)event.arg4());
+ break;
+
+ case MACHDBG_CODE(DBG_MACH_IPC, MACH_IPC_VOUCHER_DESTROY):
+ destroy_voucher(event.arg1(), now);
+ break;
+
+ // The MachMsg state chart...
+ //
+ // The "key" to the mach msg is the kmsg_addr.
+ //
+ // We can encounter a given kmsg_addr in any of
+ // four possible states:
+ //
+ // UNINITIALIZED
+ // SEND
+ // RECV
+ // FREE
+ //
+ // These are the legal state transitions:
+ // (transition to UNINITIALIZED is not possible)
+ //
+ // UNIN -> SEND ; Accept as FREE -> SEND
+ // UNIN -> RECV ; Accept as SEND -> RECV
+ // UNIN -> FREE ; Accept as FREE -> FREE
+ //
+ // SEND -> SEND ; ERROR!
+ // SEND -> RECV ; User to User IPC, send message to machine
+ // SEND -> FREE ; User to Kernel IPC, recycle.
+ //
+ // RECV -> SEND ; ERROR!
+ // RECV -> RECV ; ERROR!
+ // RECV -> FREE ; End User IPC
+ //
+ // FREE -> SEND ; Begin User IPC
+ // FREE -> RECV ; Kernel to User IPC
+ // FREE -> FREE ; Kernel to Kernel IPC
+
+ case MACHDBG_CODE(DBG_MACH_IPC, MACH_IPC_MSG_SEND): {
+ // trace event data is:
+ // kmsg_addr, msgh_bits, msgh_id, voucher_addr,
+ auto kmsg_addr = event.arg1();
+ auto msgh_bits = (uint32_t)event.arg2();
+ auto msgh_id = (uint32_t)event.arg3();
+ auto voucher_addr = event.arg4();
+
+ auto nursery_it = _mach_msg_nursery.find(kmsg_addr);
+ if (nursery_it == _mach_msg_nursery.end()) {
+ nursery_it = _mach_msg_nursery.emplace(kmsg_addr, kmsg_addr).first;
+ }
+
+ auto& nursery_msg = nursery_it->second;
+
+ switch (nursery_msg.state()) {
+ // SEND -> SEND ; ERROR!
+ // RECV -> SEND ; ERROR!
+ case kNurseryMachMsgState::Send:
+ ASSERT(false, "illegal state transition (SEND -> SEND) in nursery mach msg");
+ case kNurseryMachMsgState::Recv:
+ ASSERT(false, "illegal state transition (RECV -> SEND) in nursery mach msg");
+ break;
+
+ // UNIN -> SEND ; Accept as FREE -> SEND
+ // FREE -> SEND ; Begin User IPC
+ case kNurseryMachMsgState::Uninitialized:
+ case kNurseryMachMsgState::Free: {
+ uintptr_t event_index = &event - _events;
+ nursery_msg.send(event_index, event.timestamp(), event.tid(), kmsg_addr, msgh_bits, msgh_id, process_event_voucher_lookup(voucher_addr, msgh_bits));
+ break;
+ }
+ }
+ // We do the state set here so that release builds
+ // sync to current state when errors are encountered
+ nursery_msg.set_state(kNurseryMachMsgState::Send);
+ break;
+ }
+
+ case MACHDBG_CODE(DBG_MACH_IPC, MACH_IPC_MSG_RECV):
+ case MACHDBG_CODE(DBG_MACH_IPC, MACH_IPC_MSG_RECV_VOUCHER_REFUSED):
+ {
+ // trace event data is
+ // kmsg_addr, msgh_bits, msgh_id, voucher_addr
+ auto kmsg_addr = event.arg1();
+ auto msgh_bits = (uint32_t)event.arg2();
+ auto voucher_addr = event.arg4();
+
+ auto nursery_it = _mach_msg_nursery.find(kmsg_addr);
+ if (nursery_it == _mach_msg_nursery.end()) {
+ nursery_it = _mach_msg_nursery.emplace(kmsg_addr, kmsg_addr).first;
+ }
+
+ auto& nursery_msg = nursery_it->second;
+
+ uint32_t flags = (event.dbg_code() == MACH_IPC_MSG_RECV_VOUCHER_REFUSED) ? kMachineMachMsgFlag::IsVoucherRefused : 0;
+ uintptr_t event_index = &event - _events;
+
+ switch (nursery_msg.state()) {
+
+ // UNIN -> RECV ; Accept as SEND -> RECV
+ case kNurseryMachMsgState::Uninitialized: {
+ flags |= kMachineMachMsgFlag::HasReceiver;
+
+ auto mach_msg_it = _mach_msgs.emplace(_mach_msgs.end(),
+ NurseryMachMsg<SIZE>::message_id(),
+ kmsg_addr,
+ flags,
+ AbsTime(0),
+ 0,
+ 0,
+ &Machine<SIZE>::UnsetVoucher,
+ now,
+ event.tid(),
+ msgh_bits,
+ process_event_voucher_lookup(voucher_addr, msgh_bits));
+
+ ASSERT(_mach_msgs_by_event_index.find(event_index) == _mach_msgs_by_event_index.end(), "Stomping mach msg");
+ _mach_msgs_by_event_index[event_index] = std::distance(_mach_msgs.begin(), mach_msg_it);
+ break;
+ }
+
+ // SEND -> RECV ; User to User IPC, send message to machine
+ case kNurseryMachMsgState::Send: {
+ ASSERT(kmsg_addr == nursery_msg.kmsg_addr(), "Sanity");
+ ASSERT((uint32_t)event.arg3() == nursery_msg.send_msgh_id(), "Sanity");
+
+ flags |= (kMachineMachMsgFlag::HasSender | kMachineMachMsgFlag::HasReceiver);
+
+ auto mach_msg_it = _mach_msgs.emplace(_mach_msgs.end(),
+ nursery_msg.id(),
+ kmsg_addr,
+ flags,
+ nursery_msg.send_time(),
+ nursery_msg.send_tid(),
+ nursery_msg.send_msgh_bits(),
+ nursery_msg.send_voucher(),
+ now,
+ event.tid(),
+ msgh_bits,
+ process_event_voucher_lookup(voucher_addr, msgh_bits));
+
+ intptr_t send_event_index = nursery_msg.send_event_index();
+ if (send_event_index != -1) {
+ ASSERT(send_event_index < _event_count, "Sanity");
+ ASSERT(_mach_msgs_by_event_index.find(event_index) == _mach_msgs_by_event_index.end(), "Stomping mach msg");
+ _mach_msgs_by_event_index[send_event_index] = std::distance(_mach_msgs.begin(), mach_msg_it);
+ }
+ ASSERT(_mach_msgs_by_event_index.find(event_index) == _mach_msgs_by_event_index.end(), "Stomping mach msg");
+ _mach_msgs_by_event_index[event_index] = std::distance(_mach_msgs.begin(), mach_msg_it);
+ break;
+ }
+
+ // RECV -> RECV ; ERROR!
+ case kNurseryMachMsgState::Recv:
+ ASSERT(false, "illegal state transition (RECV -> RECV) in nursery mach msg");
+ break;
+
+ // FREE -> RECV ; Kernel to User IPC
+ case kNurseryMachMsgState::Free:
+ break;
+ }
+
+ // We do the state set here so that release builds
+ // sync to current state when errors are encountered
+ nursery_msg.set_state(kNurseryMachMsgState::Recv);
+ break;
+ }
+
+ case MACHDBG_CODE(DBG_MACH_IPC, MACH_IPC_KMSG_FREE): {
+ // trace event data is:
+ // kmsg_addr
+
+ auto kmsg_addr = event.arg1();
+
+ auto nursery_it = _mach_msg_nursery.find(kmsg_addr);
+ if (nursery_it == _mach_msg_nursery.end()) {
+ nursery_it = _mach_msg_nursery.emplace(kmsg_addr, kmsg_addr).first;
+ }
+
+ auto& nursery_msg = nursery_it->second;
+
+
+ // All transitions to FREE are legal.
+ nursery_msg.set_state(kNurseryMachMsgState::Free);
+ }
+
+ default:
+ // IO Activity
+ //
+ // There isn't an easy way to handle these inside the switch, The
+ // code is used as a bitfield.
+
+
+ //
+ // Okay temp note on how to approach this.
+ //
+ // Even a single thread may have overlapping IO activity.
+ // None of the current scheme's handle overlapped activity well.
+ //
+ // We'd like to be able to show for any given interval, "X pages IO outstanding, Y pages completed, Z ms waiting"
+ //
+ // To do that, we've got to be able to intersect an arbitrary interval with a pile of overlapping intervals.
+ //
+ // The approach is to accumulate the IO activity into a single vector.
+ // Sort by interval.location().
+ // Now flatten this interval (union flatten).
+ // This will produce a second vector of non-overlapping intervals.
+ // When we want to intersect the arbitrary interval, we do the standard search on the non overlapping interval vector.
+ // This will give us a starting and ending location that guarantee to cover every IO that might intersect.
+ //
+ // The assumption is that while IO's overlap, they don't stay active forever. Sooner or later there will be a break.
+ //
+ // The arch-nemesis of this scheme is the light overlap, like so:
+ //
+ // XXXXX XXXXXXXXXXX XXXXXXXXXXXXXXXXXXXX
+ // XXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXX
+
+
+ //
+ // It turns out that IO can overlap inside a single thread, for example:
+ //
+ // 437719 C73AD5945 --- P_RdDataAsync 209b9f07 1000002 6b647 5000 2A72 1 gamed 293
+ // 437724 C73AD5DCA --- P_RdDataAsync 209b7e37 1000002 6b64c 6000 2A72 1 gamed 293
+ // 437822 C73AD98B0 --- P_RdDataAsyncDone 209b7e37 4dfe3eef 0 0 191 1 kernel_task 0
+ // 437829 C73AD9E55 --- P_RdDataAsyncDone 209b9f07 4dfe3eef 0 0 191 1 kernel_task 0
+ //
+
+ if (event.dbg_class() == DBG_FSYSTEM && event.dbg_subclass() == DBG_DKRW) {
+ uint32_t code = event.dbg_code();
+ //
+ // Disk IO doesn't use func_start/func_end
+ //
+ // arg1 == uid
+ // arg4 == size
+ if (code & DKIO_DONE) {
+ this->end_io(now, event.arg1());
+ } else {
+
+ // IO is initiated by a given process/thread, but it always finishes on a kernel_thread.
+ // We need to stash enough data to credit the correct thread when the completion event arrives.
+ begin_io(event_thread, now, event.arg1(), event.arg4());
+ }
+ } else if (event.dbg_class() == DBG_IMPORTANCE) {
+ //
+ // Every task policy set trace code carries "trequested" data, we would like to grab them all.
+ //
+ // This subclass spans the range of 0x20 through 0x3F
+ //
+
+ uint32_t subclass = event.dbg_subclass();
+ if (subclass >= 0x20 && subclass <= 0x3F) {
+ // Trace event data is
+ // targetid(task, thread), trequested_0(task, thread), trequested_1(task, thread), value
+
+ bool is_task_event = (event.dbg_code() & TASK_POLICY_TASK) > 0;
+
+ // Should not be both a task and thread event.
+ ASSERT(is_task_event != (event.dbg_code() & TASK_POLICY_THREAD), "BEWM!");
+
+ if (is_task_event) {
+ process_trequested_task((pid_t)event.arg1(), event.arg2(), event.arg3());
+ } else {
+ process_trequested_thread(event.arg1(), event.arg2(), event.arg3());
+ }
+ }
+ }
+ break;
+ }
+ }
+
+ return true;
+}
+
+template <typename SIZE>
+void Machine<SIZE>::initialize_cpu_idle_intr_states() {
+ ASSERT(_event_count, "Sanity");
+ ASSERT(_events, "Sanity");
+ ASSERT(!_cpus.empty(), "Sanity");
+
+ // How much work do we need to do?
+ uint32_t inits_needed = 0;
+ uint32_t inits_done = 0;
+ for (auto& cpu : _cpus) {
+ if (!cpu.is_iop()) {
+ inits_needed += 3;
+
+ if (cpu.is_intr_state_initialized()) {
+ inits_done++;
+ }
+ if (cpu.is_idle_state_initialized()) {
+ inits_done++;
+ }
+ if (cpu.is_thread_state_initialized()) {
+ inits_done++;
+ }
+ }
+ }
+
+ uintptr_t index;
+ for (index = 0; index < _event_count; ++index) {
+ const KDEvent<SIZE>& event = _events[index];
+ ASSERT(event.cpu() > -1 && event.cpu() < _cpus.size(), "cpu_id out of range");
+ MachineCPU<SIZE>& cpu = _cpus[event.cpu()];
+
+ if (!cpu.is_iop()) {
+ switch (event.dbg_cooked()) {
+ case TRACE_LOST_EVENTS:
+ // We're done, give up.
+ return;
+
+ case MACHDBG_CODE(DBG_MACH_EXCP_INTR, 0):
+ if (!cpu.is_intr_state_initialized()) {
+ inits_done++;
+
+ if (event.is_func_start()) {
+ // If we are starting an INTR now, the cpu was not in INTR prior to now.
+ cpu.initialize_intr_state(false, _events[0].timestamp());
+ } else {
+ // If we are ending an INTR now, the cpu was in INTR prior to now.
+ cpu.initialize_intr_state(true, _events[0].timestamp());
+ }
+ }
+ break;
+
+ case MACHDBG_CODE(DBG_MACH_SCHED, MACH_IDLE):
+ if (!cpu.is_idle_state_initialized()) {
+ inits_done++;
+
+ if (event.is_func_start()) {
+ // If we are starting Idle now, the cpu was not Idle prior to now.
+ cpu.initialize_idle_state(false, _events[0].timestamp());
+ } else {
+ // If we are ending Idle now, the cpu was Idle prior to now.
+ cpu.initialize_idle_state(true, _events[0].timestamp());
+ }
+ }
+ break;
+
+ // I spent a day tracking this down....
+ //
+ // When you are actively sampling (say, every 100ms) on a machine
+ // that is mostly idle, there will be long periods of VERY idle
+ // cpus. So you might get a sample with no begin/end idle at all,
+ // but the cpu is actually idle the entire time. Now suppose in
+ // the next sample, you get a simple idle timeout in the middle,
+ // and immdiately go back to idle. If we treat any TID found on
+ // cpu as "running", we blow up because this segment appears to
+ // have the idle thread "running".
+ //
+ // So, to do a proper thread init, we require actual scheduler
+ // activity to tell us who the thread was.
+ case MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED):
+ case MACHDBG_CODE(DBG_MACH_SCHED, MACH_STACK_HANDOFF):
+ if (!cpu.is_thread_state_initialized()) {
+ inits_done++;
+
+ // We want to use the thread that *was* on cpu, not the thread being
+ // handed off too.
+ MachineThread<SIZE>* init_thread = youngest_mutable_thread(event.tid());
+ // Legal for this to be NULL!
+ cpu.initialize_thread_state(init_thread, _events[0].timestamp());
+
+ }
+ break;
+ }
+ }
+
+ if (inits_done == inits_needed) {
+ break;
+ }
+ }
+}
+
+template <typename SIZE>
+void Machine<SIZE>::begin_io(MachineThread<SIZE>* thread, AbsTime begin_time, typename SIZE::ptr_t uid, typename SIZE::ptr_t size) {
+ auto it = _io_by_uid.find(uid);
+ if (it == _io_by_uid.end()) {
+ _io_by_uid.emplace(uid, IOActivity<SIZE>(begin_time, AbsTime(0), thread, size));
+ } else {
+ // We shouldn't find a valid IO entry at the uid we're installing.
+ ASSERT(it->second.thread() == NULL, "Overwriting existing io entry");
+ ASSERT(it->second.location() == 0, "Overwriting existing io entry");
+
+ it->second = IOActivity<SIZE>(begin_time, AbsTime(0), thread, size);
+ }
+}
+
+template <typename SIZE>
+void Machine<SIZE>::end_io(AbsTime end_time, typename SIZE::ptr_t uid) {
+ auto it = _io_by_uid.find(uid);
+
+ // Its okay to not find a match, if a trace begins with a Done event, for example.
+ if (it != _io_by_uid.end()) {
+ MachineThread<SIZE>* io_thread = it->second.thread();
+ AbsTime begin_time = it->second.location();
+ ASSERT(end_time > it->second.location(), "Sanity");
+
+ _all_io.emplace_back(begin_time, end_time - begin_time, io_thread, it->second.size());
+
+ DEBUG_ONLY({
+ it->second.set_thread(NULL);
+ it->second.set_location(AbsTime(0));
+ it->second.set_length(AbsTime(0));
+ })
+ }
+}
projects / apple / system_cmds.git / blobdiff