gdb: Implement new functions to access vm structs

franciscozdo · franciscozdo · commit 31d0a5cf47c0 · 2023-06-20T10:31:16.000+02:00
diff --git a/sys/debug/__init__.py b/sys/debug/__init__.py
@@ -10,6 +10,7 @@
 from .sync import CondVar, Mutex
 from .thread import Kthread, Thread, CurrentThread
 from .events import stop_handler
+from .nvirtmem import VmInfo
 
 
 def addPrettyPrinters():
@@ -32,6 +33,7 @@ def addPrettyPrinters():
 Kthread()
 Ktrace()
 Kgmon()
+VmInfo()
 
 # Functions
 CurrentThread()
diff --git a/sys/debug/nvirtmem.py b/sys/debug/nvirtmem.py
@@ -0,0 +1,213 @@
+import argparse
+import gdb
+
+from .cmd import UserCommand, CommandDispatcher
+from .proc import Process
+from .utils import TextTable
+from .vm_map import Anon
+
+
+class VmInfo(CommandDispatcher):
+    """Examine virtual memory data structures."""
+
+    def __init__(self):
+        super().__init__('vminfo', [UserPmap(),
+                                    KernPmap(),
+                                    VmMapDump(),
+                                    AnonInfo(),
+                                    SegmentInfo(),
+                                    DumpAnon(),
+                                    ])
+
+
+class UserPmap(UserCommand):
+    """List active page entries in user pmap"""
+
+    def __init__(self):
+        super().__init__('upmap')
+
+    def __call__(self, args):
+        # TODO
+        print(f'Dump user pmap: {args}')
+        print('Not implemented yet!')
+
+
+class KernPmap(UserCommand):
+    """List active page entries in kernel pmap"""
+
+    def __init__(self):
+        super().__init__('kpmap')
+
+    def __call__(self, args):
+        # TODO
+        print(f'Dump user pmap: {args}')
+        print('Not implemented yet!')
+
+
+class VmMapDump(UserCommand):
+    """List segments describing virtual address space"""
+
+    def __init__(self):
+        super().__init__('map')
+
+    def __call__(self, args):
+        parser = argparse.ArgumentParser(
+            description='Launch kernel in a board simulator.')
+        parser.add_argument('-p', '--pid', type=int, default='-1',
+                            help='Pid of proc to display semgent.')
+        parser.add_argument('-s', '--segment', type=int, default='-1',
+                            help='Number of segment to display.')
+        args = parser.parse_args(args=args.split())
+
+        if args.pid == -1:
+            proc = Process.from_current()
+        else:
+            proc = Process.find_by_pid(args.pid)
+
+        entries = proc.p_uspace.get_entries()
+
+        table = TextTable(types='ittttt', align='rrrrrr')
+        table.header(['segment', 'start', 'end', 'prot', 'flags', 'amap'])
+        for idx, seg in enumerate(entries):
+            table.add_row([idx, hex(seg.start), hex(seg.end), seg.prot,
+                           seg.flags, seg.aref])
+        print(table)
+
+
+class SegmentInfo(UserCommand):
+    """Show info about i-th segment in proc vm_map"""
+
+    def __init__(self):
+        super().__init__('seg')
+
+    def _print_segment(self, seg, pid, id):
+        print('------------------------------')
+        print('Segment {} in proc {}'.format(id, pid))
+        print('Range: {:#08x}-{:#08x} ({:d} pages)'.format(seg.start,
+                                                           seg.end,
+                                                           seg.pages))
+        print('Prot:  {}'.format(seg.prot))
+        print('Flags: {}'.format(seg.flags))
+        amap = seg.amap
+        if amap:
+            print('Amap:        {}'.format(seg.amap_ptr))
+            print('Amap offset: {}'.format(seg.amap_offset))
+            print('Amap slots:  {}'.format(amap.slots))
+            print('Amap refs:   {}'.format(amap.ref_cnt))
+        else:
+            print('Amap: NULL')
+
+    def __call__(self, args):
+        parser = argparse.ArgumentParser(
+            description='Launch kernel in a board simulator.')
+        parser.add_argument('-p', '--pid', type=int, default='-1',
+                            help='Pid of proc to display semgent.')
+        parser.add_argument('-s', '--segment', type=int, default='-1',
+                            help='Number of segment to display.')
+        args = parser.parse_args(args=args.split())
+
+        if args.pid == -1:
+            proc = Process.from_current()
+        else:
+            proc = Process.find_by_pid(args.pid)
+
+        entries = proc.p_uspace.get_entries()
+
+        if args.segment > len(entries):
+            print(f'Segment {id} does not exist!')
+            return
+
+        if args.segment == -1:
+            for idx, seg in enumerate(entries):
+                self._print_segment(seg, proc.p_pid, idx)
+        else:
+            self._print_segment(entries[args.segment],
+                                proc.p_pid, args.segment)
+
+
+class AnonInfo(UserCommand):
+    """Dump info about given anon"""
+
+    def __init__(self):
+        super().__init__('anon')
+
+    def __call__(self, args):
+        parser = argparse.ArgumentParser(
+            description='Launch kernel in a board simulator.')
+        parser.add_argument('anon', type=lambda x: int(x, 0),
+                            default='-1', help='Addr of anon to find.')
+        args = parser.parse_args(args=args.split())
+
+        an = Anon(gdb.Value(args.anon)
+                  .cast(gdb.lookup_type('struct vm_anon').pointer()))
+
+        print('Anon page: {}'.format(an.page))
+        print('Anon refs: {}'.format(an.ref_cnt))
+        print('Refs:')
+
+        table = TextTable(types='iiti', align='cccc')
+        table.header(['proc', 'entry', 'range', 'offset'])
+        procs = list(Process.list_all())
+        cnt = 0
+        for p in procs:
+            entries = p.p_uspace.get_entries()
+            for i, e in enumerate(entries):
+                off = e.find_anon(an)
+                if off != -1:
+                    cnt += 1
+                    table.add_row([p.p_pid, i,
+                                   '{:#0x}-{:#0x}'.format(e.start, e.end),
+                                   off])
+        print(table)
+
+        if an.ref_cnt != cnt:
+            print('Anon should be in {} entries. Is in {}.'.format(an.ref_cnt,
+                                                                   cnt))
+
+
+class DumpAnon(UserCommand):
+    """Dump info about given anon"""
+
+    def __init__(self):
+        super().__init__('dump_anon')
+
+    def _dump_anons(self, seg, pid, id):
+        print('------------------------------')
+        print('Segment {} in proc {}'.format(id, pid))
+        print('Range: {:#08x}-{:#08x} ({:d} pages)'.format(seg.start,
+                                                           seg.end,
+                                                           seg.pages))
+        print('Prot:  {}'.format(seg.prot))
+        print('Flags: {}'.format(seg.flags))
+        print('Anons:')
+
+        anons = seg.get_anons()
+        for i, a in anons:
+            print('  {:>3}: {}'.format(i, a))
+
+    def __call__(self, args):
+        parser = argparse.ArgumentParser(
+            description='Launch kernel in a board simulator.')
+        parser.add_argument('-p', '--pid', type=int, default='-1',
+                            help='Pid of proc to display semgent.')
+        parser.add_argument('-s', '--segment', type=int, default='-1',
+                            help='Number of segment to display.')
+        args = parser.parse_args(args=args.split())
+
+        if args.pid == -1:
+            proc = Process.from_current()
+        else:
+            proc = Process.find_by_pid(args.pid)
+
+        entries = proc.p_uspace.get_entries()
+
+        if args.segment > len(entries):
+            print(f'Segment {id} does not exist!')
+            return
+
+        if args.segment == -1:
+            for idx, seg in enumerate(entries):
+                self._dump_anons(seg, proc.p_pid, idx)
+        else:
+            self._dump_anons(entries[args.segment],
+                             proc.p_pid, args.segment)
diff --git a/sys/debug/proc.py b/sys/debug/proc.py
@@ -4,6 +4,7 @@
 from .utils import TextTable, global_var
 from .struct import GdbStructMeta, TailQueue, enum
 from .thread import Thread
+from .vm_map import VmMap
 from .sync import Mutex
 
 
@@ -12,6 +13,7 @@ class Process(metaclass=GdbStructMeta):
     __cast__ = {'p_pid': int,
                 'p_lock': Mutex,
                 'p_thread': Thread,
+                'p_uspace': VmMap,
                 'p_state': enum}
 
     @staticmethod
@@ -32,6 +34,12 @@ def list_all(cls):
         dead = TailQueue(global_var('zombie_list'), 'p_all')
         return map(cls, list(alive) + list(dead))
 
+    @classmethod
+    def find_by_pid(cls, pid):
+        for p in cls.list_all():
+            if p.p_pid == pid:
+                return p
+
     def __repr__(self):
         return 'proc{pid=%d}' % self.p_pid
 
diff --git a/sys/debug/vm_map.py b/sys/debug/vm_map.py
@@ -0,0 +1,118 @@
+import gdb
+from .struct import GdbStructMeta
+from .struct import TailQueue
+
+
+class VmMap(metaclass=GdbStructMeta):
+    __ctype__ = 'struct vm_map'
+
+    def __repr__(self):
+        return 'vm_map[entries=[{} {}], pmap={}]'.format(
+            self.entries, self.nentries, self.pmap)
+
+    def get_entries(self):
+        entries = TailQueue(self.entries, 'link')
+        return [VmMapEntry(e) for e in entries]
+
+
+class VmMapEntry(metaclass=GdbStructMeta):
+    __ctype__ = 'struct vm_map_entry'
+    __cast__ = {'start': int,
+                'end': int}
+
+    def __repr__(self):
+        return 'vm_map_entry[{:#08x}-{:#08x}]'.format(self.start, self.end)
+
+    @property
+    def amap_ptr(self):
+        return self.aref['amap']
+
+    @property
+    def pages(self):
+        size = self.end - self.start
+        return int(size / int(gdb.parse_and_eval('PAGESIZE')))
+
+    @property
+    def amap(self):
+        if int(self.aref['amap']) == 0:
+            return None
+        else:
+            return Amap(self.aref['amap'])
+
+    @property
+    def amap_offset(self):
+        return self.aref['offset']
+
+    def amap_bitmap_str(self):
+        return self.amap.str_bitmap(self.amap_offset, self.pages)
+
+    def get_anon(self, offset):
+        if self.amap is None:
+            return None
+
+        return self.amap.get_anon(self.amap_offset + offset)
+
+    def get_anons(self):
+        if self.amap is None:
+            return []
+
+        return self.amap.get_anons(self.amap_offset, self.pages)
+
+    def find_anon(self, anon):
+        if not self.amap:
+            return -1
+
+        anons = self.amap.get_anons(self.amap_offset, self.pages)
+        for i, a in anons:
+            if a == anon:
+                return i
+
+        return -1
+
+
+def _bitmap_get(bitmap, offset):
+    byte = offset / 8
+    bit = offset % 8
+    return ((bitmap[byte] >> bit) & 1) == 1
+
+
+class Anon(metaclass=GdbStructMeta):
+    __ctype__ = 'struct vm_anon'
+    __cast__ = {'ref_cnt': int}
+
+    def __repr__(self):
+        return 'vm_anon[refs={}, page={:#0x}, addr={:#0x}]'.format(
+            int(self.ref_cnt),
+            int(self.page),
+            int(self._obj))
+
+    @property
+    def addr(self):
+        return int(self._obj)
+
+    def __eq__(self, other):
+        return int(self.addr) == int(other.addr)
+
+
+class Amap(metaclass=GdbStructMeta):
+    __ctype__ = 'struct vm_amap'
+    __cast__ = {'slots': int,
+                'ref_cnt': int}
+
+    def __repr__(self):
+        return 'vm_amap[slots={}, refs={}]'.format(self.slots, self.ref_cnt)
+
+    def _get_bitmap(self):
+        bitmap = []
+        bitssize = ((self.slots) + 7) >> 3
+        for i in range(bitssize):
+            bitmap.append(self.anon_bitmap[i])
+        return bitmap
+
+    def get_anons(self, offset, slots):
+        bitmap = self._get_bitmap()
+        anons = []
+        for i in range(slots):
+            if _bitmap_get(bitmap, offset + i):
+                anons.append((i, Anon(self.anon_list[offset + i])))
+        return anons
