+++ /dev/null
-//
-// MachineThread.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>
-void MachineThread<SIZE>::set_is_idle_thread() {
- ASSERT(!is_trace_terminated(), "Attempt to mark terminated thread as IDLE");
- ASSERT(_process->is_kernel(), "Attempt to set non-kernel thread as IDLE");
-
- set_flags(kMachineThreadFlag::IsIdle);
-}
-
-template <typename SIZE>
-void MachineThread<SIZE>::set_trace_terminated(AbsTime timestamp) {
- ASSERT(!is_trace_terminated(), "Attempt to trace terminate thread more than once");
- ASSERT(!is_idle_thread(), "Attempt to terminate IDLE thread");
-
- AbsTime terminated_timestamp = timestamp + AbsTime(1);
-
- // If we were killed with a block event pending, we need to flush it
- // to the queue. The make_runnable call will do sanity checks to
- // handle the corner cases when called from here.
- make_runnable(terminated_timestamp);
-
- // We need to set the final timestamp for this thread's last voucher.
- // Note that the null voucher and unset voucher are actual objects,
- // they are not represented by NULL or nullptr.
- _vouchers_by_time.back().set_max(terminated_timestamp);
-
- //
- // Finally set this threads timespan
- //
- _timespan.set_max(terminated_timestamp);
-
-
- set_flags(kMachineThreadFlag::TraceTerminated);
-}
-
-template <typename SIZE>
-void MachineThread<SIZE>::make_runnable(AbsTime timestamp) {
- ASSERT(!is_trace_terminated(), "Attempting to make terminated thread runnable");
- ASSERT(timestamp >= _timespan.location(), "Attempt to make thread runnable before it exists");
-
- if (_begin_blocked > 0) {
- ASSERT(timestamp > _begin_blocked, "Sanity");
- ASSERT(_blocked.empty() || _begin_blocked > _blocked.back().max(), "Out of order blocked regions");
- _blocked.emplace_back(_begin_blocked, timestamp - _begin_blocked);
- _begin_blocked = AbsTime(0);
- }
-}
-
-template <typename SIZE>
-void MachineThread<SIZE>::make_unrunnable(AbsTime timestamp) {
- ASSERT(!is_trace_terminated(), "Attempting to make terminated thread unrunnable");
- ASSERT(timestamp >= _timespan.location(), "Attempt to make thread unrunnable before it exists");
-
- _begin_blocked = timestamp;
-}
-
-template <typename SIZE>
-void MachineThread<SIZE>::begin_vm_fault(AbsTime timestamp) {
- ASSERT(timestamp >= _timespan.location(), "Attempt to begin vm fault before thread exists");
- ASSERT(!is_trace_terminated(), "Attempt to begin vm fault on thread that has terminated");
- ASSERT(!is_idle_thread(), "Attempt to begin vm fault on IDLE thread");
-
- ASSERT(_begin_vm_fault == 0, "Attempt to begin vm_fault without end");
- _begin_vm_fault = timestamp;
-}
-
-template <typename SIZE>
-void MachineThread<SIZE>::end_vm_fault(AbsTime timestamp) {
- ASSERT(timestamp >= _timespan.location(), "Attempt to end vm fault before thread exists");
- ASSERT(!is_trace_terminated(), "Attempt to end vm fault on thread that has terminated");
- ASSERT(!is_idle_thread(), "Attempt to end vm fault on IDLE thread");
-
- if (_begin_vm_fault > 0) {
- ASSERT(timestamp > _begin_vm_fault, "Sanity");
- ASSERT(_vm_faults.empty() || _begin_vm_fault > _vm_faults.back().max(), "Out of order vm_fault regions");
- _vm_faults.emplace_back(_begin_vm_fault, timestamp - _begin_vm_fault);
- _begin_vm_fault = AbsTime(0);
- }
-}
-
-template <typename SIZE>
-void MachineThread<SIZE>::begin_jetsam_activity(uint32_t type, AbsTime timestamp) {
- ASSERT(timestamp >= _timespan.location(), "Attempt to begin jetsam activity before thread exists");
- ASSERT(!is_trace_terminated(), "Attempt to begin jetsam activity on thread that has terminated");
- ASSERT(!is_idle_thread(), "Attempt to begin jetsam activity on IDLE thread");
-
- ASSERT(_begin_jetsam_activity == 0, "Attempt to begin jetsam activity without end");
- ASSERT(_begin_jetsam_activity_type == 0, "Sanity");
-
- _begin_jetsam_activity = timestamp;
- DEBUG_ONLY(_begin_jetsam_activity_type = type;)
-}
-
-template <typename SIZE>
-void MachineThread<SIZE>::end_jetsam_activity(uint32_t type, AbsTime timestamp) {
- ASSERT(timestamp >= _timespan.location(), "Attempt to end jetsam activity before thread exists");
- ASSERT(!is_trace_terminated(), "Attempt to end jetsam activity on thread that has terminated");
- ASSERT(!is_idle_thread(), "Attempt to end jetsam activity on IDLE thread");
-
- if (_begin_jetsam_activity > 0) {
- ASSERT(type == _begin_jetsam_activity_type, "End event type does not match start event");
- ASSERT(timestamp > _begin_jetsam_activity, "Sanity");
- ASSERT(_jetsam_activity.empty() || _begin_jetsam_activity > _jetsam_activity.back().max(), "Out of order jetsam activities");
- _jetsam_activity.emplace_back(_begin_jetsam_activity, timestamp - _begin_jetsam_activity);
- _begin_jetsam_activity = AbsTime(0);
- DEBUG_ONLY(_begin_jetsam_activity_type = 0;)
- }
-}
-
-template <typename SIZE>
-void MachineThread<SIZE>::set_voucher(MachineVoucher<SIZE>* voucher, AbsTime timestamp) {
- ASSERT(timestamp >= _timespan.location(), "Attempt to set voucher on thread before thread exists");
- ASSERT(!is_trace_terminated(), "Attempt to set voucher on terminated thread");
- ASSERT(!is_idle_thread(), "Attempt to set voucher on IDLE thread");
- ASSERT(!_vouchers_by_time.empty() || _vouchers_by_time.back().max() < timestamp, "Sanity");
- ASSERT(_vouchers_by_time.back().location() < timestamp, "Sanity");
-
- VoucherInterval<SIZE>& last_voucher = _vouchers_by_time.back();
-
- if (voucher != last_voucher.voucher()) {
- ASSERT(last_voucher.max() == AbsTime::END_OF_TIME, "Sanity");
-
- //
- // By default, the voucher interval has the last voucher continuing "forever".
- // We need to trim the time used by that voucher, while handling the case of
- // the very first event setting a new voucher as well.
- //
- // There are three cases possible.
- //
- // 1) timestamp > last_voucher.location // This is the expected case
- // 2) timestamp == last_voucher.location // This should only be possible on the very first event for a thread
- // 3) timestamp < last_voucher.location // This is an error at all times.
- //
-
- if (timestamp > last_voucher.location()) {
- // Expected case (#1)
- last_voucher.set_max(timestamp);
- _vouchers_by_time.emplace_back(voucher, AbsInterval(timestamp, AbsTime::END_OF_TIME - timestamp));
- } else if (timestamp == last_voucher.location()) {
- // Corner case (#2)
- //
- // Note that we cannot assert that the voucher being replaced is the unset voucher,
- // as vouchers are forwarded during "live" event handling. This means that the thread
- // may have a valid voucher that is replaced on the first event.
- //
- // The timestamp == _timespan.location assert may also be too strong, if we start forwarding threads true lifetimes.
-
- ASSERT(timestamp == _timespan.location(), "Should only be overriding a voucher on the first event for a given thread.");
- ASSERT(_vouchers_by_time.size() == 1, "Attempt to replace the current voucher when it isn't the first voucher");
- _vouchers_by_time.pop_back();
- _vouchers_by_time.emplace_back(voucher, AbsInterval(timestamp, AbsTime::END_OF_TIME - timestamp));
- } else {
- ASSERT(false, "Attempting to set a voucher on thread earlier in time than the thread's current voucher");
-
- }
- }
-}
-
-template <typename SIZE>
-void MachineThread<SIZE>::post_initialize(AbsTime last_machine_timestamp) {
- if (!is_trace_terminated()) {
- //
- // For threads that are still alive at the post_initialize phase,
- // we want to extend their timespan(s) to the end of the machine state,
- // so they can be looked up by tid/timestamp
- //
- ASSERT(_timespan.length() == 0, "Sanity");
-
- // Time in a range is always half open. [ 10, 11 ) means 10 is included,
- // but 11 is not. In order to include a given timestamp, we must use
- // a value one greater.
- AbsTime half_open_timestamp = last_machine_timestamp + AbsTime(1);
-
- _timespan.set_max(half_open_timestamp);
-
- // 6/22/2014 Not sure about this. Just working on the massive time
- // cleanup, along with the "we really know when threads and processes
- // are done" cleanup. We used to always check and flush any outstanding
- // blocked events in post_initialize. This is done explicitly in the trace
- // terminated code now. However, it is possible to have a blocked event
- // outstanding in a live thread at this point. If we actually forward state
- // to future threads, we would want to pick that up, right?
- //
- // So what do we do here?
- //
- // We could make sure the intermediate states were properly fowarded
- // as the threads are forwarded. That leaves the problem of queries against
- // this machine state not showing an existing blocked state, which could
- // have begun long ago.
- //
- // If we flush, how do we tag that last block so the forwarding happens
- // correctly?
- //
- // For now, no one is doing the live update thing and using the cpu
- // states, so I'm going to flush.
- //
- // Note that if the very last event is a make_unrunnable for a thread,
- // this is going to yield a zero length blocking event, which might assert.
- //
- // NEEDS REVIEW, FIX ME.
- make_runnable(half_open_timestamp);
-
- _vouchers_by_time.back().set_max(half_open_timestamp);
- }
-}
projects / apple / system_cmds.git / blobdiff