forked from mirrors/linux
276d97d90a
I tried to use these scripts in an ubuntu 14.04 host (gdb 7.7 compiled
against python 3.3) but there were several errors.
I believe this patch fixes these issues so that the commands now work (I
tested lx-symbols, lx-dmesg, lx-lsmod).
Main issues that needed to be resolved:
* In python 2 iterators have a "next()" method. In python 3 it is
__next__() instead (so let's just add both).
* In older python versions there was an implicit conversion
in object.__format__() (used when an object is in string.format())
where it was converting the object to str first and then
calling str's __format__(). This has now been removed so
we must explicitly convert to str the objects for which
we need to keep this behavior.
* In dmesg.py: in python 3 log_buf is now a "memoryview" object
which needs to be converted to a string in order to use string
methods like "splitlines()". Luckily memoryview exists in
python 2.7.6 as well, so we can convert log_buf to memoryview
and use the same code in both python 2 and python 3.
This version of the patch has now been tested with gdb 7.7 and both python
3.4 and python 2.7.6 (I think asking for at least python 2.7.6 is a
reasonable requirement instead of complicating the code with version
checks etc).
Signed-off-by: Pantelis Koukousoulas <pktoss@gmail.com>
Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Jason Wessel <jason.wessel@windriver.com>
Cc: Andi Kleen <andi@firstfloor.org>
Cc: Ben Widawsky <ben@bwidawsk.net>
Cc: Borislav Petkov <bp@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
114 lines
3.2 KiB
Python
114 lines
3.2 KiB
Python
#
|
|
# gdb helper commands and functions for Linux kernel debugging
|
|
#
|
|
# module tools
|
|
#
|
|
# Copyright (c) Siemens AG, 2013
|
|
#
|
|
# Authors:
|
|
# Jan Kiszka <jan.kiszka@siemens.com>
|
|
#
|
|
# This work is licensed under the terms of the GNU GPL version 2.
|
|
#
|
|
|
|
import gdb
|
|
|
|
from linux import cpus, utils
|
|
|
|
|
|
module_type = utils.CachedType("struct module")
|
|
|
|
|
|
class ModuleList:
|
|
def __init__(self):
|
|
global module_type
|
|
self.module_ptr_type = module_type.get_type().pointer()
|
|
modules = gdb.parse_and_eval("modules")
|
|
self.curr_entry = modules['next']
|
|
self.end_of_list = modules.address
|
|
|
|
def __iter__(self):
|
|
return self
|
|
|
|
def __next__(self):
|
|
entry = self.curr_entry
|
|
if entry != self.end_of_list:
|
|
self.curr_entry = entry['next']
|
|
return utils.container_of(entry, self.module_ptr_type, "list")
|
|
else:
|
|
raise StopIteration
|
|
|
|
def next(self):
|
|
return self.__next__()
|
|
|
|
|
|
def find_module_by_name(name):
|
|
for module in ModuleList():
|
|
if module['name'].string() == name:
|
|
return module
|
|
return None
|
|
|
|
|
|
class LxModule(gdb.Function):
|
|
"""Find module by name and return the module variable.
|
|
|
|
$lx_module("MODULE"): Given the name MODULE, iterate over all loaded modules
|
|
of the target and return that module variable which MODULE matches."""
|
|
|
|
def __init__(self):
|
|
super(LxModule, self).__init__("lx_module")
|
|
|
|
def invoke(self, mod_name):
|
|
mod_name = mod_name.string()
|
|
module = find_module_by_name(mod_name)
|
|
if module:
|
|
return module.dereference()
|
|
else:
|
|
raise gdb.GdbError("Unable to find MODULE " + mod_name)
|
|
|
|
|
|
LxModule()
|
|
|
|
|
|
class LxLsmod(gdb.Command):
|
|
"""List currently loaded modules."""
|
|
|
|
_module_use_type = utils.CachedType("struct module_use")
|
|
|
|
def __init__(self):
|
|
super(LxLsmod, self).__init__("lx-lsmod", gdb.COMMAND_DATA)
|
|
|
|
def invoke(self, arg, from_tty):
|
|
gdb.write(
|
|
"Address{0} Module Size Used by\n".format(
|
|
" " if utils.get_long_type().sizeof == 8 else ""))
|
|
|
|
for module in ModuleList():
|
|
ref = 0
|
|
module_refptr = module['refptr']
|
|
for cpu in cpus.CpuList("cpu_possible_mask"):
|
|
refptr = cpus.per_cpu(module_refptr, cpu)
|
|
ref += refptr['incs']
|
|
ref -= refptr['decs']
|
|
|
|
gdb.write("{address} {name:<19} {size:>8} {ref}".format(
|
|
address=str(module['module_core']).split()[0],
|
|
name=module['name'].string(),
|
|
size=str(module['core_size']),
|
|
ref=str(ref)))
|
|
|
|
source_list = module['source_list']
|
|
t = self._module_use_type.get_type().pointer()
|
|
entry = source_list['next']
|
|
first = True
|
|
while entry != source_list.address:
|
|
use = utils.container_of(entry, t, "source_list")
|
|
gdb.write("{separator}{name}".format(
|
|
separator=" " if first else ",",
|
|
name=use['source']['name'].string()))
|
|
first = False
|
|
entry = entry['next']
|
|
gdb.write("\n")
|
|
|
|
|
|
LxLsmod()
|