def lb_get_stats(priv):
# Per-cpu
if (symbol_exists("per_cpu__pcpu_lstats")):
# 2.6.20
addrs = percpu.get_cpu_var("pcpu_lstats")
out = []
for a in addrs:
lb_stats = readSU("struct pcpu_lstats", a)
stats = Bunch()
stats.tx_packets = stats.rx_packets = lb_stats.packets
stats.tx_bytes = stats.rx_bytes = lb_stats.bytes
out.append(stats)
return out
elif (symbol_exists("per_cpu__loopback_stats")):
addrs = percpu.get_cpu_var("loopback_stats")
out = []
for a in addrs:
stats = readSU("struct net_device_stats", a)
out.append(stats)
return out
elif (symbol_exists("init_net")): # 2.6.24
out = []
for cpu in range(sys_info.CPUS):
a = percpu.percpu_ptr(priv, cpu)
lb_stats = readSU("struct pcpu_lstats", a)
stats = Bunch()
stats.tx_packets = stats.rx_packets = lb_stats.packets
stats.tx_bytes = stats.rx_bytes = lb_stats.bytes
out.append(stats)
return out
stats = readSU("struct net_device_stats", priv)
return stats
def printPerCPU():
print ("\n\n ===== Per-CPU Data =====")
softnet_data = percpu.get_cpu_var("softnet_data")
netdev_rx_stat = percpu.get_cpu_var("netdev_rx_stat")
for cpu in range(sys_info.CPUS):
sd = readSU("struct softnet_data", softnet_data[cpu])
print ("--CPU %d" % cpu)
print ("\tinput_pkt_queue=0x%x qlen=%d" % \
(Addr(sd.input_pkt_queue), sd.input_pkt_queue.qlen))
netif_rx_stats = readSU("struct netif_rx_stats", netdev_rx_stat[cpu])
print ("\tnetif_rx_stats total=%d, dropped=%d" % \
(netif_rx_stats.total, netif_rx_stats.dropped))
def show_cpuid_x86(options):
phys_cpu_list = {}
cpuinfo_addrs = percpu.get_cpu_var("cpu_info")
for cpu, addr in enumerate(cpuinfo_addrs):
cpuinfo_x86 = readSU("struct cpuinfo_x86", addr)
phys_proc_id = cpuinfo_x86.phys_proc_id
cpu_core_id = cpuinfo_x86.cpu_core_id
cpu_core_dict = {}
if (phys_proc_id in phys_cpu_list):
cpu_core_dict = phys_cpu_list[phys_proc_id]
cpu_core_dict[cpu] = cpuinfo_x86
phys_cpu_list[phys_proc_id] = cpu_core_dict
for phys_cpu in phys_cpu_list:
crashcolor.set_color(crashcolor.BLUE)
print("<<< Physical CPU %3d >>>" % (phys_cpu))
crashcolor.set_color(crashcolor.RESET)
core_dict = phys_cpu_list[phys_cpu]
for cpu in core_dict:
cpuinfo_x86 = core_dict[cpu]
print("\tCPU %3d, core %3d : 0x%x %s" %
(cpu, cpuinfo_x86.cpu_core_id, cpuinfo_x86,
cpuinfo_x86.x86_model_id))
print("\n\tFor details, run 'cpuinfo_x86 <address>'")
def show_numa_info(options):
try:
numa_meminfo = readSymbol("numa_meminfo")
nr_blks = numa_meminfo.nr_blks
node_cpus = {}
try:
addrs = percpu.get_cpu_var("x86_cpu_to_node_map")
for cpu, addr in enumerate(addrs):
node = readInt(addr)
if node in node_cpus:
cpu_list = node_cpus[node]
else:
cpu_list = []
cpu_list.append(cpu)
node_cpus[node] = cpu_list
except:
pass
print("available: %d node%s (0" %
(nr_blks, "s" if nr_blks > 1 else ""),
end="")
if nr_blks > 1:
print("-%d" % (nr_blks - 1), end="")
print(")")
for idx in range(0, nr_blks):
numa_memblk = numa_meminfo.blk[idx]
if numa_memblk.nid in node_cpus:
print("node %d cpus: " % (numa_memblk.nid), end="")
cpu_list = node_cpus[numa_memblk.nid]
for cpu in range(0, len(cpu_list)):
print(" %d" % cpu_list[cpu], end="")
print("")
print("node %d : 0x%016x - 0x%016x" %
(numa_memblk.nid, numa_memblk.start, numa_memblk.end))
print("node %d size : %d MB" %
(numa_memblk.nid,
(numa_memblk.end - numa_memblk.start) / (1024 * 1024)))
if nr_blks <= 1:
return
numa_distance = readSymbol("numa_distance")
numa_distance_cnt = readSymbol("numa_distance_cnt")
print("node distances:")
print(" %5s" % ("node"), end="")
for i in range(0, nr_blks):
print("%5d" % i, end="")
print("")
for i in range(0, numa_meminfo.nr_blks):
print("%5d:" % (i), end="")
for j in range(0, numa_meminfo.nr_blks):
distance = numa_distance[i * numa_distance_cnt + j]
print("%5d" % (distance), end="")
print("")
except:
print("No NUMA information available")
def show_cpufreq():
if (not sys_info.machine in ("x86_64", "i386", "i686", "athlon")):
print("Some information are only available on x86 architecutres")
addrs = percpu.get_cpu_var("cpufreq_cpu_data")
try:
all_cpu_data = readSymbol("all_cpu_data")
except:
all_cpu_data = None
pass
for cpu, addr in enumerate(addrs):
cpufreq_addr = readULong(addr)
cpufreq_cpu_data = readSU('struct cpufreq_policy', cpufreq_addr)
if (cpufreq_cpu_data == None or cpufreq_cpu_data == 0):
print("struct cpufreq_policy = 0x%x" % (cpufreq_cpu_data))
continue
cur_cpu_khz = cpufreq_cpu_data.cur
if (cur_cpu_khz == 0):
cur_cpu_khz = readSymbol("cpu_khz")
print("CPU %3d (0x%x) min = %d, max = %d, cur = %d" %
(cpu, cpufreq_addr, cpufreq_cpu_data.min, cpufreq_cpu_data.max,
cur_cpu_khz))
if (all_cpu_data != None and all_cpu_data != 0):
cpudata = all_cpu_data[cpu]
print("\tcpudata = 0x%x, current_pstate = %d, turbo_pstate = %d,\n"
"\tmin_pstate = %d, max_pstate = %d, policy = %s" %
(cpudata, cpudata.pstate.current_pstate,
cpudata.pstate.turbo_pstate, cpudata.pstate.min_pstate,
cpudata.pstate.max_pstate,
cpufreq_policy_str(cpufreq_cpu_data.policy)))
try:
if (member_offset('struct cpudata', 'sample') > -1):
if (member_offset('struct sample', 'freq') > -1):
print(
"\t%s" %
(exec_crash_command("cpudata.sample.freq -d 0x%x" %
(cpudata))))
if (member_offset('struct sample', 'time') > -1):
duration_ns = cpudata.sample.time - cpudata.last_sample_time
print("\tupdated %d ns (%d sec) ago" %\
(duration_ns, duration_ns / 1000000000))
except:
pass
def print_softnet_data(details):
from LinuxDump import percpu
addrs = percpu.get_cpu_var("softnet_data")
for cpu, a in enumerate(addrs):
sd = readSU("struct softnet_data", a)
# Print the completion queue
print(" --CPU=%d" % cpu)
# Count entries in the queue, it starts from sk_buff_head
off = member_offset("struct sk_buff_head", "next")
nq = getListSize(sd.input_pkt_queue, off, 10000)
print(" ..input_pkt_queue has %d elements" % nq)
if (details > 1):
skbhead = sd.input_pkt_queue.castTo("struct sk_buff")
for skb in readStructNext(skbhead, "next", inchead=False):
print(skb)
decode_skbuf(skb)
print(" ..Completion queue")
print_skbuff_head(sd.completion_queue)
def print_blk_cpu_done(v=0):
if (not symbol_exists("blk_cpu_done")):
# This is an old kernel (e.g. RHEL4)
return
total = 0
out = []
for cpu, val in enumerate(get_cpu_var("blk_cpu_done")):
lh = ListHead(val, "struct request")
if (not len(lh)):
continue
total += len(lh)
if (v > 0):
out.append(" CPU={} Len={}".format(cpu, len(lh)))
if (v > 1):
for r in lh.csd:
out.append(" {}".format(str(r)))
if (total or v >= 0):
print(" -- Requests on blk_cpu_done: Count={}".format(total))
if (v > 0 and total):
print("\n".join(out))
return total
def show_tlb(options):
cpuinfo_addrs = percpu.get_cpu_var("cpu_tlbstate")
for cpu, addr in enumerate(cpuinfo_addrs):
tlb_state = readSU("struct tlb_state", addr)
task = 0
if tlb_state.active_mm > 0:
active_mm = readSU("struct mm_struct", tlb_state.active_mm)
task = active_mm.owner
if tlb_state.state == TLBSTATE_LAZY:
crashcolor.set_color(crashcolor.BLUE)
elif tlb_state.state == TLBSTATE_OK:
crashcolor.set_color(crashcolor.LIGHTGREEN)
if task != 0:
task_name = task.comm
else:
task_name = ""
print("CPU %3d : state = %d [%-13s], active_mm = 0x%x (%s)" %
(cpu, tlb_state.state, tlb_str(
tlb_state.state), tlb_state.active_mm, task_name))
crashcolor.set_color(crashcolor.RESET)
def show_tasklet_hi_list(options):
addrs = percpu.get_cpu_var("tasklet_hi_vec")
show_tasklet_list_details(addrs, options)
debug = API_options.debug
pointersize = sys_info.pointersize
# Fill-in the list
cpufreq_cpu_data = []
if (symbol_exists("cpufreq_cpu_data")):
addr = sym2addr("cpufreq_cpu_data")
# struct cpufreq_policy *cpufreq_cpu_data[NR_CPUS]
for cpu in range(0, sys_info.CPUS):
ptr = readPtr(addr + pointersize * cpu)
p = readSU("struct cpufreq_policy", ptr)
cpufreq_cpu_data.append(p)
elif (symbol_exists("per_cpu__cpufreq_cpu_data")):
# static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data)
vtype = percpu.get_cpu_var_type("cpufreq_cpu_data")
for v in percpu.get_cpu_var("cpufreq_cpu_data"):
cpufreq_cpu_data.append(readSU(vtype, v))
def print_cpufreq():
for p in cpufreq_cpu_data:
if (not p.governor):
continue
print(" CPU=%d" % p.cpu, p, p.governor.name)
print (" Frequencies: min=%d max=%d cur=%d" % \
(p.min, p.max, p.cur))
if (symbol_exists("sched_clock")):
if (debug):
print("Using sched_clock")
# last_ran is in ns, derived from TSC
sched_clock2ms = sched_clock2ms_26_tsc
else:
# last_ran is in ticks, derived from jiffies
if (debug):
print("Using jiffies for clock base")
if (sys_info.kernel >= "2.6.0"):
sched_clock2ms = sched_clock2ms_26_jiffies
else:
sched_clock2ms = sched_clock2ms_24
runqueues_addrs = percpu.get_cpu_var("runqueues")
sys_info.runqueues_addrs = runqueues_addrs
# Older 2.6 use 'struct runqueue', newer ones 'struct rq'
rqtype = percpu.get_cpu_var_type('runqueues')
# In crash sources the order is like that:
# if (MEMBER_EXISTS("rq", "clock"))
# rq_timestamp_name = "clock";
# else if (MEMBER_EXISTS("rq", "most_recent_timestamp"))
# rq_timestamp_name = "most_recent_timestamp";
# else if (MEMBER_EXISTS("rq", "timestamp_last_tick"))
# rq_timestamp_name = "timestamp_last_tick";
structSetAttr(rqtype, "Timestamp", [
"clock", "most_recent_timestamp", "timestamp_last_tick", "tick_timestamp"
])
