@@ -0,0 +1,19 @@
+
+# GDB
+
+## Python contexts within GDB
+
+Each time gdb enters the Python interpreter it establishes a context.
+Part of the context includes what architecture gdb believes it is
+debugging ('gdbarch') and that is passed into the context.  If anything
+changes the gdbarch in that Python context, it won't be visible to any
+subsequent Python code until a new session is established.
+
+When gdb starts up on x86_64, it uses a gdbarch of i386 -- with 32-bit words
+and pointers.  Only when we load an executable or target does it switch
+to i386:x86_64.
+
+The effect of this is that any code that relys on type information *must*
+be executed in a separate context from the one that loaded the executable
+and/or taret.  Otherwise, any built-in types that are pointers or `long`
+based will use the 32-bit sizes.
@@ -0,0 +1,61 @@
+# Testing
+
+## Summary
+
+There are unit tests in the tests/ dir that are standalone and useful for
+testing basic functionality.
+
+There are unit tests in the kernel-tests dir that require configuration,
+kernel images, debuginfo, and vmcores to use.
+
+## Configuration
+
+The configuration for each kernel/vmcore to be tested goes in a .ini file
+with the following format.  All fields except kernel and vmcore are
+optional, and defaults will be used.  A kernel missing debuginfo cannot
+be used for testing.  Missing modules will mean module-specific tests
+will be skipped.
+
+```[test]
+kernel=/path/to/kernel
+vmcore=/path/to/vmcore
+vmlinux_debuginfo=/path/to/vmlinux-debuginfo
+modules=/path/to/modules
+module_debuginfo_path=/path/to/module/debuginfo
+root=/root/for/tree/searches```
+
+The optional fields match those defined in crash.kernel.CrashKernel.
+
+Example 1:
+```[test]
+kernel=/var/crash/2019-04-23-11:35/vmlinux-4.12.14-150.14-default.gz
+vmcore=/var/crash/2019-04-23-11:35/vmcore```
+
+In this example, the kernel and debuginfo packages are installed in the
+default locations and will be searched automatically.
+
+Example 2:
+```[test]
+kernel=/var/crash/2019-04-23-11:35/vmlinux-4.12.14-150.14-default.gz
+vmcore=/var/crash/2019-04-23-11:35/vmcore
+root=/var/cache/crash-setup/leap15/4.12.14-150.14-default
+```
+
+In this example, the kernel and debuginfo packages are installed under
+/var/cache/crash-setup/leap15/4.12.14-150.14-default and so we only
+specify a root directory.
+
+## Running
+
+The script `test-all.sh` when run with no options will execute only
+the standalone tests.  The script takes a list of the .ini files
+described above and will execute the kernel tests against those
+configurations immediately after the standalone tests.
+
+Example:
+```sh test-all.sh kernel-test-configs/4.12.14-150.14-default.ini kernel-test-configs/5.1.0-rc7-vanilla.ini```
+or
+```sh test-all.sh kernel-test-configs/*.ini```
+
+Each configuration will execute independently from one another.
+
@@ -37,7 +37,7 @@ def __init__(self, name, parser=None):
         self.commands[self.name] = self
         gdb.Command.__init__(self, self.name, gdb.COMMAND_USER)
 
-    def invoke_uncaught(self, argstr, from_tty):
+    def invoke_uncaught(self, argstr, from_tty=False):
         argv = gdb.string_to_argv(argstr)
         args = self.parser.parse_args(argv)
         self.execute(args)
 
@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
+import unittest
+import gdb
+
+def skip_with_type(typename):
+    try:
+        gdbtype = gdb.lookup_type(typename)
+        return unittest.skip(f"found type {typename}")
+    except gdb.error:
+        pass
+
+    return lambda func: func
+
+def skip_without_type(typename):
+    try:
+        gdbtype = gdb.lookup_type(typename)
+    except gdb.error:
+        return unittest.skip(f"missing type {typename}")
+
+    return lambda func: func
+
+def skip_with_symbol(symname):
+    symbol = gdb.lookup_symbol(symname, None)[0]
+    if symbol is not None:
+        return unittest.skip(f"found symbol {symname}")
+
+    return lambda func: func
+
+def skip_without_symbol(symname):
+    symbol = gdb.lookup_symbol(symname, None)[0]
+    if symbol is None:
+        return unittest.skip(f"missing symbol {symname}")
+
+    return lambda func: func
+
+def has_super_blocks(name):
+    from crash.subsystem.filesystem import for_each_super_block
+    for sb in for_each_super_block():
+        if sb['s_type']['name'].string() == name:
+            return True
+    return False
+
+can_test = {}
+
+def skip_with_supers(name):
+    if not name in can_test:
+        can_test[name] = has_super_blocks(name)
+
+    if not can_test[name]:
+        return lambda func: func
+
+    return unittest.skip(f"{name} file systems in image")
+
+def skip_without_supers(name):
+    if not name in can_test:
+        can_test[name] = has_super_blocks(name)
+
+    if can_test[name]:
+        return lambda func: func
+
+    return unittest.skip(f"no {name} file systems in image")
@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
+import unittest
+import gdb
+import io
+import sys
+
+from decorators import skip_with_symbol, skip_without_symbol
+
+from crash.commands.dmesg import LogCommand
+from crash.commands import CommandError, CommandLineError
+
+class TestCommandsLog(unittest.TestCase):
+    def setUp(self):
+        self.stdout = sys.stdout
+        sys.stdout = io.StringIO()
+        self.command = LogCommand("dmesg")
+
+    def tearDown(self):
+        sys.stdout = self.stdout
+
+    def output(self):
+        return sys.stdout.getvalue()
+
+    def test_dmesg(self):
+        """`dmesg' produces valid output"""
+        self.command.invoke_uncaught("")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    def test_dmesg_bad_option(self):
+        """`dmesg -x` raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-x")
+
+    def test_dmesg_t(self):
+        """`dmesg' produces valid output"""
+        self.command.invoke_uncaught("-t")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    @skip_without_symbol('log_first_seq')
+    def test_dmesg_d(self):
+        """`dmesg -d' produces valid output"""
+        self.command.invoke_uncaught("-d")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    @skip_with_symbol('log_first_seq')
+    def test_dmesg_d(self):
+        """`dmesg -d' raises CommandError with unstructured log"""
+        with self.assertRaises(CommandError):
+            self.command.invoke_uncaught("-d")
+
+    def test_dmesg_m(self):
+        """`dmesg -m ' produces valid output"""
+        self.command.invoke_uncaught("-m")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    def test_dmesg_tm(self):
+        """`dmesg -t -m' produces valid output"""
+        self.command.invoke_uncaught("-t -m")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    @skip_without_symbol('log_first_seq')
+    def test_dmesg_td(self):
+        """`dmesg -t -d' produces valid output"""
+        self.command.invoke_uncaught("-t -d")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    @skip_without_symbol('log_first_seq')
+    def test_dmesg_dm(self):
+        """`dmesg -m -d' produces valid output"""
+        self.command.invoke_uncaught("-m -d")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    @skip_without_symbol('log_first_seq')
+    def test_dmesg_tdm(self):
+        """`dmesg -t -d -m' produces valid output"""
+        self.command.invoke_uncaught("-t -d -m")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    @skip_with_symbol('log_first_seq')
+    def test_dmesg_td(self):
+        """`dmesg -t -d' raises CommandError with unstructured log"""
+        with self.assertRaises(CommandError):
+            self.command.invoke_uncaught("-t -d")
+
+    @skip_with_symbol('log_first_seq')
+    def test_dmesg_dm(self):
+        """`dmesg -m -d' raises CommandError with unstructured log"""
+        with self.assertRaises(CommandError):
+            self.command.invoke_uncaught("-m -d")
+
+    @skip_with_symbol('log_first_seq')
+    def test_dmesg_tdm(self):
+        """`dmesg -t -d -m' raises CommandError with unstructured log"""
+        with self.assertRaises(CommandError):
+            self.command.invoke_uncaught("-t -d -m")
+
@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
+import unittest
+import gdb
+import io
+import sys
+
+from decorators import skip_without_symbol
+from decorators import skip_with_symbol
+
+from crash.commands.kmem import KmemCommand
+from crash.commands import CommandLineError, CommandError
+
+class TestCommandsKmem(unittest.TestCase):
+    def setUp(self):
+        self.stdout = sys.stdout
+        sys.stdout = io.StringIO()
+        self.command = KmemCommand("kmem")
+
+    def tearDown(self):
+        sys.stdout = self.stdout
+
+    def output(self):
+        return sys.stdout.getvalue()
+
+    def test_kmem_empty(self):
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("")
+
+    def test_kmem_invalid(self):
+        """`kmem' returns error"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("invalid")
+
+    @unittest.skip("takes a huge amount of time on a real core")
+    def test_kmem_s(self):
+        """`kmem -s' produces valid output"""
+        self.command.invoke_uncaught("-s")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    def test_kmem_s_inode_cache(self):
+        """`kmem -s inode_cache' produces valid output"""
+        self.command.invoke_uncaught("-s inode_cache")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    def test_kmem_s_unknown_cache(self):
+        """`kmem -s unknown_cache' raises CommandError"""
+        with self.assertRaises(CommandError):
+            self.command.invoke_uncaught("-s unknown_cache")
+
+    def test_kmem_sz(self):
+        """`kmem -s -z' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-s -z")
+
+    def test_kmem_sz_valid_cache(self):
+        """`kmem -s -z' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-s inode_cache -z")
+
+    def test_kmem_sz_invalid_cache(self):
+        """`kmem -s unknown_cache -z' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-s unknown_cache -z")
+
+    def test_kmem_sv(self):
+        """`kmem -s -V' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-s -V")
+
+    def test_kmem_sv_valid_cache(self):
+        """`kmem -s inode_cache -V' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-s inode_cache -V")
+
+    def test_kmem_sv_invalid_cache(self):
+        """`kmem -s unknown_cache -V' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-s unknown_cache -V")
+
+    def test_kmem_z(self):
+        """`kmem -z' produces valid output"""
+        self.command.invoke_uncaught("-z")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 2)
+
+    def test_kmem_z_invalid(self):
+        """`kmem -z invalid' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-z invalid")
+
+    @skip_without_symbol('vm_stat')
+    def test_kmem_v(self):
+        """`kmem -V' produces valid output"""
+        self.command.invoke_uncaught("-V")
+        output = self.output()
+        self.assertTrue(len(output.split("\n")) > 0)
+
+    @skip_with_symbol('vm_stat')
+    def test_kmem_v_unimplemented(self):
+        """`kmem -V' raises CommandError due to missing symbol"""
+        with self.assertRaises(CommandError):
+            self.command.invoke_uncaught("-V")
+
+    def test_kmem_v_invalid(self):
+        """`kmem -V invalid' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-V invalid")
+
+    def test_kmem_vz(self):
+        """`kmem -V -z' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-V -z")
+
+    def test_kmem_svz(self):
+        """`kmem -V -z -s' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-V -z -s")
+
+    def test_kmem_svz_valid_cache(self):
+        """`kmem -V -z -s inode_cache' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-V -z -s inode_cache")
+
+    def test_kmem_svz_invalid_cache(self):
+        """`kmem -V -z -s unknown_cache' raises CommandLineError"""
+        with self.assertRaises(CommandLineError):
+            self.command.invoke_uncaught("-V -z -s unknown_cache")