WIP: Add new "kcore" target using "drgn" backend

This adds a new "kcore" GDB target which uses "drgn" as the backend for reading from "/proc/kcore"; very similar to the existing "kdump" target which uses "kdumpfile" for reading from a crash dump. The benefit of using this new "kcore" target as opposed to GDB's existing "core" target is twofold: 1. The caching done by the "core" target is not what we want when inspecting a live, running kernel. By moving to a new python based target, we avoid all of this; each read of memory from GDB will call into our target, so we have much more control. 2. The "core" target is unable to properly fetch registers when it's used with "/proc/kcore". By using a python target, we can override the "fetch_registers" function, and do the right thing for fetching registers of kernel threads. Additionally, the code to do this is the same for "/proc/kcore" and a kernel crash dump, so the same code can be used for both the new "kcore" and existing "kdump" targets. Unfortunately though, this new "kcore" target does not solve the issue of thread information being read and cached during startup, meaning we still do not have "live" thread information when using this new target. See also: https://github.com/osandov/drgn Co-authored-by: Prakash Surya <prakash.surya@delphix.com>
prakashsurya · Apr 29, 2019 · Apr 29, 2019 · Sep 19, 2018 · Apr 29, 2019 · Apr 29, 2019
commit 14529d13cd9117f34e691b0541274dce399010e1
diff --git a/crash-kcore.sh b/crash-kcore.sh
@@ -21,20 +21,6 @@ GDBINIT=$(mktemp)
 trap "rm '$GDBINIT'" EXIT
 
 VMLINUX="/usr/lib/debug/boot/vmlinux-$(uname -r)"
-STEXT_KALLSYMS=$(awk '$3 == "_stext" { print $1 }' /proc/kallsyms)
-STEXT_VMLINUX=$(nm "$VMLINUX" | awk '$3 == "_stext" { print $1 }')
-
-#
-# Due to the KASLR done by the kernel, the symbol addresses contained in
-# the "vmlinux" file are not exactly what's used by the running system.
-# To translate the addresses in the "vmlinux" file, to the addresses
-# being used on the live system, we have to offset all of the "vmlinux"
-# addresses by the KASLR offset. Here we determine the KASLR offset by
-# determining the difference between the address of the "_stext" symbol
-# as reported by "/proc/kallsyms" and the "vminlinux" file; this offset
-# is then later fed into GDB when loading the "vmlinux" symbols.
-#
-OFFSET=$(python -c "print(int('$STEXT_KALLSYMS', 16) - int('$STEXT_VMLINUX', 16))")
 
 DIR="$(dirname $0)"
 if [[ -e "$DIR/setup.py" ]]; then
@@ -50,22 +36,18 @@ set python print-stack full
 set height 0
 set print pretty on
 
-add-symbol-file $VMLINUX -o $OFFSET
-target core /proc/kcore
+python
+from kcore.target import Target
+target = Target("$VMLINUX", debug=False)
+end
 
-#
-# Since we're readying from /proc/kcore and the contents of that can
-# change, we disable as much of GDB's caching as we can.
-#
-set stack-cache off
-set code-cache off
-set dcache size 1
-set dcache line-size 2
-set non-stop on
+target drgn /proc/kcore
 
 python
 import crash.session
 x = crash.session.Session(None, None, None)
+target.unregister()
+del target
 end
 EOF
 

diff --git a/kcore/__init__.py b/kcore/__init__.py
diff --git a/kcore/target.py b/kcore/target.py
@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
+
+import gdb
+import drgn
+import sys
+
+
+class Target(gdb.Target):
+    def __init__(self, vmlinux, debug=False):
+        super(Target, self).__init__()
+        self.debug = debug
+        self.shortname = "drgn"
+        self.longname = "Use Linux's /proc/kcore as a target through drgn"
+        self.vmlinux = vmlinux
+        self.register()
+
+    def open(self, filename, from_tty):
+        if filename != "/proc/kcore":
+            raise gdb.GdbError("incorrect file target - should be /proc/kcore")
+
+        self.drgn = drgn.Program()
+        self.drgn.set_kernel()
+
+        try:
+            self.drgn.load_default_debug_info()
+        except drgn.MissingDebugInfoError as e:
+            print(str(e), file=sys.stderr)
+
+        vmcoreinfo = dict(
+            [
+                line.split("=")
+                for line in self.drgn["vmcoreinfo_data"].string_().decode().splitlines()
+            ]
+        )
+        offset = int(vmcoreinfo["KERNELOFFSET"], base=16)
+        gdb.execute("add-symbol-file {} -o {:#x}".format(self.vmlinux, offset))
+        gdb.execute("file {}".format(self.vmlinux))
+
+    def close(self):
+        try:
+            self.unregister()
+        except:
+            pass
+        del self.drgn
+
+    @classmethod
+    def report_error(cls, addr, length, error):
+        print(
+            "Error while reading {:d} bytes from {:#x}: {}".format(
+                length, addr, str(error)
+            ),
+            file=sys.stderr,
+        )
+
+    def xfer_partial(self, obj, annex, readbuf, writebuf, offset, ln):
+        ret = -1
+        if obj == self.TARGET_OBJECT_MEMORY:
+            try:
+                r = self.drgn.read(offset, ln)
+                readbuf[:] = r
+                ret = len(r)
+            except drgn.FaultError as e:
+                if self.debug:
+                    self.report_error(offset, ln, e)
+                raise gdb.TargetXferUnavailable(str(e))
+        else:
+            raise IOError("Unknown obj type")
+        return ret
+
+    def thread_alive(self, ptid):
+        return True
+
+    def pid_to_str(self, ptid):
+        return "pid {:d}".format(ptid[1])
+
+    def fetch_registers(self, register):
+        return False
+
+    def prepare_to_store(self, thread):
+        pass
+
+    # We don't need to store anything; The regcache is already written.
+    def store_registers(self, thread):
+        pass
+
+    def has_execution(self, ptid):
+        return False