[apple/xnu.git] / tools / lldbmacros / usertaskdebugging / userprocess.py

import logging
import target
import struct

from xnu import *
from core.operating_system import Armv8_RegisterSet, Armv7_RegisterSet, I386_RegisterSet, X86_64RegisterSet

""" these defines should come from an authoritative header file """
CPU_TYPE_I386 = 0x00000007
CPU_TYPE_X86_64 = 0x01000007
CPU_TYPE_ARM = 0x0000000c
CPU_TYPE_ARM64 = 0x0100000c

def GetRegisterSetForCPU(cputype, subtype):
    if cputype == CPU_TYPE_ARM64:
        retval = Armv8_RegisterSet
    elif cputype == CPU_TYPE_ARM:
        retval = Armv7_RegisterSet
    elif cputype == CPU_TYPE_I386:
        retval = I386_RegisterSet
    elif cputype == CPU_TYPE_X86_64:
        retval = X86_64RegisterSet
    
    """ crash if unknown cputype """

    return retval.register_info['registers']


class UserThreadObject(object):
    """representation of userspace thread"""
    def __init__(self, thr_obj, cputype, cpusubtype, is_kern_64bit):
        super(UserThreadObject, self).__init__()
        self.thread = thr_obj
        self.registerset = GetRegisterSetForCPU(cputype, cpusubtype)
        self.thread_id = unsigned(self.thread.thread_id)
        self.is64Bit = bool(cputype & 0x01000000)

        if self.is64Bit:
            if cputype == CPU_TYPE_X86_64:
                self.reg_type = "x86_64"
                self.saved_state = Cast(self.thread.machine.iss, 'x86_saved_state_t *').uss.ss_64
            if cputype == CPU_TYPE_ARM64:
                self.reg_type = "arm64"
                self.saved_state = self.thread.machine.upcb.uss.ss_64
        else:
            if cputype == CPU_TYPE_I386:
                self.reg_type = "i386"
                self.saved_state = Cast(self.thread.machine.iss, 'x86_saved_state_t *').uss.ss_32
            if cputype == CPU_TYPE_ARM:
                self.reg_type = "arm"
                if not is_kern_64bit:
                    self.saved_state = self.thread.machine.PcbData
                else:
                    self.saved_state = self.thread.machine.contextData.ss.uss.ss_32

        logging.debug("created thread id 0x%x of type %s, is_kern_64bit 0x%x cputype 0x%x"
                      % (self.thread_id, self.reg_type, is_kern_64bit, cputype))

    def getRegisterValueByName(self, name):
        if self.reg_type == 'arm64':
            if name in ('x0', 'x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7', 'x8', 'x9', 'x10', 'x11', 'x12', 'x13', 'x14', 'x15', 'x16', 'x17', 'x18', 'x19', 'x20', 'x21', 'x22', 'x23', 'x24', 'x25', 'x26', 'x27', 'x28'):
                return unsigned(getattr(self.saved_state, 'x')[int(name.strip('x'))])

            return unsigned(getattr(self.saved_state, name))

        if self.reg_type == "x86_64":
            if name in ('rip', 'rflags', 'cs', 'rsp', 'cpu'):
                return unsigned(getattr(self.saved_state.isf, name))
            return unsigned(getattr(self.saved_state, name))

        if self.reg_type == "arm":
            if name in ('r0', 'r1', 'r2', 'r3', 'r4', 'r5', 'r6', 'r7', 'r8', 'r9', 'r10', 'r11', 'r12'):
                retval = unsigned(getattr(self.saved_state, 'r')[int(name.strip('r'))])
            else:
                retval = unsigned(getattr(self.saved_state, name))
            return retval

        #TODO for i386

    def getName(self):
        return str(self.thread_id)

    def getRegisterData(self, reg_num):
        """ returns None if there is error """
        if reg_num < 0 or reg_num >= len(self.registerset):
            logging.warning("regnum %d is not defined for thread_id 0x%x" % (reg_num, self.thread_id))
            return None
        return self.getRegisterValueByName(self.registerset[reg_num]['name'])


class UserProcess(target.Process):
    """ Represent a user process and thread states """
    def __init__(self, task):
        self.task = task
        self.proc = Cast(task.bsd_info, 'proc_t')
        dataregisters64bit = False
        ptrsize = 4

        if task.t_flags & 0x1:
            ptrsize = 8
        if task.t_flags & 0x2:
            dataregisters64bit = True

        is_kern_64bit = kern.arch in ['x86_64', 'x86_64h', 'arm64'
        ]

        self.cputype = unsigned(self.proc.p_cputype)
        self.cpusubtype = unsigned(self.proc.p_cpusubtype)

        super(UserProcess, self).__init__(self.cputype, self.cpusubtype, ptrsize)

        self.hinfo['ostype'] = 'macosx'
        if self.cputype != CPU_TYPE_X86_64 and self.cputype != CPU_TYPE_I386:
            self.hinfo['ostype'] = 'ios'

        self.registerset = GetRegisterSetForCPU(self.cputype, self.cpusubtype)
        logging.debug("process %s is64bit: %d ptrsize: %d cputype: %d  cpusubtype:%d",
                      hex(self.proc), int(dataregisters64bit), ptrsize,
                      self.cputype, self.cpusubtype
                      )
        self.threads = {}
        self.threads_ids_list = []
        logging.debug("iterating over threads in process")
        for thval in IterateQueue(task.threads, 'thread *', 'task_threads'):
            self.threads[unsigned(thval.thread_id)] = UserThreadObject(thval, self.cputype, self.cpusubtype, is_kern_64bit)
            self.threads_ids_list.append(unsigned(thval.thread_id))

    def getRegisterDataForThread(self, th_id, reg_num):
        if th_id not in self.threads:
            logging.critical("0x%x thread id is not found in this task")
            return ''
        if reg_num < 0 or reg_num >= len(self.registerset):
            logging.warning("regnum %d is not defined for thread_id 0x%x" % (reg_num, th_id))
            return ''
        value = self.threads[th_id].getRegisterData(reg_num)
        return self.encodeRegisterData(value, bytesize=self.registerset[reg_num]['bitsize']/8)

    def getRegisterCombinedDataForThread(self, th_id):
        if th_id not in self.threads:
            logging.critical("0x%x thread id is not found in this task" % th_id)
            return ''
        cur_thread = self.threads[th_id]
        retval = 'thread:%s;name:%s;' % (self.encodeThreadID(th_id), cur_thread.getName())
        pos = 0
        for rinfo in self.registerset:
            name = rinfo['name']
            format = "%02x:%s;"
            value = cur_thread.getRegisterValueByName(name)
            value_endian_correct_str = self.encodeRegisterData(value, bytesize=(rinfo['bitsize']/8))
            retval += format % (pos, value_endian_correct_str)
            pos += 1
        return retval

    def getThreadStopInfo(self, th_id):
        if th_id not in self.threads:
            logging.critical("0x%x thread id is not found in this task")
            return ''
        return 'T02' + self.getRegisterCombinedDataForThread(th_id) + 'threads:' + self.getThreadsInfo()+';'

    def getRegisterInfo(self, regnum):
        #something similar to
        #"name:x1;bitsize:64;offset:8;encoding:uint;format:hex;gcc:1;dwarf:1;set:General Purpose Registers;"
        if regnum > len(self.registerset):
            logging.debug("No register_info for number %d." % regnum)
            return 'E45'

        rinfo = self.registerset[regnum]
        retval = ''
        for i in rinfo.keys():
            i_val = str(rinfo[i])
            if i == 'set':
                i_val = 'General Purpose Registers'
            retval += '%s:%s;' % (str(i), i_val)

        return retval

    def getProcessInfo(self):
        retval = ''
        #pid:d22c;parent-pid:d34d;real-uid:ecf;real-gid:b;effective-uid:ecf;effective-gid:b;cputype:1000007;cpusubtype:3;
        #ostype:macosx;vendor:apple;endian:little;ptrsize:8;
        pinfo = {'effective-uid': 'ecf', 'effective-gid': 'b', 'endian': 'little', 'vendor': 'apple'}
        pinfo['pid'] = "%x" % (GetProcPIDForTask(self.task))
        pinfo['parent-pid'] = "%x" % (unsigned(self.proc.p_ppid))
        pinfo['ptrsize'] = str(self.ptrsize)
        pinfo['ostype'] = 'macosx'
        pinfo['cputype'] = "%x" % self.cputype
        pinfo['cpusubtype'] = "%x" % self.cpusubtype
        pinfo['real-uid'] = "%x" % (unsigned(self.proc.p_ruid))
        pinfo['real-gid'] = "%x" % (unsigned(self.proc.p_rgid))
        if str(kern.arch).find('arm') >= 0:
            pinfo['ostype'] = 'ios'
        for i in pinfo.keys():
            i_val = str(pinfo[i])
            retval += '%s:%s;' % (str(i), i_val)
        return retval

    def readMemory(self, address, size):
        data = GetUserDataAsString(self.task, address, size)
        if not data:
            logging.error("Failed to read memory task:{: <#018x} {: <#018x} {:d}".format(self.task, address, size))
        return self.encodeByteString(data)

    def getSharedLibInfoAddress(self):
        return unsigned(self.task.all_image_info_addr)
Commit	Line	Data
39037602 A	1	import logging
	2	import target
	3	import struct
	4
	5	from xnu import *
	6	from core.operating_system import Armv8_RegisterSet, Armv7_RegisterSet, I386_RegisterSet, X86_64RegisterSet
	7
5ba3f43e	8	""" these defines should come from an authoritative header file """
39037602 A	9	CPU_TYPE_I386 = 0x00000007
	10	CPU_TYPE_X86_64 = 0x01000007
	11	CPU_TYPE_ARM = 0x0000000c
	12	CPU_TYPE_ARM64 = 0x0100000c
	13
39037602	14	def GetRegisterSetForCPU(cputype, subtype):
d9a64523	15	if cputype == CPU_TYPE_ARM64:
5ba3f43e A	16	retval = Armv8_RegisterSet
	17	elif cputype == CPU_TYPE_ARM:
	18	retval = Armv7_RegisterSet
39037602 A	19	elif cputype == CPU_TYPE_I386:
39037602 A	20	retval = I386_RegisterSet
5ba3f43e A	21	elif cputype == CPU_TYPE_X86_64:
	22	retval = X86_64RegisterSet
	23
	24	""" crash if unknown cputype """
39037602 A	25
	26	return retval.register_info['registers']
	27
	28
	29	class UserThreadObject(object):
	30	"""representation of userspace thread"""
d9a64523	31	def __init__(self, thr_obj, cputype, cpusubtype, is_kern_64bit):
39037602 A	32	super(UserThreadObject, self).__init__()
	33	self.thread = thr_obj
	34	self.registerset = GetRegisterSetForCPU(cputype, cpusubtype)
	35	self.thread_id = unsigned(self.thread.thread_id)
	36	self.is64Bit = bool(cputype & 0x01000000)
39037602 A	37
	38	if self.is64Bit:
	39	if cputype == CPU_TYPE_X86_64:
	40	self.reg_type = "x86_64"
	41	self.saved_state = Cast(self.thread.machine.iss, 'x86_saved_state_t *').uss.ss_64
	42	if cputype == CPU_TYPE_ARM64:
	43	self.reg_type = "arm64"
	44	self.saved_state = self.thread.machine.upcb.uss.ss_64
	45	else:
	46	if cputype == CPU_TYPE_I386:
	47	self.reg_type = "i386"
	48	self.saved_state = Cast(self.thread.machine.iss, 'x86_saved_state_t *').uss.ss_32
	49	if cputype == CPU_TYPE_ARM:
	50	self.reg_type = "arm"
d9a64523	51	if not is_kern_64bit:
39037602 A	52	self.saved_state = self.thread.machine.PcbData
	53	else:
	54	self.saved_state = self.thread.machine.contextData.ss.uss.ss_32
d9a64523 A	55
	56	logging.debug("created thread id 0x%x of type %s, is_kern_64bit 0x%x cputype 0x%x"
	57	% (self.thread_id, self.reg_type, is_kern_64bit, cputype))
39037602 A	58
	59	def getRegisterValueByName(self, name):
	60	if self.reg_type == 'arm64':
	61	if name in ('x0', 'x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7', 'x8', 'x9', 'x10', 'x11', 'x12', 'x13', 'x14', 'x15', 'x16', 'x17', 'x18', 'x19', 'x20', 'x21', 'x22', 'x23', 'x24', 'x25', 'x26', 'x27', 'x28'):
	62	return unsigned(getattr(self.saved_state, 'x')[int(name.strip('x'))])
	63
	64	return unsigned(getattr(self.saved_state, name))
	65
	66	if self.reg_type == "x86_64":
	67	if name in ('rip', 'rflags', 'cs', 'rsp', 'cpu'):
	68	return unsigned(getattr(self.saved_state.isf, name))
	69	return unsigned(getattr(self.saved_state, name))
	70
	71	if self.reg_type == "arm":
	72	if name in ('r0', 'r1', 'r2', 'r3', 'r4', 'r5', 'r6', 'r7', 'r8', 'r9', 'r10', 'r11', 'r12'):
	73	retval = unsigned(getattr(self.saved_state, 'r')[int(name.strip('r'))])
	74	else:
	75	retval = unsigned(getattr(self.saved_state, name))
	76	return retval
	77
	78	#TODO for i386
	79
	80	def getName(self):
	81	return str(self.thread_id)
	82
	83	def getRegisterData(self, reg_num):
	84	""" returns None if there is error """
	85	if reg_num < 0 or reg_num >= len(self.registerset):
	86	logging.warning("regnum %d is not defined for thread_id 0x%x" % (reg_num, self.thread_id))
	87	return None
	88	return self.getRegisterValueByName(self.registerset[reg_num]['name'])
	89
	90
	91	class UserProcess(target.Process):
	92	""" Represent a user process and thread states """
	93	def __init__(self, task):
	94	self.task = task
	95	self.proc = Cast(task.bsd_info, 'proc_t')
	96	dataregisters64bit = False
	97	ptrsize = 4
	98
	99	if task.t_flags & 0x1:
	100	ptrsize = 8
	101	if task.t_flags & 0x2:
d9a64523	102	dataregisters64bit = True
39037602	103
d9a64523 A	104	is_kern_64bit = kern.arch in ['x86_64', 'x86_64h', 'arm64'
d9a64523 A	105	]
5ba3f43e	106
d9a64523 A	107	self.cputype = unsigned(self.proc.p_cputype)
d9a64523 A	108	self.cpusubtype = unsigned(self.proc.p_cpusubtype)
39037602	109
d9a64523	110	super(UserProcess, self).__init__(self.cputype, self.cpusubtype, ptrsize)
39037602 A	111
39037602 A	112	self.hinfo['ostype'] = 'macosx'
d9a64523	113	if self.cputype != CPU_TYPE_X86_64 and self.cputype != CPU_TYPE_I386:
39037602 A	114	self.hinfo['ostype'] = 'ios'
39037602 A	115
d9a64523	116	self.registerset = GetRegisterSetForCPU(self.cputype, self.cpusubtype)
39037602 A	117	logging.debug("process %s is64bit: %d ptrsize: %d cputype: %d cpusubtype:%d",
	118	hex(self.proc), int(dataregisters64bit), ptrsize,
	119	self.cputype, self.cpusubtype
	120	)
	121	self.threads = {}
	122	self.threads_ids_list = []
	123	logging.debug("iterating over threads in process")
	124	for thval in IterateQueue(task.threads, 'thread *', 'task_threads'):
d9a64523	125	self.threads[unsigned(thval.thread_id)] = UserThreadObject(thval, self.cputype, self.cpusubtype, is_kern_64bit)
39037602 A	126	self.threads_ids_list.append(unsigned(thval.thread_id))
	127
	128	def getRegisterDataForThread(self, th_id, reg_num):
	129	if th_id not in self.threads:
	130	logging.critical("0x%x thread id is not found in this task")
	131	return ''
	132	if reg_num < 0 or reg_num >= len(self.registerset):
	133	logging.warning("regnum %d is not defined for thread_id 0x%x" % (reg_num, th_id))
	134	return ''
	135	value = self.threads[th_id].getRegisterData(reg_num)
	136	return self.encodeRegisterData(value, bytesize=self.registerset[reg_num]['bitsize']/8)
	137
	138	def getRegisterCombinedDataForThread(self, th_id):
	139	if th_id not in self.threads:
	140	logging.critical("0x%x thread id is not found in this task" % th_id)
	141	return ''
	142	cur_thread = self.threads[th_id]
	143	retval = 'thread:%s;name:%s;' % (self.encodeThreadID(th_id), cur_thread.getName())
	144	pos = 0
	145	for rinfo in self.registerset:
	146	name = rinfo['name']
	147	format = "%02x:%s;"
	148	value = cur_thread.getRegisterValueByName(name)
	149	value_endian_correct_str = self.encodeRegisterData(value, bytesize=(rinfo['bitsize']/8))
	150	retval += format % (pos, value_endian_correct_str)
	151	pos += 1
	152	return retval
	153
	154	def getThreadStopInfo(self, th_id):
	155	if th_id not in self.threads:
	156	logging.critical("0x%x thread id is not found in this task")
	157	return ''
	158	return 'T02' + self.getRegisterCombinedDataForThread(th_id) + 'threads:' + self.getThreadsInfo()+';'
	159
	160	def getRegisterInfo(self, regnum):
	161	#something similar to
	162	#"name:x1;bitsize:64;offset:8;encoding:uint;format:hex;gcc:1;dwarf:1;set:General Purpose Registers;"
	163	if regnum > len(self.registerset):
	164	logging.debug("No register_info for number %d." % regnum)
	165	return 'E45'
	166
	167	rinfo = self.registerset[regnum]
	168	retval = ''
	169	for i in rinfo.keys():
	170	i_val = str(rinfo[i])
	171	if i == 'set':
	172	i_val = 'General Purpose Registers'
	173	retval += '%s:%s;' % (str(i), i_val)
	174
	175	return retval
	176
	177	def getProcessInfo(self):
	178	retval = ''
	179	#pid:d22c;parent-pid:d34d;real-uid:ecf;real-gid:b;effective-uid:ecf;effective-gid:b;cputype:1000007;cpusubtype:3;
	180	#ostype:macosx;vendor:apple;endian:little;ptrsize:8;
	181	pinfo = {'effective-uid': 'ecf', 'effective-gid': 'b', 'endian': 'little', 'vendor': 'apple'}
	182	pinfo['pid'] = "%x" % (GetProcPIDForTask(self.task))
	183	pinfo['parent-pid'] = "%x" % (unsigned(self.proc.p_ppid))
	184	pinfo['ptrsize'] = str(self.ptrsize)
	185	pinfo['ostype'] = 'macosx'
	186	pinfo['cputype'] = "%x" % self.cputype
	187	pinfo['cpusubtype'] = "%x" % self.cpusubtype
	188	pinfo['real-uid'] = "%x" % (unsigned(self.proc.p_ruid))
	189	pinfo['real-gid'] = "%x" % (unsigned(self.proc.p_rgid))
190	if str(kern.arch).find('arm') >= 0:
191	pinfo['ostype'] = 'ios'
192	for i in pinfo.keys():
193	i_val = str(pinfo[i])
194	retval += '%s:%s;' % (str(i), i_val)
195	return retval
196
197	def readMemory(self, address, size):
198	data = GetUserDataAsString(self.task, address, size)
199	if not data:
200	logging.error("Failed to read memory task:{: <#018x} {: <#018x} {:d}".format(self.task, address, size))
201	return self.encodeByteString(data)
202
203	def getSharedLibInfoAddress(self):
204	return unsigned(self.task.all_image_info_addr)