def print_theta(hs):
theta = cfs_hash_cur_theta(hs)
- print "Theta: %d %s" % (theta, cfs_hash_format_theta(theta))
+ print("Theta: %d %s" % (theta, cfs_hash_format_theta(theta)))
def print_thetas(name, hashtable):
hs = readSU('struct cfs_hash', hashtable)
s = ""
for idx in xrange(count):
s += "="
- print s
+ print(s)
def print_hash_labels():
- print "%-15s %-17s\t %-5s %-5s %-5s %-5s %-5s %-5s %-5s " \
+ print("%-15s %-17s\t %-5s %-5s %-5s %-5s %-5s %-5s %-5s " \
"%-5s %-5s %-5s %-5s %-11s %-11s %-11s %-5s" % \
("name", "cfs_hash", "cnt", "rhcnt", "xtr", "cur", "min", "max", "rhash", \
- "bkt", "nbkt", "nhlst", "flags", "theta", "minT", "maxT", "bktsz")
+ "bkt", "nbkt", "nhlst", "flags", "theta", "minT", "maxT", "bktsz"))
def print_hash_summary(name, hashtable):
hs = readSU('struct cfs_hash', hashtable)
if hs:
hs_cnt = readSU('atomic_t', hs.hs_count).counter
hs_ref = readSU('atomic_t', hs.hs_refcount).counter
- print "%-15s %-17x\t %-5d %-5d %-5d %-5d %-5d %-5d %-5d %-5d %-5d %-5d %-5x %-11s %-11s %-11s %-5d" % \
+ print("%-15s %-17x\t %-5d %-5d %-5d %-5d %-5d %-5d %-5d %-5d %-5d %-5d %-5x %-11s %-11s %-11s %-5d" % \
(name, (Addr(hs)), \
readSU('atomic_t', hs.hs_count).counter, \
hs.hs_rehash_count, \
cfs_hash_format_theta(cfs_hash_cur_theta(hs)), \
cfs_hash_format_theta(hs.hs_min_theta), \
cfs_hash_format_theta(hs.hs_max_theta), \
- ll.cfs_hash_bucket_size(hs))
+ ll.cfs_hash_bucket_size(hs)))
else:
- print "%-15s %-17x" % \
- (name, (Addr(hs)))
+ print("%-15s %-17x" % \
+ (name, (Addr(hs))))
def obd_print_export_hashes(obd, exp_list, fld):
- print "\nExport list head %x %s" % (exp_list, fld)
+ print("\nExport list head %x %s" % (exp_list, fld))
for exp in readSUListFromHead(exp_list, fld, 'struct obd_export'):
print_hash_summary('exp_lock', exp.exp_lock_hash)
print_hash_summary('exp_flock', exp.exp_flock_hash)
def obd_print_one_device_hashes(obd):
try:
nm = ll.obd2str(obd)
- except Exception, e:
+ except Exception as e:
return 1
- print "obd_device %-17x %-22s" % (Addr(obd), ll.obd2str(obd))
+ print("obd_device %-17x %-22s" % (Addr(obd), ll.obd2str(obd)))
print_hash_labels()
print_hash_summary("uuid", obd.obd_uuid_hash)
# obd_print_export_hashes(obd, obd.obd_exports, 'exp_obd_chain')
# obd_print_export_hashes(obd, obd.obd_exports_timed, 'exp_obd_chain_timed')
- print ""
+ print("")
return 0
def obd_devs_hash():
def ldlm_print_ns_hashes(ns, type):
ns_list = readSymbol(ns)
- print "\n%s namespaces-resources" % type
+ print("\n%s namespaces-resources" % type)
print_hash_labels()
for ns in readSUListFromHead(ns_list, 'ns_list_chain', 'struct ldlm_namespace'):
nm = ll.obd2str(ns.ns_obd)[0:20]
print_hash_labels()
for site in readSUListFromHead(lu_sites, 'ls_linkage', 'struct lu_site'):
print_hash_summary("lu_site_vvp", site.ls_obj_hash)
- print ""
+ print("")
def global_hashes():
print_hash_summary("jobid_hash", readSymbol('jobid_hash'))
if symbol_exists('cl_env_hash'):
print_hash_summary("cl_env_hash", readSymbol('cl_env_hash'))
- print ""
+ print("")
if __name__ == "__main__":
description = "Displays summary of hash tables in 'obd_devs'"
def dump_hnodes(hs, hlist, hnode, depth=0, ruler=RULER):
while(hnode != hlist & hnode):
s = get_hash_object(hs, hnode)
- print "%*.*shlist_node 0x%x %s" % (depth, depth, ruler, Addr(hnode), s)
+ print("%*.*shlist_node 0x%x %s" % (depth, depth, ruler, Addr(hnode), s))
hnode = hnode.next
def dump_hlist(hs, hlist, depth=0, ruler=RULER):
if hlist.first:
hnode = hlist.first
- print "%*.*shlist_head 0x%x" % (depth, depth, ruler, Addr(hlist))
+ print("%*.*shlist_head 0x%x" % (depth, depth, ruler, Addr(hlist)))
dump_hnodes(hs, hlist, hnode, depth+DEPTH, ruler)
def dump_hash_bucket(hs, bd_bkt, depth=0, ruler=RULER):
- print "%*.*scfs_hash_bucket 0x%x" % (depth, depth, ruler, Addr(bd_bkt))
+ print("%*.*scfs_hash_bucket 0x%x" % (depth, depth, ruler, Addr(bd_bkt)))
for bd_offset in range(ll.CFS_HASH_BKT_NHLIST(hs)):
hlist = ll.cfs_hash_hhead(hs, bd_bkt, bd_offset)
if hlist:
dump_hlist(hs, hlist, depth+DEPTH, ruler)
def dump_hash_table(hs):
- print "cfs_hash@0x%x" % Addr(hs)
+ print("cfs_hash@0x%x" % Addr(hs))
for bd_bkt in ll.cfs_hash_get_buckets(hs):
dump_hash_bucket(hs, bd_bkt, DEPTH, RULER)
def pfn2phys(pfn):
"""Convert a page offset into a physical address."""
- return pfn << crashlib.cid.mdtbl.pageshift
+ return int(pfn) << int(crashlib.cid.mdtbl.pageshift)
# a suffix happens to contain valid numeric characters, we'll
# try the numeric interpretation before we try their multiplier
# meaning, e.g. 'g' is a valid numeric value in base 17).
- for i in xrange(2):
+ for i in range(2):
for b in bases:
try:
return int(string, b) * multiplier
return toint(string, base=[16, 0])
-def to_rangelist(args, default=xrange(0), base=[0,16],
+def to_rangelist(args, default=range(0), base=[0,16],
suffixes=binary_suffixes):
"""Convert a bunch of range list strings into a list of ranges
fields = range_str.split('-', 1)
start = toint(fields[0], base, suffixes=suffixes)
end = toint(fields[1], base, suffixes=suffixes) + 1
- ranges.append(xrange(start, end))
+ ranges.append(range(start, end))
elif "#" in range_str:
fields = range_str.split('#', 1)
start = toint(fields[0], base, suffixes=suffixes)
end = start + toint(fields[1], base, suffixes=suffixes)
- ranges.append(xrange(start, end))
+ ranges.append(range(start, end))
else:
start = toint(range_str, base, suffixes=suffixes)
end = start + 1
- ranges.append(xrange(start, end))
+ ranges.append(range(start, end))
return ranges
"""Test both iter_rangelist and the underlying to_rangelist."""
def test_good_single_ranges(self):
self.assertEqual(list(iter_rangestr([])), [])
- self.assertEqual(list(iter_rangestr(['1-2'])), list(xrange(1,3)))
- self.assertEqual(list(iter_rangestr(['1#2'])), list(xrange(1,3)))
- self.assertEqual(list(iter_rangestr(['1'])), list(xrange(1,2)))
+ self.assertEqual(list(iter_rangestr(['1-2'])), list(range(1,3)))
+ self.assertEqual(list(iter_rangestr(['1#2'])), list(range(1,3)))
+ self.assertEqual(list(iter_rangestr(['1'])), list(range(1,2)))
def test_good_multiple_ranges(self):
test_rangestrs = [
{"casesensitive": False, "prefixok": True},
{"casesensitive": True, "prefixok": False},
{"casesensitive": True, "prefixok": True}]
- for i in xrange(len(expectedlist)):
+ for i in range(len(expectedlist)):
e = expectedlist[i]
if e is None:
self.assertRaises(KeyError,
import crashlib.cid.machdep_table
import crashlib.cid.page_flags
import crashlib.cid.phys_mem_map
-import crashlib.memarray
# --------------------------------------------------------------------------
return (page - vmemmap_vaddr) / page_struct_size
# --------------------------------------------------------------------------
-
-def page_list():
- """Return a list-like class of page structs indexed by pfn.
-
- This implementation assumes the kernel is configured with a virtually
- contiguous mem_map.
- """
- # If the kernel doesn't have a virtually contiguous mem_map, this could
- # be changed to return a chained list of MemCArray objects.
-
- PAGE_SHIFT = crashlib.cid.mdtbl.pageshift
- pfn_start = crashlib.cid.physmap[0].start >> PAGE_SHIFT
- pfn_end = crashlib.cid.physmap[-1].end >> PAGE_SHIFT
-
- # Find page map and create an array of page_struct
- vmemmap_addr = crashlib.cid.mdtbl.vmemmap_vaddr
-
- return crashlib.memarray.MemCArray(vmemmap_addr,
- lambda a:readSU('struct page',a),
- getSizeOf('struct page'),
- pfn_end-pfn_start)
if key & mask:
flags = flags + value + " "
tmp &= ~key
- print "mask: 0x%x = %s" % (mask, flags)
+ print("mask: 0x%x = %s" % (mask, flags))
if tmp != 0:
- print "unknown bits set in mask: 0x%x" % tmp
+ print("unknown bits set in mask: 0x%x" % tmp)
def dump_debug_flags(bitmask):
- print bitmask
+ print(bitmask)
if not bitmask:
bitmask = readSymbol('libcfs_debug')
print_flags(debug_flags_tbl, bitmask)
description_short = 'Dump and sort the Lustre dk logs.'
def do_shell_cmd(cmd):
- return os.popen(cmd).read()
+ return "done"
+ #return os.popen(cmd).read()
# ---------------------------------------------------------------------------
# pfn: 2582e8c, physaddr: 2582e8c000, vaddr: ffff002582e8c000
laddr = vaddr + hdr_size
try:
line = readmem(laddr, hdr.ph_len - hdr_size)
- except:
- print "Skipping pfn: %x, physaddr: %x, vaddr: %x, laddr: %x" % \
- (pfn, physaddr, vaddr, laddr)
+ except:
+ print("Skipping pfn: %x, physaddr: %x, vaddr: %x, laddr: %x" % \
+ (pfn, physaddr, vaddr, laddr))
return
- (filename,function,text) = line.split('\0')
+ (filename,function,text) = line.decode().split('\0')
text = text.rstrip()
used -= hdr.ph_len
def walk_array(options):
"""Walk the cfs_trace_data array of array pointers."""
- fname = do_shell_cmd('mktemp .dklogXXXX').rstrip()
- tmpfd = file(fname, 'w')
+ #fname = do_shell_cmd('mktemp .dklogXXXX').rstrip()
+ tmpfd = open("/tmp/log.bin", 'w')
try:
cfs_trace_data = readSymbol('cfs_trace_data')
cfs_trace_data = readSymbol('trace_data')
trace_page_struct = 'struct trace_page'
except:
- print "Ensure you have loaded the Lustre modules"
+ print("Ensure you have loaded the Lustre modules")
return 1
for cfstd_array in cfs_trace_data:
if not cfstd_array: continue
- for i in xrange(sys_info.CPUS):
+ for i in range(sys_info.CPUS):
u = cfstd_array[i]
walk_pages(tmpfd, options, u.tcd.tcd_pages, trace_page_struct)
walk_pages(tmpfd, options, u.tcd.tcd_stock_pages, trace_page_struct)
tmpfd.close()
- print do_shell_cmd('sort -n -s -t: -k4,4 ' + fname)
- print do_shell_cmd('rm ' + fname)
+ print(do_shell_cmd('sort -n -s -t: -k4,4 ' + fname))
+ print(do_shell_cmd('rm ' + fname))
# ---------------------------------------------------------------------------
def dump_dk_log():
stime = scur - soffset
date = time.asctime(time.localtime(stime))
- print '%s (epoch: %d)' % (date, stime)
+ print('%s (epoch: %d)' % (date, stime))
if __name__ == "__main__":
description = "Print the date and time of a given jiffies timestamp. " + \
obd = None
imp = None
if(lock == None):
- print " NULL LDLM lock"
+ print(" NULL LDLM lock")
+ return
+ try:
+ if lock.l_handle.hasField("h_ref"):
+ refcounter = lock.l_handle.h_ref.refs
+ else:
+ refcounter = lock.l_refc.counter
+
+ print(" -- Lock: (ldlm_lock) %#x/%#x (rc: %d) (pos: %d/%s) (pid: %d)" % \
+ (Addr(lock), lock.l_handle.h_cookie, refcounter,
+ pos, lstname, lock.l_pid))
+ if(lock.l_conn_export):
+ obd = lock.l_conn_export.exp_obd
+ if(lock.l_export and lock.l_export.exp_connection):
+ print(" Node: NID %s (remote: %#x) export" % \
+ (ll.nid2str(lock.l_export.exp_connection.c_peer.nid),
+ lock.l_remote_handle.cookie))
+ elif(obd == None):
+ print(" Node: local")
+ else:
+ imp = obd.u.cli.cl_import
+ print(" Node: NID %s (remote: %#x) import " % \
+ (ll.nid2str(imp.imp_connection.c_peer.nid),
+ lock.l_remote_handle.cookie))
+
+ res = lock.l_resource
+ print(" Resource: %#x [0x%x:0x%x:0x%x].%x" % \
+ (Addr(res),
+ res.lr_name.name[0],
+ res.lr_name.name[1],
+ res.lr_name.name[2],
+ res.lr_name.name[3]))
+
+ print(" Req mode: %s, grant mode: %s, rc: %d, read: %d, \
+ write: %d flags: %#x" % (lockmode2str(lock.l_req_mode),
+ lockmode2str(lock.l_granted_mode),
+ refcounter, lock.l_readers, lock.l_writers,
+ lock.l_flags))
+
+ lr_type = lock.l_resource.lr_type
+ if(lr_type == enum_LDLM_EXTENT):
+ print(" Extent: %d -> %d (req %d-%d)" % \
+ (lock.l_policy_data.l_extent.start,
+ lock.l_policy_data.l_extent.end,
+ lock.l_req_extent.start, lock.l_req_extent.end))
+ elif(lr_type == enum_LDLM_FLOCK):
+ print(" Pid: %d Flock: 0x%x -> 0x%x" % \
+ (lock.l_policy_data.l_flock.pid,
+ lock.l_policy_data.l_flock.start,
+ lock.l_policy_data.l_flock.end))
+ elif(lr_type == enum_LDLM_IBITS):
+ print(" Bits: %#x" % \
+ (lock.l_policy_data.l_inodebits.bits))
+ except (crash.error, IndexError):
+ print(" Corrupted lock %#x" % (Addr(lock)))
return
- print " -- Lock: (ldlm_lock) %#x/%#x (rc: %d) (pos: %d/%s) (pid: %d)" % \
- (Addr(lock), lock.l_handle.h_cookie, lock.l_refc.counter,
- pos, lstname, lock.l_pid)
- if(lock.l_conn_export):
- obd = lock.l_conn_export.exp_obd
- if(lock.l_export and lock.l_export.exp_connection):
- print " Node: NID %s (remote: %#x) export" % \
- (ll.nid2str(lock.l_export.exp_connection.c_peer.nid),
- lock.l_remote_handle.cookie)
- elif(obd == None):
- print " Node: local"
- else:
- imp = obd.u.cli.cl_import
- print " Node: NID %s (remote: %#x) import " % \
- (ll.nid2str(imp.imp_connection.c_peer.nid),
- lock.l_remote_handle.cookie)
-
- res = lock.l_resource
- print " Resource: %#x [0x%x:0x%x:0x%x].%x" % \
- (Addr(res),
- res.lr_name.name[0],
- res.lr_name.name[1],
- res.lr_name.name[2],
- res.lr_name.name[3])
-
- print " Req mode: %s, grant mode: %s, rc: %d, read: %d, \
- write: %d flags: %#x" % (lockmode2str(lock.l_req_mode),
- lockmode2str(lock.l_granted_mode),
- lock.l_refc.counter, lock.l_readers, lock.l_writers,
- lock.l_flags)
-
- lr_type = lock.l_resource.lr_type
- if(lr_type == enum_LDLM_EXTENT):
- print " Extent: %d -> %d (req %d-%d)" % \
- (lock.l_policy_data.l_extent.start,
- lock.l_policy_data.l_extent.end,
- lock.l_req_extent.start, lock.l_req_extent.end)
- elif(lr_type == enum_LDLM_FLOCK):
- print " Pid: %d Flock: 0x%x -> 0x%x" % \
- (lock.l_policy_data.l_flock.pid,
- lock.l_policy_data.l_flock.start,
- lock.l_policy_data.l_flock.end)
- elif(lr_type == enum_LDLM_IBITS):
- print " Bits: %#x" % \
- (lock.l_policy_data.l_inodebits.bits)
def ldlm_dump_resource(res):
res_lr_granted = readSU('struct list_head', Addr(res.lr_granted))
res_lr_waiting = readSU('struct list_head', Addr(res.lr_waiting))
- print "-- Resource: (ldlm_resource) %#x [0x%x:0x%x:0x%x].%x (rc: %d)" % \
- (Addr(res), res.lr_name.name[0], res.lr_name.name[1],
- res.lr_name.name[2], res.lr_name.name[3], res.lr_refcount.counter)
+ try:
+ print("-- Resource: (ldlm_resource) %#x [0x%x:0x%x:0x%x].%x (rc: %d)" % \
+ (Addr(res), res.lr_name.name[0], res.lr_name.name[1],
+ res.lr_name.name[2], res.lr_name.name[3], res.lr_refcount.counter))
+ except (crash.error, IndexError):
+ print("-- Corrupted resource %#x" % (Addr(res)))
+ return
if not ll.list_empty(res_lr_granted):
pos = 0
- print " Granted locks: "
+ print(" Granted locks: ")
tmp = res_lr_granted.next
while(tmp != res_lr_granted):
pos += 1
lock = readSU('struct ldlm_lock',
Addr(tmp)-member_offset('struct ldlm_lock', 'l_res_link'))
ldlm_dump_lock(lock, pos, "grnt")
- tmp = tmp.next
+ try:
+ tmp = tmp.next
+ except (crash.error, IndexError):
+ break
if not ll.list_empty(res_lr_waiting):
pos = 0
- print " Waiting locks: "
+ print(" Waiting locks: ")
tmp = res_lr_waiting.next
while(tmp != res_lr_waiting):
pos += 1
lock = readSU('struct ldlm_lock',
Addr(tmp)-member_offset('struct ldlm_lock', 'l_res_link'))
ldlm_dump_lock(lock, pos, "wait")
- tmp = tmp.next
+ try:
+ tmp = tmp.next
+ except (crash.error, IndexError):
+ break
def print_namespace(ns, client_server):
- print "Namespace: (ldlm_namespace) %#x, %s\t(rc: %d, side: %s)\tpoolcnt: %d unused: %d" % \
+ print("Namespace: (ldlm_namespace) %#x, %s\t(rc: %d, side: %s)\tpoolcnt: %d unused: %d" % \
(Addr(ns), ll.obd2str(ns.ns_obd), ns.ns_bref.counter,
- client_server, ns.ns_pool.pl_granted.counter, ns.ns_nr_unused)
+ client_server, ns.ns_pool.pl_granted.counter, ns.ns_nr_unused))
def ldlm_dump_ns_resources(ns):
if args.nflag:
if key & mask:
flags = flags + value + " "
tmp &= ~key
- print "mask: 0x%x = %s" % (mask, flags)
+ print("mask: 0x%x = %s" % (mask, flags))
if tmp != 0:
- print "unknown bits set in mask: 0x%x" % tmp
+ print("unknown bits set in mask: 0x%x" % tmp)
if __name__ == "__main__":
description = "Prints string identifiers for specified LDLM flags."
IDIF_OID_MASK = ((1 << IDIF_OID_MAX_BITS) -1)
def lov_print_empty(obj, depth=0, ruler=RULER):
- print "empty %d" % obj.lo_layout_invalid
+ print("empty %d" % obj.lo_layout_invalid)
def lov_print_raid0(obj, depth=0, ruler=RULER):
r0 = None
stripes = lsm.lsm_stripe_count
layout_gen = lsm.lsm_layout_gen
pattern = lsm.lsm_pattern
- except Exception, e:
+ except Exception as e:
magic = lsm.lsm_wire.lw_magic
stripes = lsm.lsm_wire.lw_stripe_count
layout_gen = lsm.lsm_wire.lw_layout_gen
lli = readU32(Addr(obj) + member_offset('struct lov_object', 'lo_layout_invalid'))
invalid = "invalid" if lli else "valid"
if r0 and r0.lo_nr:
- print "%*.*sstripes: %d, %s, lsm[0x%x 0x%X %d %d %d %d]:" % \
+ print("%*.*sstripes: %d, %s, lsm[0x%x 0x%X %d %d %d %d]:" % \
(depth, depth, ruler,
r0.lo_nr, invalid, Addr(lsm), magic,
- lsm.lsm_refc.counter, stripes, layout_gen, pattern)
+ lsm.lsm_refc.counter, stripes, layout_gen, pattern))
for i in range(r0.lo_nr):
los = r0.lo_sub[i]
if los:
sub = los.lso_cl.co_lu
lovsub_object_print(sub, depth+DEPTH, ruler)
else:
- print "sub %d absent" % i
+ print("sub %d absent" % i)
def lov_print_released(obj, depth=0, ruler=RULER):
lsm = obj.lo_lsm
lli = readU32(Addr(obj) + member_offset('struct lov_object', 'lo_layout_invalid'))
invalid = "invalid" if lli else "valid"
if magic==LOV_MAGIC or magic==LOV_MAGIC_V3:
- print "%*.*sreleased: %s, lov_stripe_md: 0x%x [0x%X %d %u %u]:" % \
+ print("%*.*sreleased: %s, lov_stripe_md: 0x%x [0x%X %d %u %u]:" % \
(depth, depth, ruler,
invalid, Addr(lsm), magic, lsm.lsm_refc.counter,
- entries, layout_gen)
+ entries, layout_gen))
LOV_PRINT_TYPE = {
0:lov_print_empty,
def vvp_object_print(o, depth=0, ruler=RULER):
obj = readSU('struct vvp_object', Addr(o) - member_offset('struct vvp_object', 'vob_cl.co_lu'))
- print "%*.*s(trans:%s mmap:%d) inode: 0x%x " % \
+ print("%*.*s(trans:%s mmap:%d) inode: 0x%x " % \
(depth, depth, ruler,
obj.vob_transient_pages.counter,
obj.vob_mmap_cnt.counter,
- Addr(obj.vob_inode))
+ Addr(obj.vob_inode)))
def lod_object_print(o, depth=0, ruler=RULER):
obj = readSU('struct lod_object', Addr(o) - member_offset('struct lod_object', 'ldo_obj.do_lu'))
- print "%*.*slod_object@0x%x" % (depth, depth, ruler, Addr(obj))
+ print("%*.*slod_object@0x%x" % (depth, depth, ruler, Addr(obj)))
def lov_object_print(o, depth=0, ruler=RULER):
obj = readSU('struct lov_object', Addr(o) - member_offset('struct lov_object', 'lo_cl.co_lu'))
def lovsub_object_print(o, depth=0, ruler=RULER):
obj = readSU('struct lovsub_object', Addr(o) - member_offset('struct lovsub_object', 'lso_cl.co_lu'))
- print "%*.*slso_index: %d" % (depth, depth, ruler, obj.lso_index)
+ print("%*.*slso_index: %d" % (depth, depth, ruler, obj.lso_index))
def mdd_object_print(o, depth=0, ruler=RULER):
obj = readSU('struct mdd_object', Addr(o) - member_offset('struct mdd_object', 'mod_obj.mo_lu'))
- print "%*.*smdd_object@0x%x(open_count=%d, valid=%x, cltime=%u, flags=%x)" % \
+ print("%*.*smdd_object@0x%x(open_count=%d, valid=%x, cltime=%u, flags=%x)" % \
(depth, depth, ruler, Addr(obj), obj.mod_count, obj.mod_valid,
- obj.mod_cltime, obj.mod_flags)
+ obj.mod_cltime, obj.mod_flags))
def mdt_object_print(o, depth=0, ruler=RULER):
obj = readSU('struct mdt_object', Addr(o) - member_offset('struct mdt_object', 'mot_obj'))
- print "%*.*smdt_object@0x%x(ioepoch=%u, flags=%x, epochcount=%d, writecount-%d" % \
+ print("%*.*smdt_object@0x%x(ioepoch=%u, flags=%x, epochcount=%d, writecount-%d" % \
(depth, depth, ruler, Addr(obj), obj.mot_ioepoch, obj.mot_flags,
- obj.mot_ioepoch_count, obj.mot_writecount)
+ obj.mot_ioepoch_count, obj.mot_writecount))
def mgs_object_print(o, depth=0, ruler=RULER):
obj = readSU('struct mgs_object', Addr(o) - member_offset('struct mgs_object', 'mgo_obj.do_lu'))
- print "%*.*smgs_object@0x%x" % (depth, depth, ruler, Addr(obj))
+ print("%*.*smgs_object@0x%x" % (depth, depth, ruler, Addr(obj)))
def echo_object_print(o, depth=0, ruler=RULER):
clo = readSU('struct cl_object', Addr(o) - member_offset('struct cl_object', 'co_lu'))
obj = readSU('struct echo_object', Addr(clo) - member_offset('struct echo_object', 'eo_cl'))
- print "%*.*sechocl_object@0x%x" % (depth, depth, ruler, Addr(obj))
+ print("%*.*sechocl_object@0x%x" % (depth, depth, ruler, Addr(obj)))
def ofd_object_print(o, depth=0, ruler=RULER):
- print "%*.*sofd_object@0x%x" % (depth, depth, ruler, Addr(o))
+ print("%*.*sofd_object@0x%x" % (depth, depth, ruler, Addr(o)))
def osc_object_print(o, depth=0, ruler=RULER):
obj = readSU('struct osc_object', Addr(o) - member_offset('struct osc_object', 'oo_cl.co_lu'))
else:
ostid_seq = ostid.oi_fid.f_seq
ostid_id = ostid.oi_fid.f_oid
- print "%*.*sid: 0x%x:%u idx: %d gen: %d kms_valid: %u kms: %u rc: %d force_sync: %d min_xid: %u" % \
+ print("%*.*sid: 0x%x:%u idx: %d gen: %d kms_valid: %u kms: %u rc: %d force_sync: %d min_xid: %u" % \
(depth, depth, ruler, ostid_seq, ostid_id,
oinfo.loi_ost_idx, oinfo.loi_ost_gen, oinfo.loi_kms_valid,
- oinfo.loi_kms, ar.ar_rc, ar.ar_force_sync, ar.ar_min_xid)
+ oinfo.loi_kms, ar.ar_rc, ar.ar_force_sync, ar.ar_min_xid))
def osd_object_print(o, depth=0, ruler=RULER):
obj = readSU('struct osd_object', Addr(o) - member_offset('struct osd_object', 'oo_dt.do_lu'))
- print "%*.*sosd_object@0x%x" % (depth, depth, ruler, Addr(obj))
+ print("%*.*sosd_object@0x%x" % (depth, depth, ruler, Addr(obj)))
def osp_object_print(o, depth=0, ruler=RULER):
obj = readSU('struct osp_object', Addr(o) - member_offset('struct osp_object', 'opo_obj.do_lu'))
- print "%*.*sosp_object@0x%x" % (depth, depth, ruler, Addr(o))
+ print("%*.*sosp_object@0x%x" % (depth, depth, ruler, Addr(o)))
OBJ_PRINT = {
"vvp":vvp_object_print,
OBJ_PRINT[name](obj, depth, ruler)
def print_object(pos, depth=0, ruler=RULER):
- print "%*.*s%s@0x%x" % (depth, depth, ruler, pos.lo_dev.ld_type.ldt_name, Addr(pos))
+ print("%*.*s%s@0x%x" % (depth, depth, ruler, pos.lo_dev.ld_type.ldt_name, Addr(pos)))
if (pos.lo_ops.loo_object_print):
print_object_from_name(pos.lo_dev.ld_type.ldt_name, pos, depth+DEPTH, ruler)
head = loh.loh_layers
empty = "" if (loh.loh_lru.next == loh.loh_lru) else " lru"
exists = " exist" if loh.loh_attr & LOHA_EXISTS else ""
- print "%*.*slu_object_header@0x%x[fl:0x%x, rc:%d, [0x%x:0x%x:0x%x]%s%s] {" % \
+ print("%*.*slu_object_header@0x%x[fl:0x%x, rc:%d, [0x%x:0x%x:0x%x]%s%s] {" % \
(depth, depth, ruler,
Addr(loh),
loh.loh_flags,
loh.loh_fid.f_oid,
loh.loh_fid.f_ver,
empty,
- exists)
+ exists))
for obj in readSUListFromHead(head, 'lo_linkage', 'struct lu_object'):
print_object(obj, depth+DEPTH, ruler)
- print "%*.*s} header@0x%x\n" % (depth, depth, ruler, Addr(loh))
+ print("%*.*s} header@0x%x\n" % (depth, depth, ruler, Addr(loh)))
if __name__ == "__main__":
description = "Prints contents of an lu_object"
hnode = hlist.first
while (hnode and hnode != hlist):
hnodes.append(hnode)
- hnode = hnode.next
+ try:
+ hnode = hnode.next
+ except (crash.error, IndexError):
+ break
return hnodes
def cfs_hash_get_nodes(hsh):
LNET_NID_ANY = 0xffffffffffffffff
LNET_NIDSTR_SIZE = 32
+SOCKLND = 2
O2IBLND = 5
PTLLND = 4
GNILND = 13
s = "%d@ptl" % addr
elif lnd == GNILND:
s = "%d@gni" % addr
+ elif lnd == SOCKLND:
+ s = "%d.%d.%d.%d@tcp" % ((addr >> 24) & 0xff, (addr >> 16) & 0xff,
+ (addr >> 8) & 0xff, addr & 0xff)
else:
nnum = 0
if nnum != 0:
LNET_CPT_BITS = the_lnet.ln_cpt_bits
LNET_PROC_CPT_BITS = LNET_CPT_BITS + 1
LNET_LOFFT_BITS = getSizeOf('loff_t') * 8
-LNET_PROC_VER_BITS = max((min(LNET_LOFFT_BITS, 64) / 4), 8)
+LNET_PROC_VER_BITS = int(max((min(LNET_LOFFT_BITS, 64) / 4), 8))
LNET_PROC_HASH_BITS = 9
LNET_PROC_HOFF_BITS = LNET_LOFFT_BITS - LNET_PROC_CPT_BITS - LNET_PROC_VER_BITS - LNET_PROC_HASH_BITS -1
LNET_PROC_HPOS_BITS = LNET_PROC_HASH_BITS + LNET_PROC_HOFF_BITS
SEP_SIZE = 152
def print_separator(count):
s=""
- for idx in xrange(count):
+ for idx in range(count):
s += "="
- print s
+ print(s)
def print_header():
- print "%-19s %-22s \t%-22s %-19s %-19s %-12s %-10s %-7s %-10s" % \
+ print("%-19s %-22s \t%-22s %-19s %-19s %-12s %-10s %-7s %-10s" % \
("obd_device",
"obd_name",
"ip_address",
"imp_state",
"ish_time",
"index",
- "conn_cnt")
+ "conn_cnt"))
print_separator(SEP_SIZE)
IMP_STATE = {
def print_one_device(obd, stats_flag):
try:
nid = ll.obd2nidstr(obd)
- except Exception, e:
+ except Exception as e:
try:
- print "0x%-17x %-22s" % (Addr(obd), ll.obd2str(obd))
- except Exception, e:
+ print("0x%-17x %-22s" % (Addr(obd), ll.obd2str(obd)))
+ except Exception as e:
return 1
return 0
impstate=IMP_STATE.get(obd.u.cli.cl_import.imp_state)
index=obd.u.cli.cl_import.imp_state_hist_idx - 1
if index > 0 and index < 16:
- ish_time=obd.u.cli.cl_import.imp_state_hist[index].ish_time
- inflight=obd.u.cli.cl_import.imp_inflight.counter
+ ish_time=obd.u.cli.cl_import.imp_state_hist[index].ish_time
+ inflight=obd.u.cli.cl_import.imp_inflight.counter
connect_cnt = obd.u.cli.cl_import.imp_conn_cnt
- print "0x%-17x %-22s\t%-22s\t 0x%-17x 0x%-17x %-10s %-10d %5d %5d" % \
+ print("0x%-17x %-22s\t%-22s\t 0x%-17x 0x%-17x %-10s %-10d %5d %5d" % \
(Addr(obd),
ll.obd2str(obd),
nid,
impstate,
ish_time,
index,
- connect_cnt)
+ connect_cnt))
if stats_flag:
- print
- rs.osc_rpc_stats_seq_show(Addr(obd.u.cli))
+ print(rs.osc_rpc_stats_seq_show(Addr(obd.u.cli)))
print_separator(SEP_SIZE)
return 0
def print_separator(count):
s = ""
- for idx in xrange(count):
+ for idx in range(count):
s += "="
- print s
+ print(s)
def print_title(title):
if title:
- print "\n" + title
- print "%-14s %-6s %-19s %-18s %-19s %-4s %-14s %-4s %-22s %-19s" \
+ print("\n" + title)
+ print("%-14s %-6s %-19s %-18s %-19s %-4s %-14s %-4s %-22s %-19s" \
% ("thread", "pid", "ptlrpc_request", "xid", "nid", "opc",
- "phase:flags", "R:W", "sent/deadline", "ptlrpc_body")
+ "phase:flags", "R:W", "sent/deadline", "ptlrpc_body"))
print_separator(148)
def enum(**enums):
offset = size_round(offset)
addr = Addr(msg) + offset
if addr == 0:
- print "addr"
+ print("addr")
return None
return readSU('struct ptlrpc_body_v2', addr)
nid = ll.nid2str(req.rq_import.imp_connection.c_peer.nid)
brw = "%1d:%1d" % (req.rq_bulk_read, req.rq_bulk_write)
rq_sent_dl = "%d/%d" % (req.rq_sent, req.rq_deadline)
- print "%-14s %-6s 0x%-17x %-18d %-19s %-4d %-14s %-4s %-22s 0x%-17x" % \
+ print("%-14s %-6s 0x%-17x %-18d %-19s %-4d %-14s %-4s %-22s 0x%-17x" % \
(sthread,
status,
Addr(req),
get_phase_flags(req),
brw,
rq_sent_dl,
- pbaddr)
+ pbaddr))
def print_request_list(sthread, lhdr, loffset):
try:
req = readSU('struct ptlrpc_request', reqlnk.next-loffset)
print_one_request(sthread, req)
- except Exception, e:
+ except Exception as e:
print_exc()
return 1
return 0
pinfo_rpcds = readSymbol('ptlrpcds')
pinfo_count = readSymbol('ptlrpcds_num')
- for idx in xrange(pinfo_count):
+ for idx in range(pinfo_count):
ptlrpcd = pinfo_rpcds[idx]
- for jdx in xrange(ptlrpcd.pd_nthreads):
+ for jdx in range(ptlrpcd.pd_nthreads):
pd = ptlrpcd.pd_threads[jdx]
callback(pd, *args)
pd = readSymbol('ptlrpcd_rcv')
def print_overview_entry(pd):
s = "%s:" % pd.pc_name
- print "%-14s ptlrpcd_ctl 0x%x ptlrpc_request_set 0x%x" % \
- (s, Addr(pd), pd.pc_set)
+ print("%-14s ptlrpcd_ctl 0x%x ptlrpc_request_set 0x%x" % \
+ (s, Addr(pd), pd.pc_set))
def dump_overview():
foreach_ptlrpcd_ctl(print_overview_entry)
if pd.pc_set.set_new_count.counter != 0 or \
pd.pc_set.set_remaining.counter != 0:
s = "%s:" %pd.pc_name
- print "%-13s 0x%-18x %-4d %-4d %-6d" % \
+ print("%-13s 0x%-18x %-4d %-4d %-6d" % \
(s, Addr(pd.pc_set),
pd.pc_set.set_refcount.counter,
pd.pc_set.set_new_count.counter,
- pd.pc_set.set_remaining.counter)
+ pd.pc_set.set_remaining.counter))
def dump_pcsets():
- print '%-14s %-19s %-4s %-4s %-6s' % \
- ("thread", "ptlrpc_request_set", "ref", "new", "remain")
+ print('%-14s %-19s %-4s %-4s %-6s' % \
+ ("thread", "ptlrpc_request_set", "ref", "new", "remain"))
print_separator(52)
foreach_ptlrpcd_ctl(print_pcset_stats)
def translate_opcodes(opc_list):
for opc in opc_list:
try:
- print "o%d \t= %s" % (opc, opcodes[opc])
+ print("o%d \t= %s" % (opc, opcodes[opc]))
except:
- print "o%d \t= unknown" % opc
+ print("o%d \t= unknown" % opc)
if __name__ == "__main__":
cli = None
try:
cli = readSU('struct client_obd', client_obd)
- except Exception, e:
+ except Exception as e:
for dev in readSymbol('obd_devs'):
try:
if ll.obd2str(dev, 4) == client_obd:
cli = dev.u.cli
break
- except Exception, e:
+ except Exception as e:
continue
return cli
def osc_rpc_stats_seq_show(client_obd):
if not client_obd:
- print "invalid input for field 'client_obd'"
+ print("invalid input for field 'client_obd'")
return 1
cli = readSU('struct client_obd', client_obd)
- print "read RPCs in flight: %d" % cli.cl_r_in_flight
- print "write RPCs in flight: %d" % cli.cl_w_in_flight
- print "pending write pages: %d" % cli.cl_pending_w_pages.counter
- print "pending read pages: %d" % cli.cl_pending_r_pages.counter
+ print("read RPCs in flight: %d" % cli.cl_r_in_flight)
+ print("write RPCs in flight: %d" % cli.cl_w_in_flight)
+ print("pending write pages: %d" % cli.cl_pending_w_pages.counter)
+ print("pending read pages: %d" % cli.cl_pending_r_pages.counter)
- print "\n\t\t\tread\t\t\twrite"
- print "pages per rpc rpcs % cum % | rpcs % cum %\n"
+ print("\n\t\t\tread\t\t\twrite")
+ print("pages per rpc rpcs % cum % | rpcs % cum %\n")
read_tot = lprocfs_oh_sum(cli.cl_read_page_hist)
write_tot = lprocfs_oh_sum(cli.cl_write_page_hist)
read_cum += r
write_cum += w
- print "%d:\t\t%10d %3d %3d | %10d %3d %3d" % \
+ print("%d:\t\t%10d %3d %3d | %10d %3d %3d" % \
(1 << i, r, pct(r, read_tot),
pct(read_cum, read_tot), w,
pct(w, write_tot),
- pct(write_cum, write_tot))
+ pct(write_cum, write_tot)))
if read_cum == read_tot and write_cum == write_tot:
break
- print "\n\t\t\tread\t\t\twrite"
- print "rpcs in flight rpcs % cum % | rpcs % cum %\n"
+ print("\n\t\t\tread\t\t\twrite")
+ print("rpcs in flight rpcs % cum % | rpcs % cum %\n")
read_tot = lprocfs_oh_sum(cli.cl_read_rpc_hist)
write_tot = lprocfs_oh_sum(cli.cl_write_rpc_hist)
read_cum += r
write_cum += w
- print "%d:\t\t%10d %3d %3d | %10d %3d %3d" % \
+ print("%d:\t\t%10d %3d %3d | %10d %3d %3d" % \
(i, r, pct(r, read_tot),
pct(read_cum, read_tot), w,
pct(w, write_tot),
- pct(write_cum, write_tot))
+ pct(write_cum, write_tot)))
if read_cum == read_tot and write_cum == write_tot:
break
- print "\n\t\t\tread\t\t\twrite"
- print "offset rpcs % cum % | rpcs % cum %\n"
+ print("\n\t\t\tread\t\t\twrite")
+ print("offset rpcs % cum % | rpcs % cum %\n")
read_tot = lprocfs_oh_sum(cli.cl_read_offset_hist)
write_tot = lprocfs_oh_sum(cli.cl_write_offset_hist)
read_cum += r
write_cum += w
offset = 0 if i == 0 else 1 << (i - 1)
- print "%d: \t%10d %3d %3d | %10d %3d %3d" % \
+ print("%d: \t%10d %3d %3d | %10d %3d %3d" % \
(offset, r, pct(r, read_tot),
pct(read_cum, read_tot), w,
pct(w, write_tot),
- pct(write_cum, write_tot))
+ pct(write_cum, write_tot)))
if read_cum == read_tot and write_cum == write_tot:
break
- print
+ print()
return 0
if __name__ == "__main__":
sb = readSU('struct super_block', inode.i_sb)
lsi = readSU('struct lustre_sb_info', sb.s_fs_info)
llsbi = readSU('struct ll_sb_info', lsi.lsi_llsbi)
- print "%x %x %x %x %x" % (Addr(inode), lli, sb, lsi, llsbi)
+ print("%x %x %x %x %x" % (Addr(inode), lli, sb, lsi, llsbi))
def dump_inode_list(inodes):
- print "%-16s %-16s %-16s %-16s %-16s" % ("inode", "ll_inode_info",
- "super_block", "lustre_sb_info", "ll_sb_info")
+ print("%-16s %-16s %-16s %-16s %-16s" % ("inode", "ll_inode_info",
+ "super_block", "lustre_sb_info", "ll_sb_info"))
for addr in inodes:
dump_inode(readSU('struct inode', addr))
"""
for stack_trace, ptask_list in sort:
if printpid and not printptr:
- print "PID: %s" % (', '.join(p[0] for p in ptask_list))
+ print("PID: %s" % (', '.join(p[0] for p in ptask_list)))
elif printpid and printptr:
- print "PID, TSK: %s" % (', '.join(p[0] + ': ' + p[1] for p in ptask_list))
+ print("PID, TSK: %s" % (', '.join(p[0] + ': ' + p[1] for p in ptask_list)))
elif not printpid and printptr:
- print "TSK: %s" % (', '.join(p[1] for p in ptask_list))
- print "TASKS: %d" %(len(ptask_list))
- print "\t%s" %(stack_trace)
+ print("TSK: %s" % (', '.join(p[1] for p in ptask_list)))
+ print("TASKS: %d" %(len(ptask_list)))
+ print("\t%s" %(stack_trace))
def main():
git://git.whamcloud.com / fs / lustre-release.git / commitdiff