[apple/libpthread.git] / lldbmacros / init.py

from xnu import *
import struct

def GetSeqCount(seq):
	return (seq >> 8)

def GetLSeqBits(seq):
	rv = ""
	if seq & 0x1:
		rv += "K"
	if seq & 0x2:
		rv += "E"
	if seq & 0x4:
		rv += "W"
	if seq & 0x20:
		rv += "M"
	if seq & 0x40:
		rv += "U"
	if seq & 0x80:
		rv += "I"
	return rv

def GetSSeqBits(seq):
	rv = ""
	if seq & 0x1:
		rv += "S"
	if seq & 0x2:
		rv += "I"
	if seq & 0x4:
		rv += "Ws"
	return rv

def GetLSeqSummary(seq):
	return "{:d} {:s}".format(GetSeqCount(seq), GetLSeqBits(seq))

def GetSSeqSummary(seq):
	return "{:d} {:s}".format(GetSeqCount(seq), GetSSeqBits(seq))

@header("{0: <24s} {1: <16s} {2: <16s} {3: <16s} {4: <16s}".format('sig', 'tid', 'options', 'lseq', 'useq'))
def GetUserMutexSummary(task, uaddr):
	if int(task.t_flags) & 0x1:
		mtxlayout = "QIIhhIQIII"
		padoffset = 1
	else:
		mtxlayout = "QIIhhQIII"
		padoffset = 0

	data = GetUserDataAsString(task, unsigned(uaddr), struct.calcsize(mtxlayout))
	info = struct.unpack(mtxlayout, data)

	format = "{0: <24s} {1: <16s} {2: <16s} {3: <16s} {4: <16s}"
	sigstr = str("{0: <#020x}".format(info[0]))

	# the options field dictates whether we were created misaligned
	if info[2] & 0x800:
		lseq = info[7+padoffset]
		useq = info[8+padoffset]
	else:
		lseq = info[6+padoffset]
		useq = info[7+padoffset]

	return format.format(sigstr, hex(info[5+padoffset]), hex(info[2]), hex(lseq), hex(useq))

@lldb_command('showusermutex')
def PthreadShowUserMutex(cmd_args=None):
	"""
	display information about a userspace mutex at a given address
	Syntax: (lldb) showusermutex <task_t> <uaddr>
	"""
	if not cmd_args:
		raise ArgumentError("No arguments passed")
	task = kern.GetValueFromAddress(cmd_args[0], "task_t")
	uaddr = kern.GetValueFromAddress(cmd_args[1], "user_addr_t")

	print GetUserMutexSummary.header
	print GetUserMutexSummary(task, uaddr)

@lldb_type_summary(['ksyn_wait_queue *', 'ksyn_wait_queue_t'])
@header("{:<20s} {:<20s} {:<10s} {:<6s} {:<6s} {:<8s} {:<8s} {:<8s} {:<8s}".format('kwq', 'uaddr', 'type', 'pflags', 'kflags', 'refs', 'indrop', 'waiters', 'preposts'))
def GetKwqSummary(kwq):
	format = "{:<#20x} {:<#20x} {:<10s} {:<6s} {:<6s} {:<8d} {:<8d} {:<8d} {:<8d}\n"
	kwq = Cast(kwq, "ksyn_wait_queue_t")

	kwqtype = ""
	if kwq.kw_type & 0xff == 0x01:
		kwqtype = "mtx"
	if kwq.kw_type & 0xff == 0x02:
		kwqtype = "cvar"
	if kwq.kw_type & 0xff == 0x04:
		kwqtype = "rwl"
	if kwq.kw_type & 0xff == 0x05:
		kwqtype = "sema"

	if kwq.kw_type & 0x1000 == 0x1000:
		kwqtype += "W" # INWAIT
	if kwq.kw_type & 0x2000 == 0x2000:
		kwqtype += "D" # INDROP

	pflags = ""
	if kwq.kw_pflags & 0x2:
		pflags += "H" # INHASH
	if kwq.kw_pflags & 0x4:
		pflags += "S" # SHARED
	if kwq.kw_pflags & 0x8:
		pflags += "W" # WAITING
	if kwq.kw_pflags & 0x10:
		pflags += "F" # FREELIST

	kflags = ""
	if kwq.kw_kflags & 0x1:
		kflags += "C" # INITCLEARED
	if kwq.kw_kflags & 0x2:
		kflags += "Z" # ZEROED
	if kwq.kw_kflags & 0x4:
		kflags += "Q" # QOS APPLIED
	if kwq.kw_kflags & 0x8:
		kflags += "O" # OVERLAP

	rs = format.format(kwq, kwq.kw_addr, kwqtype, pflags, kflags, kwq.kw_iocount, kwq.kw_dropcount, kwq.kw_inqueue, kwq.kw_fakecount)

	rs += "\t{:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s}\n".format('lowest', 'highest', 'lword', 'uword', 'sword', 'last', 'next')
	rs += "\t{:<10d} {:<10d} {:<10s} {:<10d} {:<10s} {:<10s} {:<10s}\n".format(
			GetSeqCount(kwq.kw_lowseq), GetSeqCount(kwq.kw_highseq),
			GetLSeqSummary(kwq.kw_lword), GetSeqCount(kwq.kw_uword),
			GetSSeqSummary(kwq.kw_sword), GetSSeqSummary(kwq.kw_lastseqword),
			GetSSeqSummary(kwq.kw_nextseqword))

	rs += "\t{:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s}\n".format(
			'pposts', 'lseq', 'sseq', 'intr', 'count', 'seq', 'bits')

	intr_type = "NONE"
	if kwq.kw_intr.type == 0x1:
		intr_type = "READ"
	elif kwq.kw_intr.type == 0x2:
		intr_type = "WRITE"

	rs += "\t{:<10d} {:<10s} {:<10s} {:<10s} {:<10d} {:<10s} {:<10s}\n".format(
			kwq.kw_prepost.count,
			GetLSeqSummary(kwq.kw_prepost.lseq), GetSSeqSummary(kwq.kw_prepost.sseq),
			intr_type, kwq.kw_intr.count,
			GetSSeqSummary(kwq.kw_intr.seq), GetSSeqSummary(kwq.kw_intr.returnbits))

	rs += "\twaiting readers:\n"
	for kwe in IterateTAILQ_HEAD(kwq.kw_ksynqueues[0].ksynq_kwelist, 'kwe_list'):
		rs += "\t" + GetKweSummary.header + "\n"
		rs += "\t" + GetKweSummary(kwe) + "\n"

	rs += "\twaiting writers:\n"
	for kwe in IterateTAILQ_HEAD(kwq.kw_ksynqueues[1].ksynq_kwelist, 'kwe_list'):
		rs += "\t" + GetKweSummary.header + "\n"
		rs += "\t" + GetKweSummary(kwe) + "\n"

	if kwq.kw_turnstile:
		rs += GetTurnstileSummary.header + "\n"
		rs += GetTurnstileSummary(Cast(kwq.kw_turnstile, "struct turnstile *"))

	return rs

@lldb_type_summary(['ksyn_waitq_element *', 'ksyn_waitq_element_t'])
@header("{:<20s} {:<20s} {:<10s} {:<10s} {:<20s} {:<20s}".format('kwe', 'kwq', 'lseq', 'state', 'uthread', 'thread'))
def GetKweSummary(kwe):
	format = "{:<#20x} {:<#20x} {:<10s} {:<10s} {:<#20x} {:<#20x}"
	kwe = Cast(kwe, 'struct ksyn_waitq_element *')
	state = ""
	if kwe.kwe_state == 1:
		state = "INWAIT"
	elif kwe.kwe_state == 2:
		state = "PPOST"
	elif kwe.kwe_state == 3:
		state = "BROAD"
	else:
		state = "{:#10x}".format(kwe.kwe_state)
	return format.format(kwe, kwe.kwe_kwqqueue, GetLSeqSummary(kwe.kwe_lockseq), state, kwe.kwe_uth, kwe.kwe_thread)

@header("{0: <24s} {1: <24s} {2: <24s}".format('thread', 'thread_id', 'uthread'))
def GetPthreadSummary(thread):
	format = "{0: <24s} {1: <24s} {2: <24s}"

	threadstr = str("{0: <#020x}".format(thread))
	if int(thread.static_param):
		threadstr += "[WQ]"

	uthread = Cast(thread.uthread, "uthread_t")
	uthreadstr = str("{0: <#020x}".format(uthread))


	return format.format(threadstr, hex(thread.thread_id), uthreadstr)

@header("{0: <24s} {1: <24s} {2: <10s} {3: <10s} {4: <10s} {5: <10s} {6: <10s}".format('proc', 'wq', 'sched', 'req', 'idle', 'wq_flags', 'wq_lflags'))
def GetPthreadWorkqueueSummary(wq):
	format = "{0: <24s} {1: <24s} {2: <10d} {3: <10d} {4: <10d} {5: <10s} {6: <10s}"
	procstr = str("{0: <#020x}".format(wq.wq_proc))
	wqstr = str("{0: <#020x}".format(wq))
	
	flags = []
	if wq.wq_flags & 0x1:
		flags.append("I")
	if wq.wq_flags & 0x2:
		flags.append("R")
	if wq.wq_flags & 0x4:
		flags.append("E")
		
	wqflags = []
	if wq.wq_lflags & 0x1:
		wqflags.append("B")
	if wq.wq_lflags & 0x2:
		wqflags.append("W")
	if wq.wq_lflags & 0x4:
		wqflags.append("C")
	if wq.wq_lflags & 0x8:
		wqflags.append("L")
	
	return format.format(procstr, wqstr, wq.wq_threads_scheduled, wq.wq_reqcount, wq.wq_thidlecount, "".join(flags), "".join(wqflags))

@header("{0: <24s} {1: <5s} {2: <5s} {3: <5s} {4: <5s} {5: <5s} {6: <5s} {7: <5s}".format('category', 'uint', 'uinit', 'lgcy', 'util', 'bckgd', 'maint', 'event'))
def GetPthreadWorkqueueDetail(wq):
	format = "  {0: <22s} {1: <5d} {2: <5d} {3: <5d} {4: <5d} {5: <5d} {6: <5d} {7: <5d}"
	# requests
	schedstr = format.format('scheduled', wq.wq_thscheduled_count[0], wq.wq_thscheduled_count[1], wq.wq_thscheduled_count[2], wq.wq_thscheduled_count[3], wq.wq_thscheduled_count[4], wq.wq_thscheduled_count[5], wq.wq_thscheduled_count[6])
	activestr = format.format('active', wq.wq_thactive_count[0], wq.wq_thactive_count[1], wq.wq_thactive_count[2], wq.wq_thactive_count[3], wq.wq_thactive_count[4], wq.wq_thactive_count[5], wq.wq_thactive_count[6])
	return "\n".join([schedstr, activestr])

@lldb_command('showthreadpsynch')
def PthreadCurrentMutex(cmd_args=None):
	"""
	display information about a thread's pthread state
	Syntax: (lldb) showthreadpsync <thread_t>
	"""
	if not cmd_args:
		raise ArgumentError("No arguments passed")

	thread = kern.GetValueFromAddress(cmd_args[0], "thread_t")
	print GetPthreadSummary.header
	print GetPthreadSummary(thread)

	uthread = Cast(thread.uthread, "uthread_t")
	kwe = Cast(addressof(uthread.uu_save.uus_kwe), 'struct ksyn_waitq_element *')
	if not kwe or not kwe.kwe_kwqqueue:
		print GetKweSummary.header
		print GetKweSummary(kwe)
	else:
		print GetKwqSummary.header
		print GetKwqSummary(kwe.kwe_kwqqueue)

@lldb_command('showpthreadkwq')
def PthreadShowKsynQueue(cmd_args=None):
	"""
	display information about a pthread ksyn_wait_queue_t
	Syntax: (lldb) showpthreadkwq <ksyn_wait_queue_t>
	"""
	if not cmd_args:
		raise ArgumentError("No arguments passed")

	kwq = kern.GetValueFromAddress(cmd_args[0], "ksyn_wait_queue_t")
	print GetKwqSummary.header
	print GetKwqSummary(kwq)

@lldb_command('showpthreadkwe')
def PthreadShowKsynElement(cmd_args=None):
	"""
	display information about a thread's ksyn_waitq_element
	Syntax: (lldb) showpthreadkwe <ksyn_waitq_element_t>	
	"""
	if not cmd_args:
		raise ArgumentError("No arguments passed")

	kwe = kern.GetValueFromAddress(cmd_args[0], "struct ksyn_waitq_element *")
	print GetKweSummary.header
	print GetKweSummary(kwe)

@lldb_command('showpthreadworkqueue')
def ShowPthreadWorkqueue(cmd_args=None):
	"""
	display information about a processes' pthread workqueue
	Syntax: (lldb) showpthreadworkqueue <proc_t>
	"""
	
	if not cmd_args:
		raise ArgumentError("No arguments passed")
		
	proc = kern.GetValueFromAddress(cmd_args[0], "proc_t")
	wq = Cast(proc.p_wqptr, "struct workqueue *");
	
	print GetPthreadWorkqueueSummary.header
	print GetPthreadWorkqueueSummary(wq)
	
	print GetPthreadWorkqueueDetail.header
	print GetPthreadWorkqueueDetail(wq)

def IterateTAILQ_HEAD(headval, element_name):
    """ iterate over a TAILQ_HEAD in kernel. refer to bsd/sys/queue.h
        params:
            headval     - value : value object representing the head of the list
            element_name- str          :  string name of the field which holds the list links.
        returns:
            A generator does not return. It is used for iterating.
            value : an object that is of type as headval->tqh_first. Always a pointer object
        example usage:
          list_head = kern.GetGlobalVariable('mountlist')
          for entryobj in IterateTAILQ_HEAD(list_head, 'mnt_list'):
            print GetEntrySummary(entryobj)
    """
    iter_val = headval.tqh_first
    while unsigned(iter_val) != 0 :
        yield iter_val
        iter_val = iter_val.__getattr__(element_name).tqe_next
    #end of yield loop

def __lldb_init_module(debugger, internal_dict):
	pass
Commit	Line	Data
214d78a2 A	1	from xnu import *
	2	import struct
	3
	4	def GetSeqCount(seq):
	5	return (seq >> 8)
	6
	7	def GetLSeqBits(seq):
	8	rv = ""
	9	if seq & 0x1:
	10	rv += "K"
	11	if seq & 0x2:
	12	rv += "E"
	13	if seq & 0x4:
	14	rv += "W"
	15	if seq & 0x20:
	16	rv += "M"
	17	if seq & 0x40:
	18	rv += "U"
	19	if seq & 0x80:
	20	rv += "I"
	21	return rv
	22
	23	def GetSSeqBits(seq):
	24	rv = ""
	25	if seq & 0x1:
	26	rv += "S"
	27	if seq & 0x2:
	28	rv += "I"
	29	if seq & 0x4:
	30	rv += "Ws"
	31	return rv
	32
	33	def GetLSeqSummary(seq):
	34	return "{:d} {:s}".format(GetSeqCount(seq), GetLSeqBits(seq))
	35
	36	def GetSSeqSummary(seq):
	37	return "{:d} {:s}".format(GetSeqCount(seq), GetSSeqBits(seq))
	38
	39	@header("{0: <24s} {1: <16s} {2: <16s} {3: <16s} {4: <16s}".format('sig', 'tid', 'options', 'lseq', 'useq'))
	40	def GetUserMutexSummary(task, uaddr):
	41	if int(task.t_flags) & 0x1:
	42	mtxlayout = "QIIhhIQIII"
	43	padoffset = 1
	44	else:
	45	mtxlayout = "QIIhhQIII"
	46	padoffset = 0
	47
	48	data = GetUserDataAsString(task, unsigned(uaddr), struct.calcsize(mtxlayout))
	49	info = struct.unpack(mtxlayout, data)
	50
	51	format = "{0: <24s} {1: <16s} {2: <16s} {3: <16s} {4: <16s}"
	52	sigstr = str("{0: <#020x}".format(info[0]))
	53
	54	# the options field dictates whether we were created misaligned
	55	if info[2] & 0x800:
	56	lseq = info[7+padoffset]
	57	useq = info[8+padoffset]
	58	else:
	59	lseq = info[6+padoffset]
	60	useq = info[7+padoffset]
	61
	62	return format.format(sigstr, hex(info[5+padoffset]), hex(info[2]), hex(lseq), hex(useq))
	63
	64	@lldb_command('showusermutex')
65	def PthreadShowUserMutex(cmd_args=None):
66	"""
67	display information about a userspace mutex at a given address
68	Syntax: (lldb) showusermutex <task_t> <uaddr>
69	"""
70	if not cmd_args:
71	raise ArgumentError("No arguments passed")
72	task = kern.GetValueFromAddress(cmd_args[0], "task_t")
73	uaddr = kern.GetValueFromAddress(cmd_args[1], "user_addr_t")
74
75	print GetUserMutexSummary.header
76	print GetUserMutexSummary(task, uaddr)
77
78	@lldb_type_summary(['ksyn_wait_queue *', 'ksyn_wait_queue_t'])
79	@header("{:<20s} {:<20s} {:<10s} {:<6s} {:<6s} {:<8s} {:<8s} {:<8s} {:<8s}".format('kwq', 'uaddr', 'type', 'pflags', 'kflags', 'refs', 'indrop', 'waiters', 'preposts'))
80	def GetKwqSummary(kwq):
81	format = "{:<#20x} {:<#20x} {:<10s} {:<6s} {:<6s} {:<8d} {:<8d} {:<8d} {:<8d}\n"
82	kwq = Cast(kwq, "ksyn_wait_queue_t")
83
84	kwqtype = ""
85	if kwq.kw_type & 0xff == 0x01:
86	kwqtype = "mtx"
87	if kwq.kw_type & 0xff == 0x02:
88	kwqtype = "cvar"
89	if kwq.kw_type & 0xff == 0x04:
90	kwqtype = "rwl"
91	if kwq.kw_type & 0xff == 0x05:
92	kwqtype = "sema"
93
94	if kwq.kw_type & 0x1000 == 0x1000:
95	kwqtype += "W" # INWAIT
96	if kwq.kw_type & 0x2000 == 0x2000:
97	kwqtype += "D" # INDROP
98
99	pflags = ""
100	if kwq.kw_pflags & 0x2:
101	pflags += "H" # INHASH
102	if kwq.kw_pflags & 0x4:
103	pflags += "S" # SHARED
104	if kwq.kw_pflags & 0x8:
105	pflags += "W" # WAITING
106	if kwq.kw_pflags & 0x10:
107	pflags += "F" # FREELIST
108
109	kflags = ""
110	if kwq.kw_kflags & 0x1:
111	kflags += "C" # INITCLEARED
112	if kwq.kw_kflags & 0x2:
113	kflags += "Z" # ZEROED
114	if kwq.kw_kflags & 0x4:
115	kflags += "Q" # QOS APPLIED
116	if kwq.kw_kflags & 0x8:
117	kflags += "O" # OVERLAP
118
119	rs = format.format(kwq, kwq.kw_addr, kwqtype, pflags, kflags, kwq.kw_iocount, kwq.kw_dropcount, kwq.kw_inqueue, kwq.kw_fakecount)
120
121	rs += "\t{:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s}\n".format('lowest', 'highest', 'lword', 'uword', 'sword', 'last', 'next')
122	rs += "\t{:<10d} {:<10d} {:<10s} {:<10d} {:<10s} {:<10s} {:<10s}\n".format(
123	GetSeqCount(kwq.kw_lowseq), GetSeqCount(kwq.kw_highseq),
124	GetLSeqSummary(kwq.kw_lword), GetSeqCount(kwq.kw_uword),
125	GetSSeqSummary(kwq.kw_sword), GetSSeqSummary(kwq.kw_lastseqword),
126	GetSSeqSummary(kwq.kw_nextseqword))
127
128	rs += "\t{:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s}\n".format(
129	'pposts', 'lseq', 'sseq', 'intr', 'count', 'seq', 'bits')
130
131	intr_type = "NONE"
132	if kwq.kw_intr.type == 0x1:
133	intr_type = "READ"
134	elif kwq.kw_intr.type == 0x2:
135	intr_type = "WRITE"
136
137	rs += "\t{:<10d} {:<10s} {:<10s} {:<10s} {:<10d} {:<10s} {:<10s}\n".format(
138	kwq.kw_prepost.count,
139	GetLSeqSummary(kwq.kw_prepost.lseq), GetSSeqSummary(kwq.kw_prepost.sseq),
140	intr_type, kwq.kw_intr.count,
141	GetSSeqSummary(kwq.kw_intr.seq), GetSSeqSummary(kwq.kw_intr.returnbits))
142
143	rs += "\twaiting readers:\n"
144	for kwe in IterateTAILQ_HEAD(kwq.kw_ksynqueues[0].ksynq_kwelist, 'kwe_list'):
145	rs += "\t" + GetKweSummary.header + "\n"
146	rs += "\t" + GetKweSummary(kwe) + "\n"
147
148	rs += "\twaiting writers:\n"
149	for kwe in IterateTAILQ_HEAD(kwq.kw_ksynqueues[1].ksynq_kwelist, 'kwe_list'):
150	rs += "\t" + GetKweSummary.header + "\n"
151	rs += "\t" + GetKweSummary(kwe) + "\n"
152
153	if kwq.kw_turnstile:
154	rs += GetTurnstileSummary.header + "\n"
155	rs += GetTurnstileSummary(Cast(kwq.kw_turnstile, "struct turnstile *"))
156
157	return rs
158
159	@lldb_type_summary(['ksyn_waitq_element *', 'ksyn_waitq_element_t'])
160	@header("{:<20s} {:<20s} {:<10s} {:<10s} {:<20s} {:<20s}".format('kwe', 'kwq', 'lseq', 'state', 'uthread', 'thread'))
161	def GetKweSummary(kwe):
162	format = "{:<#20x} {:<#20x} {:<10s} {:<10s} {:<#20x} {:<#20x}"
163	kwe = Cast(kwe, 'struct ksyn_waitq_element *')
164	state = ""
165	if kwe.kwe_state == 1:
166	state = "INWAIT"
167	elif kwe.kwe_state == 2:
168	state = "PPOST"
169	elif kwe.kwe_state == 3:
170	state = "BROAD"
171	else:
172	state = "{:#10x}".format(kwe.kwe_state)
173	return format.format(kwe, kwe.kwe_kwqqueue, GetLSeqSummary(kwe.kwe_lockseq), state, kwe.kwe_uth, kwe.kwe_thread)
174
175	@header("{0: <24s} {1: <24s} {2: <24s}".format('thread', 'thread_id', 'uthread'))
176	def GetPthreadSummary(thread):
177	format = "{0: <24s} {1: <24s} {2: <24s}"
178
179	threadstr = str("{0: <#020x}".format(thread))
180	if int(thread.static_param):
181	threadstr += "[WQ]"
182
183	uthread = Cast(thread.uthread, "uthread_t")
184	uthreadstr = str("{0: <#020x}".format(uthread))
185
186
187	return format.format(threadstr, hex(thread.thread_id), uthreadstr)
188
189	@header("{0: <24s} {1: <24s} {2: <10s} {3: <10s} {4: <10s} {5: <10s} {6: <10s}".format('proc', 'wq', 'sched', 'req', 'idle', 'wq_flags', 'wq_lflags'))
190	def GetPthreadWorkqueueSummary(wq):
191	format = "{0: <24s} {1: <24s} {2: <10d} {3: <10d} {4: <10d} {5: <10s} {6: <10s}"
192	procstr = str("{0: <#020x}".format(wq.wq_proc))
193	wqstr = str("{0: <#020x}".format(wq))
194
195	flags = []
196	if wq.wq_flags & 0x1:
197	flags.append("I")
198	if wq.wq_flags & 0x2:
199	flags.append("R")
200	if wq.wq_flags & 0x4:
201	flags.append("E")
202
203	wqflags = []
204	if wq.wq_lflags & 0x1:
205	wqflags.append("B")
206	if wq.wq_lflags & 0x2:
207	wqflags.append("W")
208	if wq.wq_lflags & 0x4:
209	wqflags.append("C")
210	if wq.wq_lflags & 0x8:
211	wqflags.append("L")
212
213	return format.format(procstr, wqstr, wq.wq_threads_scheduled, wq.wq_reqcount, wq.wq_thidlecount, "".join(flags), "".join(wqflags))
214
215	@header("{0: <24s} {1: <5s} {2: <5s} {3: <5s} {4: <5s} {5: <5s} {6: <5s} {7: <5s}".format('category', 'uint', 'uinit', 'lgcy', 'util', 'bckgd', 'maint', 'event'))
216	def GetPthreadWorkqueueDetail(wq):
217	format = " {0: <22s} {1: <5d} {2: <5d} {3: <5d} {4: <5d} {5: <5d} {6: <5d} {7: <5d}"
218	# requests
219	schedstr = format.format('scheduled', wq.wq_thscheduled_count[0], wq.wq_thscheduled_count[1], wq.wq_thscheduled_count[2], wq.wq_thscheduled_count[3], wq.wq_thscheduled_count[4], wq.wq_thscheduled_count[5], wq.wq_thscheduled_count[6])
220	activestr = format.format('active', wq.wq_thactive_count[0], wq.wq_thactive_count[1], wq.wq_thactive_count[2], wq.wq_thactive_count[3], wq.wq_thactive_count[4], wq.wq_thactive_count[5], wq.wq_thactive_count[6])
221	return "\n".join([schedstr, activestr])
222
223	@lldb_command('showthreadpsynch')
224	def PthreadCurrentMutex(cmd_args=None):
225	"""
226	display information about a thread's pthread state
227	Syntax: (lldb) showthreadpsync <thread_t>
228	"""
229	if not cmd_args:
230	raise ArgumentError("No arguments passed")
231
232	thread = kern.GetValueFromAddress(cmd_args[0], "thread_t")
233	print GetPthreadSummary.header
234	print GetPthreadSummary(thread)
235
236	uthread = Cast(thread.uthread, "uthread_t")
237	kwe = Cast(addressof(uthread.uu_save.uus_kwe), 'struct ksyn_waitq_element *')
238	if not kwe or not kwe.kwe_kwqqueue:
239	print GetKweSummary.header
240	print GetKweSummary(kwe)
241	else:
242	print GetKwqSummary.header
243	print GetKwqSummary(kwe.kwe_kwqqueue)
244
245	@lldb_command('showpthreadkwq')
246	def PthreadShowKsynQueue(cmd_args=None):
247	"""
248	display information about a pthread ksyn_wait_queue_t
249	Syntax: (lldb) showpthreadkwq <ksyn_wait_queue_t>
250	"""
251	if not cmd_args:
252	raise ArgumentError("No arguments passed")
253
254	kwq = kern.GetValueFromAddress(cmd_args[0], "ksyn_wait_queue_t")
255	print GetKwqSummary.header
256	print GetKwqSummary(kwq)
257
258	@lldb_command('showpthreadkwe')
259	def PthreadShowKsynElement(cmd_args=None):
260	"""
261	display information about a thread's ksyn_waitq_element
262	Syntax: (lldb) showpthreadkwe <ksyn_waitq_element_t>
263	"""
264	if not cmd_args:
265	raise ArgumentError("No arguments passed")
266
267	kwe = kern.GetValueFromAddress(cmd_args[0], "struct ksyn_waitq_element *")
268	print GetKweSummary.header
269	print GetKweSummary(kwe)
270
271	@lldb_command('showpthreadworkqueue')
272	def ShowPthreadWorkqueue(cmd_args=None):
273	"""
274	display information about a processes' pthread workqueue
275	Syntax: (lldb) showpthreadworkqueue <proc_t>
276	"""
277
278	if not cmd_args:
279	raise ArgumentError("No arguments passed")
280
281	proc = kern.GetValueFromAddress(cmd_args[0], "proc_t")
282	wq = Cast(proc.p_wqptr, "struct workqueue *");
283
284	print GetPthreadWorkqueueSummary.header
285	print GetPthreadWorkqueueSummary(wq)
286
287	print GetPthreadWorkqueueDetail.header
288	print GetPthreadWorkqueueDetail(wq)
289
290	def IterateTAILQ_HEAD(headval, element_name):
291	""" iterate over a TAILQ_HEAD in kernel. refer to bsd/sys/queue.h
292	params:
293	headval - value : value object representing the head of the list
294	element_name- str : string name of the field which holds the list links.
295	returns:
296	A generator does not return. It is used for iterating.
297	value : an object that is of type as headval->tqh_first. Always a pointer object
298	example usage:
299	list_head = kern.GetGlobalVariable('mountlist')
300	for entryobj in IterateTAILQ_HEAD(list_head, 'mnt_list'):
301	print GetEntrySummary(entryobj)
302	"""
303	iter_val = headval.tqh_first
304	while unsigned(iter_val) != 0 :
305	yield iter_val
306	iter_val = iter_val.__getattr__(element_name).tqe_next
307	#end of yield loop
308
309	def __lldb_init_module(debugger, internal_dict):
310	pass