system_cmds-671.10.3.tar.gz

[apple/system_cmds.git] / KDBG / Machine.hpp

//
//  Machine.hpp
//  KDBG
//
//  Created by James McIlree on 10/25/12.
//  Copyright (c) 2014 Apple. All rights reserved.
//

enum class kMachineFlag : std::uint32_t {
	LostEvents			= 0x00000001
};

template <typename SIZE>
class Machine {
    protected:
	std::vector<MachineCPU<SIZE>>									_cpus;

	std::unordered_multimap<pid_t, MachineProcess<SIZE>>						_processes_by_pid;
	std::unordered_multimap<const char*, MachineProcess<SIZE>*, ConstCharHash, ConstCharEqualTo>	_processes_by_name;
	std::vector<MachineProcess<SIZE>*>								_processes_by_time;

	std::unordered_multimap<typename SIZE::ptr_t, MachineThread<SIZE> >				_threads_by_tid;
	std::vector<MachineThread<SIZE>*>								_threads_by_time;

	std::vector<MachineMachMsg<SIZE>>								_mach_msgs;
	std::unordered_map<uintptr_t, uintptr_t>							_mach_msgs_by_event_index;
	std::unordered_map<typename SIZE::ptr_t, NurseryMachMsg<SIZE>>					_mach_msg_nursery;

	//
	// Vouchers are a bit special. We install pointers to vouchers in
	// MachineThreads and MachineMachMsg. This means that vouchers cannot
	// be moved once allocated. We could do two passes to exactly size
	// the data structures, this should be investigated in the future.
	//
	// On create or first observed use, a voucher goes into the nursery.
	// It stays there until a destroy event, or the end of Machine events.
	// Once flushed from the nursery, we have a map of addresses, which
	// points to a vector sorted by time. This allows addr @ time lookups
	// later.
	//
	std::unordered_map<typename SIZE::ptr_t, std::unique_ptr<MachineVoucher<SIZE>>>			_voucher_nursery;
        std::unordered_map<typename SIZE::ptr_t, std::vector<std::unique_ptr<MachineVoucher<SIZE>>>>	_vouchers_by_addr;

	std::unordered_map<typename SIZE::ptr_t, IOActivity<SIZE>>					_io_by_uid; // uid == unique id, not user id
	std::vector<IOActivity<SIZE>>									_all_io;
	std::vector<AbsInterval>									_all_io_active_intervals;

	MachineProcess<SIZE>*										_kernel_task;
	const KDEvent<SIZE>*										_events;
	uintptr_t											_event_count;
	uint32_t											_flags;
	int32_t												_unknown_process_pid; // We need unique negative pid's for previously unknown TID's

	//
	// Protected initialization code
	//
	void raw_initialize(const KDCPUMapEntry* cpumaps,
			    uint32_t cpumap_count,
			    const KDThreadMapEntry<SIZE>* threadmaps,
			    uint32_t threadmap_count,
			    const KDEvent<SIZE>* events,
			    uintptr_t event_count);

	void post_initialize();

	//
	// Mutable API, for use during construction
	//
	
	pid_t next_unknown_pid()									{ return --_unknown_process_pid; }
	
	MachineProcess<SIZE>* create_process(pid_t pid, const char* name, AbsTime create_timestamp, kMachineProcessFlag flags);
	MachineThread<SIZE>* create_thread(MachineProcess<SIZE>* process, typename SIZE::ptr_t tid, MachineVoucher<SIZE>* voucher, AbsTime create_timestamp, kMachineThreadFlag flags);
	MachineVoucher<SIZE>* create_voucher(typename SIZE::ptr_t address, AbsTime create_timestamp, kMachineVoucherFlag flags, uint32_t content_bytes_capacity);

	void destroy_voucher(typename SIZE::ptr_t address, AbsTime timestamp);

	void set_flags(kMachineFlag flag)								{ _flags |= (uint32_t)flag; }
	
	void set_process_name(MachineProcess<SIZE>* process, const char* name);
	
	MachineProcess<SIZE>* mutable_process(pid_t pid, AbsTime time)					{ return const_cast<MachineProcess<SIZE>*>(process(pid, time)); }
	MachineThread<SIZE>* mutable_thread(typename SIZE::ptr_t tid, AbsTime time)			{ return const_cast<MachineThread<SIZE>*>(thread(tid, time)); }
	
	MachineProcess<SIZE>* youngest_mutable_process(pid_t pid);
	MachineThread<SIZE>* youngest_mutable_thread(typename SIZE::ptr_t tid);

	MachineVoucher<SIZE>* process_event_voucher_lookup(typename SIZE::ptr_t address, uint32_t msgh_bits);
	MachineThread<SIZE>* process_event_tid_lookup(typename SIZE::ptr_t tid, AbsTime now);

	MachineVoucher<SIZE>* thread_forwarding_voucher_lookup(const MachineVoucher<SIZE>* original_thread_voucher);

	void begin_io(MachineThread<SIZE>* thread, AbsTime time, typename SIZE::ptr_t uid, typename SIZE::ptr_t size);
	void end_io(AbsTime time, typename SIZE::ptr_t uid);

	bool process_event(const KDEvent<SIZE>& event);
	void process_trequested_task(pid_t pid, typename SIZE::ptr_t trequested_0, typename SIZE::ptr_t trequested_1);
	void process_trequested_thread(typename SIZE::ptr_t tid, typename SIZE::ptr_t trequested_0, typename SIZE::ptr_t trequested_1);

	void initialize_cpu_idle_intr_states();

    public:
	static MachineVoucher<SIZE> UnsetVoucher;
	static MachineVoucher<SIZE> NullVoucher;

	Machine(KDCPUMapEntry* cpumaps, uint32_t cpumap_count, KDThreadMapEntry<SIZE>* threadmaps, uint32_t threadmap_count, KDEvent<SIZE>* events, uintptr_t event_count);
	// Destructive, mutates parent!
	Machine(Machine<SIZE>& parent, KDEvent<SIZE>* events, uintptr_t event_count);
	Machine(const TraceFile& file);

	bool lost_events() const									{ return (_flags & (uint32_t)kMachineFlag::LostEvents) > 0; }
	
	const MachineProcess<SIZE>* process(pid_t pid, AbsTime time) const;
	const MachineThread<SIZE>* thread(typename SIZE::ptr_t tid, AbsTime time) const;
	const MachineVoucher<SIZE>* voucher(typename SIZE::ptr_t address, AbsTime time) const;
	const MachineMachMsg<SIZE>* mach_msg(uintptr_t event_index) const;

	const std::vector<const MachineProcess<SIZE>*>& processes() const;
	const std::vector<const MachineThread<SIZE>*>& threads() const;
	const std::vector<const MachineCPU<SIZE>>& cpus() const;

	const KDEvent<SIZE>* events() const								{ return _events; }
	uintptr_t event_count() const									{ return _event_count; }

	AbsInterval timespan() const;

	// Returns the number of cpus that have timeline data.
	// (IOW, typically the number of AP(s) on a machine, but might be less if you've disabled some so they generate no trace data)
	uint32_t active_cpus() const;

	// If summary_cpu == NULL , all cpus are matched.
	CPUSummary<SIZE> summary_for_timespan(AbsInterval timespan, const MachineCPU<SIZE>* summary_cpu) const;

	// This attempts to analyze various pieces of data and guess
	// if the Machine represents an ios device or not.
	bool is_ios() const;

	DEBUG_ONLY(void validate() const;)
};

template <typename SIZE> MachineVoucher<SIZE> Machine<SIZE>::UnsetVoucher(SIZE::PTRMAX, AbsInterval(AbsTime(0),AbsTime(UINT64_MAX)), kMachineVoucherFlag::IsUnsetVoucher, 0);
template <typename SIZE> MachineVoucher<SIZE> Machine<SIZE>::NullVoucher(0, AbsInterval(AbsTime(0),AbsTime(UINT64_MAX)), kMachineVoucherFlag::IsNullVoucher, 0);