[apple/xnu.git] / tools / lldbmacros / workqueue.py

from xnu import *
from scheduler import GetRecentTimestamp
import xnudefines

def GetProcWorkqueue(proc):
    wq = proc.p_wqptr;
    if unsigned(wq):
        return Cast(wq, "struct workqueue *");
    return None

@header("{:<20s} {:<20s} {:<20s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<30s}".format(
    'task', 'proc', 'wq', 'sched', 'pending', 'idle', 'dying', 'creations', 'fulfilled', 'wq_flags'))
def GetWorkqueueSummary(proc, wq):
    wq_flags = []
    if wq.wq_flags & GetEnumValue("workq_state_flags_t::WQ_EXITING"):
        wq_flags.append("EXITING")
    if wq.wq_flags & GetEnumValue("workq_state_flags_t::WQ_PROC_SUSPENDED"):
        wq_flags.append("PROC_SUSPENDED")
    if wq.wq_flags & GetEnumValue("workq_state_flags_t::WQ_DEATH_CALL_SCHEDULED"):
        wq_flags.append("DEATH_CALL")

    scheduled = GetEnumValue("workq_state_flags_t::WQ_DELAYED_CALL_SCHEDULED")
    pended = GetEnumValue("workq_state_flags_t::WQ_DELAYED_CALL_PENDED")
    if wq.wq_flags & (scheduled | pended):
        s = "DELAYED_CALL["
        if wq.wq_flags & scheduled: s += 'S'
        if wq.wq_flags & pended: s += 'P'
        s += ']'
        wq_flags.append(s)

    scheduled = GetEnumValue("workq_state_flags_t::WQ_IMMEDIATE_CALL_SCHEDULED")
    pended = GetEnumValue("workq_state_flags_t::WQ_IMMEDIATE_CALL_PENDED")
    if wq.wq_flags & (scheduled | pended):
        s = "IMMEDIATE_CALL["
        if wq.wq_flags & scheduled: s += 'S'
        if wq.wq_flags & pended: s += 'P'
        s += ']'
        wq_flags.append(s)

    return "{p.task: <#020x} {p: <#020x} {wq: <#020x} {wq.wq_threads_scheduled: <10d} {wq.wq_reqcount: <10d} {wq.wq_thidlecount: <10d} {wq.wq_thdying_count: <10d} {wq.wq_creations: <10d} {wq.wq_fulfilled: <10d} {wq_flags: <30s}".format(p=proc, wq=wq, wq_flags=" ".join(wq_flags));

@header("{:<20s} {:<20s} {:>10s}  {:9s} {:<20s} {:<10s} {:<30s}".format(
    'thread', 'uthread', 'thport', 'kind', 'kqueue', 'idle (ms)', 'uu_workq_flags'))
def GetWQThreadSummary(th, uth):
    p = Cast(th.task.bsd_info, 'proc *')
    wq = p.p_wqptr

    uu_workq_flags = []
    if uth.uu_workq_flags & 0x01: uu_workq_flags.append("NEW")
    if uth.uu_workq_flags & 0x02:
        uu_workq_flags.append("RUNNING")
        if wq.wq_creator == uth:
            kind = "creator"
        else:
            kind = "workq"
        idle = ""
    else:
        ts = kern.GetNanotimeFromAbstime(GetRecentTimestamp() - uth.uu_save.uus_workq_park_data.idle_stamp) / 1e9
        kind = "idle"
        idle = "%#.03f" % (ts)
    if uth.uu_workq_flags & 0x04: uu_workq_flags.append("DYING")
    if uth.uu_workq_flags & 0x08: uu_workq_flags.append("OVERCOMMIT")
    if uth.uu_workq_flags & 0x10: uu_workq_flags.append("OUTSIDE_QOS")
    if uth.uu_workq_flags & 0x20: uu_workq_flags.append("IDLE_CLEANUP")
    if uth.uu_workq_flags & 0x40: uu_workq_flags.append("EARLY_BOUND")
    if uth.uu_workq_flags & 0x80: uu_workq_flags.append("CPU%")

    kqr = uth.uu_kqr_bound
    if not kqr:
        kq = 0
    elif kqr.kqr_state & 0x1: # workloop
        kq = ContainerOf(kqr, 'struct kqworkloop', 'kqwl_request')
        kind = "workloop"
    else:
        kq = p.p_fd.fd_wqkqueue
        kind = "kqwq[%s]" % (xnudefines.thread_qos_short_strings[int(kqr.kqr_qos_index)])

    return "{th: <#020x} {uth: <#020x} {thport: >#010x}  {kind: <9s} {kq: <#020x} {idle: <10s} {uu_workq_flags: <30s}".format(th=th, uth=uth, thport=uth.uu_workq_thport, kind=kind, kq=kq, idle=idle, uu_workq_flags=" ".join(uu_workq_flags))

@header("{:<20s} {:<20s} {:<10s} {:<3s} {:<4s} {:<30s}".format(
    'request', 'kqueue', 'state', '#', 'qos', 'tr_flags'))
def GetWorkqueueThreadRequestSummary(proc, req):
    kq = 0
    tr_flags = []

    if req.tr_flags & 0x01:
        tr_flags.append("KEVENT")
        kq = proc.p_fd.fd_wqkqueue
    if req.tr_flags & 0x02:
        tr_flags.append("WORKLOOP")
        kq = ContainerOf(req, 'struct kqworkloop', 'kqwl_request.kqr_req')
    if req.tr_flags & 0x04: tr_flags.append("OVERCOMMIT")
    if req.tr_flags & 0x08: tr_flags.append("PARAMS")
    if req.tr_flags & 0x10: tr_flags.append("OUTSIDE_QOS")

    state = {0: "IDLE", 1: "NEW", 2: "QUEUED", 4: "BINDING" }[int(req.tr_state)]

    qos = int(req.tr_qos)
    if qos == 8:
        qos = "MG"
    elif qos == 7:
        qos = "SP"
    else:
        qos = xnudefines.thread_qos_short_strings[qos]

    return "{req: <#020x} {kq: <#020x} {state: <10s} {req.tr_count: <3d} {qos: <4s} {tr_flags: <30s}".format(req=req, kq=kq, state=state, qos=qos, tr_flags=" ".join(tr_flags))

@lldb_command('showwqthread')
def ShowWQThread(cmd_args=None):
    """ Shows info about a workqueue thread

        usage: showworkqthread <thread_t>
    """

    if not cmd_args:
        raise ArgumentError('missing struct proc * argument')

    th = kern.GetValueFromAddress(cmd_args[0], "struct thread *")
    if not (th.thread_tag & 0x20):
        raise ArgumentError('not a workqueue thread')

    print GetWQThreadSummary.header
    print GetWQThreadSummary(th, Cast(th.uthread, 'struct uthread *'))


@lldb_command('showprocworkqueue')
def ShowProcWorkqueue(cmd_args=None):
    """ Shows the process workqueue

        usage: showprocworkqueue <proc_t>
    """

    if not cmd_args:
        raise ArgumentError('missing struct proc * argument')

    proc = kern.GetValueFromAddress(cmd_args[0], "proc_t")
    wq = Cast(proc.p_wqptr, "struct workqueue *");
    if wq:
        print GetWorkqueueSummary.header
        print GetWorkqueueSummary(proc, wq)

        if wq.wq_reqcount:
            print "    "
            print "    " + GetWorkqueueThreadRequestSummary.header
            if wq.wq_event_manager_threadreq:
                print "    " + GetWorkqueueThreadRequestSummary(proc, wq.wq_event_manager_threadreq)
            for req in IteratePriorityQueueEntry(wq.wq_overcommit_queue, 'struct workq_threadreq_s', 'tr_entry'):
                print "    " + GetWorkqueueThreadRequestSummary(proc, req)
            for req in IteratePriorityQueueEntry(wq.wq_constrained_queue, 'struct workq_threadreq_s', 'tr_entry'):
                print "    " + GetWorkqueueThreadRequestSummary(proc, req)
            for req in IteratePriorityQueueEntry(wq.wq_special_queue, 'struct workq_threadreq_s', 'tr_entry'):
                print "    " + GetWorkqueueThreadRequestSummary(proc, req)

        print "    "
        print "    " + GetWQThreadSummary.header
        for uth in IterateTAILQ_HEAD(wq.wq_thrunlist, "uu_workq_entry"):
            print "    " + GetWQThreadSummary(Cast(uth.uu_thread, 'struct thread *'), uth)
        for uth in IterateTAILQ_HEAD(wq.wq_thidlelist, "uu_workq_entry"):
            print "    " + GetWQThreadSummary(Cast(uth.uu_thread, 'struct thread *'), uth)
        for uth in IterateTAILQ_HEAD(wq.wq_thnewlist, "uu_workq_entry"):
            print "    " + GetWQThreadSummary(Cast(uth.uu_thread, 'struct thread *'), uth)

@lldb_command('showallworkqueues')
def ShowAllWorkqueues(cmd_args=None):
    """ Display a summary of all the workqueues in the system

        usage: showallworkqueues
    """

    print GetWorkqueueSummary.header

    for t in kern.tasks:
        proc = Cast(t.bsd_info, 'proc *')
        wq = Cast(proc.p_wqptr, "struct workqueue *");
        if wq:
            print GetWorkqueueSummary(proc, wq)
Commit	Line	Data
d9a64523 A	1	from xnu import *
	2	from scheduler import GetRecentTimestamp
	3	import xnudefines
	4
	5	def GetProcWorkqueue(proc):
	6	wq = proc.p_wqptr;
	7	if unsigned(wq):
	8	return Cast(wq, "struct workqueue *");
	9	return None
	10
	11	@header("{:<20s} {:<20s} {:<20s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<10s} {:<30s}".format(
	12	'task', 'proc', 'wq', 'sched', 'pending', 'idle', 'dying', 'creations', 'fulfilled', 'wq_flags'))
	13	def GetWorkqueueSummary(proc, wq):
	14	wq_flags = []
	15	if wq.wq_flags & GetEnumValue("workq_state_flags_t::WQ_EXITING"):
	16	wq_flags.append("EXITING")
	17	if wq.wq_flags & GetEnumValue("workq_state_flags_t::WQ_PROC_SUSPENDED"):
	18	wq_flags.append("PROC_SUSPENDED")
	19	if wq.wq_flags & GetEnumValue("workq_state_flags_t::WQ_DEATH_CALL_SCHEDULED"):
	20	wq_flags.append("DEATH_CALL")
	21
	22	scheduled = GetEnumValue("workq_state_flags_t::WQ_DELAYED_CALL_SCHEDULED")
	23	pended = GetEnumValue("workq_state_flags_t::WQ_DELAYED_CALL_PENDED")
	24	if wq.wq_flags & (scheduled \| pended):
	25	s = "DELAYED_CALL["
	26	if wq.wq_flags & scheduled: s += 'S'
	27	if wq.wq_flags & pended: s += 'P'
	28	s += ']'
	29	wq_flags.append(s)
	30
	31	scheduled = GetEnumValue("workq_state_flags_t::WQ_IMMEDIATE_CALL_SCHEDULED")
	32	pended = GetEnumValue("workq_state_flags_t::WQ_IMMEDIATE_CALL_PENDED")
	33	if wq.wq_flags & (scheduled \| pended):
	34	s = "IMMEDIATE_CALL["
	35	if wq.wq_flags & scheduled: s += 'S'
	36	if wq.wq_flags & pended: s += 'P'
	37	s += ']'
	38	wq_flags.append(s)
	39
	40	return "{p.task: <#020x} {p: <#020x} {wq: <#020x} {wq.wq_threads_scheduled: <10d} {wq.wq_reqcount: <10d} {wq.wq_thidlecount: <10d} {wq.wq_thdying_count: <10d} {wq.wq_creations: <10d} {wq.wq_fulfilled: <10d} {wq_flags: <30s}".format(p=proc, wq=wq, wq_flags=" ".join(wq_flags));
	41
	42	@header("{:<20s} {:<20s} {:>10s} {:9s} {:<20s} {:<10s} {:<30s}".format(
	43	'thread', 'uthread', 'thport', 'kind', 'kqueue', 'idle (ms)', 'uu_workq_flags'))
	44	def GetWQThreadSummary(th, uth):
	45	p = Cast(th.task.bsd_info, 'proc *')
	46	wq = p.p_wqptr
	47
	48	uu_workq_flags = []
	49	if uth.uu_workq_flags & 0x01: uu_workq_flags.append("NEW")
	50	if uth.uu_workq_flags & 0x02:
	51	uu_workq_flags.append("RUNNING")
	52	if wq.wq_creator == uth:
	53	kind = "creator"
	54	else:
	55	kind = "workq"
	56	idle = ""
	57	else:
	58	ts = kern.GetNanotimeFromAbstime(GetRecentTimestamp() - uth.uu_save.uus_workq_park_data.idle_stamp) / 1e9
	59	kind = "idle"
	60	idle = "%#.03f" % (ts)
	61	if uth.uu_workq_flags & 0x04: uu_workq_flags.append("DYING")
	62	if uth.uu_workq_flags & 0x08: uu_workq_flags.append("OVERCOMMIT")
	63	if uth.uu_workq_flags & 0x10: uu_workq_flags.append("OUTSIDE_QOS")
	64	if uth.uu_workq_flags & 0x20: uu_workq_flags.append("IDLE_CLEANUP")
65	if uth.uu_workq_flags & 0x40: uu_workq_flags.append("EARLY_BOUND")
66	if uth.uu_workq_flags & 0x80: uu_workq_flags.append("CPU%")
67
68	kqr = uth.uu_kqr_bound
69	if not kqr:
70	kq = 0
71	elif kqr.kqr_state & 0x1: # workloop
72	kq = ContainerOf(kqr, 'struct kqworkloop', 'kqwl_request')
73	kind = "workloop"
74	else:
75	kq = p.p_fd.fd_wqkqueue
76	kind = "kqwq[%s]" % (xnudefines.thread_qos_short_strings[int(kqr.kqr_qos_index)])
77
78	return "{th: <#020x} {uth: <#020x} {thport: >#010x} {kind: <9s} {kq: <#020x} {idle: <10s} {uu_workq_flags: <30s}".format(th=th, uth=uth, thport=uth.uu_workq_thport, kind=kind, kq=kq, idle=idle, uu_workq_flags=" ".join(uu_workq_flags))
79
80	@header("{:<20s} {:<20s} {:<10s} {:<3s} {:<4s} {:<30s}".format(
81	'request', 'kqueue', 'state', '#', 'qos', 'tr_flags'))
82	def GetWorkqueueThreadRequestSummary(proc, req):
83	kq = 0
84	tr_flags = []
85
86	if req.tr_flags & 0x01:
87	tr_flags.append("KEVENT")
88	kq = proc.p_fd.fd_wqkqueue
89	if req.tr_flags & 0x02:
90	tr_flags.append("WORKLOOP")
91	kq = ContainerOf(req, 'struct kqworkloop', 'kqwl_request.kqr_req')
92	if req.tr_flags & 0x04: tr_flags.append("OVERCOMMIT")
93	if req.tr_flags & 0x08: tr_flags.append("PARAMS")
94	if req.tr_flags & 0x10: tr_flags.append("OUTSIDE_QOS")
95
96	state = {0: "IDLE", 1: "NEW", 2: "QUEUED", 4: "BINDING" }[int(req.tr_state)]
97
98	qos = int(req.tr_qos)
99	if qos == 8:
100	qos = "MG"
101	elif qos == 7:
102	qos = "SP"
103	else:
104	qos = xnudefines.thread_qos_short_strings[qos]
105
106	return "{req: <#020x} {kq: <#020x} {state: <10s} {req.tr_count: <3d} {qos: <4s} {tr_flags: <30s}".format(req=req, kq=kq, state=state, qos=qos, tr_flags=" ".join(tr_flags))
107
108	@lldb_command('showwqthread')
109	def ShowWQThread(cmd_args=None):
110	""" Shows info about a workqueue thread
111
112	usage: showworkqthread <thread_t>
113	"""
114
115	if not cmd_args:
116	raise ArgumentError('missing struct proc * argument')
117
118	th = kern.GetValueFromAddress(cmd_args[0], "struct thread *")
119	if not (th.thread_tag & 0x20):
120	raise ArgumentError('not a workqueue thread')
121
122	print GetWQThreadSummary.header
123	print GetWQThreadSummary(th, Cast(th.uthread, 'struct uthread *'))
124
125
126	@lldb_command('showprocworkqueue')
127	def ShowProcWorkqueue(cmd_args=None):
128	""" Shows the process workqueue
129
130	usage: showprocworkqueue <proc_t>
131	"""
132
133	if not cmd_args:
134	raise ArgumentError('missing struct proc * argument')
135
136	proc = kern.GetValueFromAddress(cmd_args[0], "proc_t")
137	wq = Cast(proc.p_wqptr, "struct workqueue *");
138	if wq:
139	print GetWorkqueueSummary.header
140	print GetWorkqueueSummary(proc, wq)
141
142	if wq.wq_reqcount:
143	print " "
144	print " " + GetWorkqueueThreadRequestSummary.header
145	if wq.wq_event_manager_threadreq:
146	print " " + GetWorkqueueThreadRequestSummary(proc, wq.wq_event_manager_threadreq)
147	for req in IteratePriorityQueueEntry(wq.wq_overcommit_queue, 'struct workq_threadreq_s', 'tr_entry'):
148	print " " + GetWorkqueueThreadRequestSummary(proc, req)
149	for req in IteratePriorityQueueEntry(wq.wq_constrained_queue, 'struct workq_threadreq_s', 'tr_entry'):
150	print " " + GetWorkqueueThreadRequestSummary(proc, req)
151	for req in IteratePriorityQueueEntry(wq.wq_special_queue, 'struct workq_threadreq_s', 'tr_entry'):
152	print " " + GetWorkqueueThreadRequestSummary(proc, req)
153
154	print " "
155	print " " + GetWQThreadSummary.header
156	for uth in IterateTAILQ_HEAD(wq.wq_thrunlist, "uu_workq_entry"):
157	print " " + GetWQThreadSummary(Cast(uth.uu_thread, 'struct thread *'), uth)
158	for uth in IterateTAILQ_HEAD(wq.wq_thidlelist, "uu_workq_entry"):
159	print " " + GetWQThreadSummary(Cast(uth.uu_thread, 'struct thread *'), uth)
160	for uth in IterateTAILQ_HEAD(wq.wq_thnewlist, "uu_workq_entry"):
161	print " " + GetWQThreadSummary(Cast(uth.uu_thread, 'struct thread *'), uth)
162
163	@lldb_command('showallworkqueues')
164	def ShowAllWorkqueues(cmd_args=None):
165	""" Display a summary of all the workqueues in the system
166
167	usage: showallworkqueues
168	"""
169
170	print GetWorkqueueSummary.header
171
172	for t in kern.tasks:
173	proc = Cast(t.bsd_info, 'proc *')
174	wq = Cast(proc.p_wqptr, "struct workqueue *");
175	if wq:
176	print GetWorkqueueSummary(proc, wq)