| ############################################################################ |
| # tools/gdb/memdump.py |
| # |
| # Licensed to the Apache Software Foundation (ASF) under one or more |
| # contributor license agreements. See the NOTICE file distributed with |
| # this work for additional information regarding copyright ownership. The |
| # ASF licenses this file to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance with the |
| # License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| # License for the specific language governing permissions and limitations |
| # under the License. |
| # |
| ############################################################################ |
| |
| import gdb |
| import utils |
| from lists import list_for_each_entry, sq_for_every, sq_is_empty, sq_queue |
| |
| mempool_backtrace = utils.CachedType("struct mempool_backtrace_s") |
| |
| MM_ALLOC_BIT = 0x1 |
| MM_PREVFREE_BIT = 0x2 |
| MM_MASK_BIT = MM_ALLOC_BIT | MM_PREVFREE_BIT |
| |
| |
| PID_MM_FREE = -4 |
| PID_MM_ALLOC = -3 |
| PID_MM_LEAK = -2 |
| PID_MM_MEMPOOL = -1 |
| |
| |
| def mm_foreach(heap): |
| """Iterate over a heap, yielding each node""" |
| node = gdb.Value(heap["mm_heapstart"][0]).cast( |
| gdb.lookup_type("struct mm_allocnode_s").pointer() |
| ) |
| while 1: |
| yield node |
| next = gdb.Value(node).cast(gdb.lookup_type("char").pointer()) |
| next = gdb.Value(next + (node["size"] & ~MM_MASK_BIT)).cast( |
| gdb.lookup_type("struct mm_allocnode_s").pointer() |
| ) |
| if node >= heap["mm_heapend"].dereference() or next == node: |
| break |
| node = next |
| |
| |
| def mempool_multiple_foreach(mpool): |
| """Iterate over all pools in a mempool, yielding each pool""" |
| i = 0 |
| while i < mpool["npools"]: |
| pool = mpool["pools"] + i |
| yield pool |
| i += 1 |
| |
| |
| class Nxmemdump(gdb.Command): |
| """Dump the heap and mempool memory""" |
| |
| def __init__(self): |
| super(Nxmemdump, self).__init__("memdump", gdb.COMMAND_USER) |
| |
| def mempool_dump(self, mpool, pid, seqmin, seqmax): |
| """Dump the mempool memory""" |
| for pool in mempool_multiple_foreach(mpool): |
| if pid == PID_MM_FREE: |
| entry = sq_queue.get_type().pointer() |
| |
| for entry in sq_for_every(pool["queue"], entry): |
| gdb.write("%12u%#*x\n" % (pool["blocksize"], self.align, entry)) |
| self.aordblks += 1 |
| self.uordblks += pool["blocksize"] |
| |
| for entry in sq_for_every(pool["iqueue"], entry): |
| gdb.write("%12u%#*x\n" % (pool["blocksize"], self.align, entry)) |
| self.aordblks += 1 |
| self.uordblks += pool["blocksize"] |
| else: |
| for node in list_for_each_entry( |
| pool["alist"], mempool_backtrace.get_type().pointer(), "node" |
| ): |
| if (pid == node["pid"] or pid == PID_MM_ALLOC) and ( |
| node["seqno"] >= seqmin and node["seqno"] < seqmax |
| ): |
| charnode = gdb.Value(node).cast( |
| gdb.lookup_type("char").pointer() |
| ) |
| gdb.write( |
| "%6d%12u%12u%#*x" |
| % ( |
| node["pid"], |
| pool["blocksize"] & ~MM_MASK_BIT, |
| node["seqno"], |
| self.align, |
| (int)(charnode - pool["blocksize"]), |
| ) |
| ) |
| if node.type.has_key("backtrace"): |
| max = node["backtrace"].type.range()[1] |
| for x in range(0, max): |
| gdb.write(" ") |
| gdb.write( |
| node["backtrace"][x].format_string( |
| raw=False, symbols=True, address=False |
| ) |
| ) |
| |
| gdb.write("\n") |
| self.aordblks += 1 |
| self.uordblks += pool["blocksize"] |
| |
| def memdump(self, pid, seqmin, seqmax): |
| """Dump the heap memory""" |
| if pid >= PID_MM_ALLOC: |
| gdb.write("Dump all used memory node info:\n") |
| gdb.write( |
| "%6s%12s%12s%*s %s\n" |
| % ("PID", "Size", "Sequence", self.align, "Address", "Callstack") |
| ) |
| else: |
| gdb.write("Dump all free memory node info:\n") |
| gdb.write("%12s%*s\n" % ("Size", self.align, "Address")) |
| |
| heap = gdb.parse_and_eval("g_mmheap") |
| if heap.type.has_key("mm_mpool"): |
| self.mempool_dump(heap["mm_mpool"], pid, seqmin, seqmax) |
| |
| for node in mm_foreach(heap): |
| if node["size"] & MM_ALLOC_BIT != 0: |
| if (pid == node["pid"] or (pid == PID_MM_ALLOC and node["pid"] != PID_MM_MEMPOOL)) and ( |
| node["seqno"] >= seqmin and node["seqno"] < seqmax |
| ): |
| charnode = gdb.Value(node).cast(gdb.lookup_type("char").pointer()) |
| gdb.write( |
| "%6d%12u%12u%#*x" |
| % ( |
| node["pid"], |
| node["size"] & ~MM_MASK_BIT, |
| node["seqno"], |
| self.align, |
| (int)( |
| charnode |
| + gdb.lookup_type("struct mm_allocnode_s").sizeof |
| ), |
| ) |
| ) |
| |
| if node.type.has_key("backtrace"): |
| max = node["backtrace"].type.range()[1] |
| for x in range(0, max): |
| gdb.write(" ") |
| gdb.write( |
| node["backtrace"][x].format_string( |
| raw=False, symbols=True, address=False |
| ) |
| ) |
| |
| gdb.write("\n") |
| |
| self.aordblks += 1 |
| self.uordblks += node["size"] & ~MM_MASK_BIT |
| else: |
| if pid == PID_MM_FREE: |
| charnode = gdb.Value(node).cast(gdb.lookup_type("char").pointer()) |
| gdb.write( |
| "%12u%#*x\n" |
| % ( |
| node["size"] & ~MM_MASK_BIT, |
| self.align, |
| (int)( |
| charnode |
| + gdb.lookup_type("struct mm_allocnode_s").sizeof |
| ), |
| ) |
| ) |
| self.aordblks += 1 |
| self.uordblks += node["size"] & ~MM_MASK_BIT |
| |
| gdb.write("%12s%12s\n" % ("Total Blks", "Total Size")) |
| gdb.write("%12d%12d\n" % (self.aordblks, self.uordblks)) |
| |
| def complete(self, text, word): |
| return gdb.COMPLETE_SYMBOL |
| |
| def invoke(self, args, from_tty): |
| if gdb.lookup_type("size_t").sizeof == 4: |
| self.align = 11 |
| else: |
| self.align = 19 |
| |
| arg = args.split(" ") |
| |
| if arg[0] == "": |
| pid = PID_MM_ALLOC |
| elif arg[0] == "used": |
| pid = PID_MM_ALLOC |
| elif arg[0] == "free": |
| pid = PID_MM_LEAK |
| else: |
| pid = int(arg[0]) |
| |
| if len(arg) == 2: |
| seqmin = int(arg[1]) |
| else: |
| seqmin = 0 |
| |
| if len(arg) == 3: |
| seqmax = int(arg[2]) |
| else: |
| seqmax = 0xFFFFFFFF |
| |
| self.aordblks = 0 |
| self.uordblks = 0 |
| self.memdump(pid, seqmin, seqmax) |
| |
| |
| Nxmemdump() |
