scripts/cros_generate_breakpad_symbols_unittest.py

# Copyright 2013 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Test cros_generate_breakpad_symbols."""

import ctypes
import io
import os
from unittest import mock

from chromite.lib import cros_test_lib
from chromite.lib import osutils
from chromite.lib import parallel
from chromite.lib import parallel_unittest
from chromite.lib import partial_mock
from chromite.scripts import cros_generate_breakpad_symbols


class FindDebugDirMock(partial_mock.PartialMock):
    """Mock out the DebugDir helper so we can point it to a tempdir."""

    TARGET = "chromite.scripts.cros_generate_breakpad_symbols"
    ATTRS = ("FindDebugDir",)
    DEFAULT_ATTR = "FindDebugDir"

    def __init__(self, path, *args, **kwargs):
        self.path = path
        super().__init__(*args, **kwargs)

    # pylint: disable=unused-argument
    def FindDebugDir(self, _board, sysroot=None):
        return self.path


# This long decorator triggers a false positive in the docstring test.
# https://github.com/PyCQA/pylint/issues/3077
# pylint: disable=bad-docstring-quotes
@mock.patch(
    "chromite.scripts.cros_generate_breakpad_symbols." "GenerateBreakpadSymbol"
)
class GenerateSymbolsTest(cros_test_lib.MockTempDirTestCase):
    """Test GenerateBreakpadSymbols."""

    def setUp(self):
        self.board = "monkey-board"
        self.board_dir = os.path.join(self.tempdir, "build", self.board)
        self.debug_dir = os.path.join(self.board_dir, "usr", "lib", "debug")
        self.breakpad_dir = os.path.join(self.debug_dir, "breakpad")

        # Generate a tree of files which we'll scan through.
        elf_files = [
            "bin/elf",
            "iii/large-elf",
            # Need some kernel modules (with & without matching .debug).
            "lib/modules/3.10/module.ko",
            "lib/modules/3.10/module-no-debug.ko",
            # Need a file which has an ELF only, but not a .debug.
            "usr/bin/elf-only",
            "usr/sbin/elf",
        ]
        debug_files = [
            "bin/bad-file",
            "bin/elf.debug",
            "iii/large-elf.debug",
            "boot/vmlinux.debug",
            "lib/modules/3.10/module.ko.debug",
            # Need a file which has a .debug only, but not an ELF.
            "sbin/debug-only.debug",
            "usr/sbin/elf.debug",
        ]
        for f in [os.path.join(self.board_dir, x) for x in elf_files] + [
            os.path.join(self.debug_dir, x) for x in debug_files
        ]:
            osutils.Touch(f, makedirs=True)

        # Set up random build dirs and symlinks.
        buildid = os.path.join(self.debug_dir, ".build-id", "00")
        osutils.SafeMakedirs(buildid)
        os.symlink("/asdf", os.path.join(buildid, "foo"))
        os.symlink("/bin/sh", os.path.join(buildid, "foo.debug"))
        os.symlink("/bin/sh", os.path.join(self.debug_dir, "file.debug"))
        osutils.WriteFile(
            os.path.join(self.debug_dir, "iii", "large-elf.debug"),
            "just some content",
        )

        self.StartPatcher(FindDebugDirMock(self.debug_dir))

    def testNormal(self, gen_mock):
        """Verify all the files we expect to get generated do"""
        with parallel_unittest.ParallelMock():
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board, sysroot=self.board_dir
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 5)

            # The largest ELF should be processed first.
            call1 = (
                os.path.join(self.board_dir, "iii/large-elf"),
                os.path.join(self.debug_dir, "iii/large-elf.debug"),
            )
            self.assertEqual(gen_mock.call_args_list[0][0], call1)

            # The other ELFs can be called in any order.
            call2 = (
                os.path.join(self.board_dir, "bin/elf"),
                os.path.join(self.debug_dir, "bin/elf.debug"),
            )
            call3 = (
                os.path.join(self.board_dir, "usr/sbin/elf"),
                os.path.join(self.debug_dir, "usr/sbin/elf.debug"),
            )
            call4 = (
                os.path.join(self.board_dir, "lib/modules/3.10/module.ko"),
                os.path.join(
                    self.debug_dir, "lib/modules/3.10/module.ko.debug"
                ),
            )
            call5 = (
                os.path.join(self.board_dir, "boot/vmlinux"),
                os.path.join(self.debug_dir, "boot/vmlinux.debug"),
            )
            exp_calls = set((call2, call3, call4, call5))
            actual_calls = set(
                (
                    gen_mock.call_args_list[1][0],
                    gen_mock.call_args_list[2][0],
                    gen_mock.call_args_list[3][0],
                    gen_mock.call_args_list[4][0],
                )
            )
            self.assertEqual(exp_calls, actual_calls)

    def testFileList(self, gen_mock):
        """Verify that file_list restricts the symbols generated"""
        with parallel_unittest.ParallelMock():
            call1 = (
                os.path.join(self.board_dir, "usr/sbin/elf"),
                os.path.join(self.debug_dir, "usr/sbin/elf.debug"),
            )

            # Filter with elf path.
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                breakpad_dir=self.breakpad_dir,
                file_list=[os.path.join(self.board_dir, "usr", "sbin", "elf")],
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 1)
            self.assertEqual(gen_mock.call_args_list[0][0], call1)

            # Filter with debug symbols file path.
            gen_mock.reset_mock()
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                breakpad_dir=self.breakpad_dir,
                file_list=[
                    os.path.join(self.debug_dir, "usr", "sbin", "elf.debug")
                ],
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 1)
            self.assertEqual(gen_mock.call_args_list[0][0], call1)

    def testGenLimit(self, gen_mock):
        """Verify generate_count arg works"""
        with parallel_unittest.ParallelMock():
            # Generate nothing!
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                breakpad_dir=self.breakpad_dir,
                generate_count=0,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 0)

            # Generate just one.
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                breakpad_dir=self.breakpad_dir,
                generate_count=1,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 1)

            # The largest ELF should be processed first.
            call1 = (
                os.path.join(self.board_dir, "iii/large-elf"),
                os.path.join(self.debug_dir, "iii/large-elf.debug"),
            )
            self.assertEqual(gen_mock.call_args_list[0][0], call1)

    def testGenErrors(self, gen_mock):
        """Verify we handle errors from generation correctly"""

        def _SetError(*_args, **kwargs):
            kwargs["num_errors"].value += 1
            return 1

        gen_mock.side_effect = _SetError
        with parallel_unittest.ParallelMock():
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board, sysroot=self.board_dir
            )
            self.assertEqual(ret, 5)
            self.assertEqual(gen_mock.call_count, 5)

    def testCleaningTrue(self, gen_mock):
        """Verify behavior of clean_breakpad=True"""
        with parallel_unittest.ParallelMock():
            # Dir does not exist, and then does.
            self.assertNotExists(self.breakpad_dir)
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                generate_count=1,
                clean_breakpad=True,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 1)
            self.assertExists(self.breakpad_dir)

            # Dir exists before & after.
            # File exists, but then doesn't.
            stub_file = os.path.join(self.breakpad_dir, "fooooooooo")
            osutils.Touch(stub_file)
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                generate_count=1,
                clean_breakpad=True,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 2)
            self.assertNotExists(stub_file)

    def testCleaningFalse(self, gen_mock):
        """Verify behavior of clean_breakpad=False"""
        with parallel_unittest.ParallelMock():
            # Dir does not exist, and then does.
            self.assertNotExists(self.breakpad_dir)
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                generate_count=1,
                clean_breakpad=False,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 1)
            self.assertExists(self.breakpad_dir)

            # Dir exists before & after.
            # File exists before & after.
            stub_file = os.path.join(self.breakpad_dir, "fooooooooo")
            osutils.Touch(stub_file)
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board,
                sysroot=self.board_dir,
                generate_count=1,
                clean_breakpad=False,
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 2)
            self.assertExists(stub_file)

    def testExclusionList(self, gen_mock):
        """Verify files in directories of the exclusion list are excluded"""
        exclude_dirs = ["bin", "usr", "fake/dir/fake"]
        with parallel_unittest.ParallelMock():
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbols(
                self.board, sysroot=self.board_dir, exclude_dirs=exclude_dirs
            )
            self.assertEqual(ret, 0)
            self.assertEqual(gen_mock.call_count, 3)


class GenerateSymbolTest(cros_test_lib.RunCommandTempDirTestCase):
    """Test GenerateBreakpadSymbol."""

    def setUp(self):
        self.elf_file = os.path.join(self.tempdir, "elf")
        osutils.Touch(self.elf_file)
        self.debug_dir = os.path.join(self.tempdir, "debug")
        self.debug_file = os.path.join(self.debug_dir, "elf.debug")
        osutils.Touch(self.debug_file, makedirs=True)
        # Not needed as the code itself should create it as needed.
        self.breakpad_dir = os.path.join(self.debug_dir, "breakpad")

        self.FILE_OUT = (
            f"{self.elf_file}: ELF 64-bit LSB pie executable, x86-64, "
            "version 1 (SYSV), dynamically linked, interpreter "
            "/lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, "
            "BuildID[sha1]=cf9a21fa6b14bfb2dfcb76effd713c4536014d95, stripped"
        )
        self.rc.SetDefaultCmdResult(stdout="MODULE OS CPU ID NAME")
        self.rc.AddCmdResult(
            ["/usr/bin/file", self.elf_file], stdout=self.FILE_OUT
        )
        self.assertCommandContains = self.rc.assertCommandContains
        self.sym_file = os.path.join(self.breakpad_dir, "NAME/ID/NAME.sym")

        self.StartPatcher(FindDebugDirMock(self.debug_dir))

    def assertCommandArgs(self, i, args):
        """Helper for looking at the args of the |i|th call"""
        self.assertEqual(self.rc.call_args_list[i][0][0], args)

    def testNormal(self):
        """Normal run -- given an ELF and a debug file"""
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            self.debug_file,
            self.breakpad_dir,
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(self.rc.call_count, 2)
        self.assertCommandArgs(
            1, ["dump_syms", "-v", self.elf_file, self.debug_dir]
        )
        self.assertExists(self.sym_file)

    def testNormalNoCfi(self):
        """Normal run w/out CFI"""
        # Make sure the num_errors flag works too.
        num_errors = ctypes.c_int()
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file,
            breakpad_dir=self.breakpad_dir,
            strip_cfi=True,
            num_errors=num_errors,
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(num_errors.value, 0)
        self.assertCommandArgs(1, ["dump_syms", "-v", "-c", self.elf_file])
        self.assertEqual(self.rc.call_count, 2)
        self.assertExists(self.sym_file)

    def testNormalElfOnly(self):
        """Normal run -- given just an ELF"""
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file, breakpad_dir=self.breakpad_dir
        )
        self.assertEqual(ret, self.sym_file)
        self.assertCommandArgs(1, ["dump_syms", "-v", self.elf_file])
        self.assertEqual(self.rc.call_count, 2)
        self.assertExists(self.sym_file)

    def testNormalSudo(self):
        """Normal run where ELF is readable only by root"""
        with mock.patch.object(os, "access") as mock_access:
            mock_access.return_value = False
            ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
                self.elf_file, breakpad_dir=self.breakpad_dir
            )
        self.assertEqual(ret, self.sym_file)
        self.assertCommandArgs(
            1, ["sudo", "--", "dump_syms", "-v", self.elf_file]
        )

    def testLargeDebugFail(self):
        """Running w/large .debug failed, but retry worked"""
        self.rc.AddCmdResult(
            ["dump_syms", "-v", self.elf_file, self.debug_dir], returncode=1
        )
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file, self.debug_file, self.breakpad_dir
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(self.rc.call_count, 4)
        self.assertCommandArgs(
            1, ["dump_syms", "-v", self.elf_file, self.debug_dir]
        )
        # The current fallback from _DumpExpectingSymbols() to
        # _DumpAllowingBasicFallback() causes the first dump_sums command to get
        # repeated.
        self.assertCommandArgs(
            2, ["dump_syms", "-v", self.elf_file, self.debug_dir]
        )
        self.assertCommandArgs(
            3, ["dump_syms", "-v", "-c", "-r", self.elf_file, self.debug_dir]
        )
        self.assertExists(self.sym_file)

    def testDebugFail(self):
        """Running w/.debug always failed, but works w/out"""
        self.rc.AddCmdResult(
            ["dump_syms", "-v", self.elf_file, self.debug_dir], returncode=1
        )
        self.rc.AddCmdResult(
            ["dump_syms", "-v", "-c", "-r", self.elf_file, self.debug_dir],
            returncode=1,
        )
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file, self.debug_file, self.breakpad_dir
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(self.rc.call_count, 5)
        self.assertCommandArgs(
            1, ["dump_syms", "-v", self.elf_file, self.debug_dir]
        )
        # The current fallback from _DumpExpectingSymbols() to
        # _DumpAllowingBasicFallback() causes the first dump_sums command to get
        # repeated.
        self.assertCommandArgs(
            2, ["dump_syms", "-v", self.elf_file, self.debug_dir]
        )
        self.assertCommandArgs(
            3, ["dump_syms", "-v", "-c", "-r", self.elf_file, self.debug_dir]
        )
        self.assertCommandArgs(4, ["dump_syms", "-v", self.elf_file])
        self.assertExists(self.sym_file)

    def testCompleteFail(self):
        """Running dump_syms always fails"""
        self.rc.SetDefaultCmdResult(returncode=1)
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file, breakpad_dir=self.breakpad_dir
        )
        self.assertEqual(ret, 1)
        # Make sure the num_errors flag works too.
        num_errors = ctypes.c_int()
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            self.elf_file, breakpad_dir=self.breakpad_dir, num_errors=num_errors
        )
        self.assertEqual(ret, 1)
        self.assertEqual(num_errors.value, 1)

    def testKernelObjects(self):
        """Kernel object files should call _DumpAllowingBasicFallback()"""
        ko_file = os.path.join(self.tempdir, "elf.ko")
        osutils.Touch(ko_file)
        self.rc.AddCmdResult(
            ["dump_syms", "-v", ko_file, self.debug_dir], returncode=1
        )
        self.rc.AddCmdResult(
            ["dump_syms", "-v", "-c", "-r", ko_file, self.debug_dir],
            returncode=1,
        )
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            ko_file, self.debug_file, self.breakpad_dir
        )
        self.assertEqual(ret, self.sym_file)
        self.assertEqual(self.rc.call_count, 3)
        # Only one call (at the beginning of _DumpAllowingBasicFallback())
        # to "dump_syms -v"
        self.assertCommandArgs(0, ["dump_syms", "-v", ko_file, self.debug_dir])
        self.assertCommandArgs(
            1, ["dump_syms", "-v", "-c", "-r", ko_file, self.debug_dir]
        )
        self.assertCommandArgs(2, ["dump_syms", "-v", ko_file])
        self.assertExists(self.sym_file)

    def testGoBinary(self):
        """Go binaries should call _DumpAllowingBasicFallback()

        Also tests that dump_syms failing with 'file contains no debugging
        information' does not fail the script.
        """
        go_binary = os.path.join(self.tempdir, "goprogram")
        osutils.Touch(go_binary)
        go_debug_file = os.path.join(self.debug_dir, "goprogram.debug")
        osutils.Touch(go_debug_file, makedirs=True)
        FILE_OUT_GO = go_binary + (
            ": ELF 64-bit LSB executable, x86-64, "
            "version 1 (SYSV), statically linked, "
            "Go BuildID=KKXVlL66E8Qmngr4qll9/5kOKGZw9I7TmNhoqKLqq/SiYVJam6w5Fo39B3BtDo/ba8_ceezZ-3R4qEv6_-K, "
            "not stripped"
        )
        self.rc.AddCmdResult(["/usr/bin/file", go_binary], stdout=FILE_OUT_GO)
        self.rc.AddCmdResult(
            ["dump_syms", "-v", go_binary, self.debug_dir], returncode=1
        )
        self.rc.AddCmdResult(
            ["dump_syms", "-v", "-c", "-r", go_binary, self.debug_dir],
            returncode=1,
        )
        self.rc.AddCmdResult(
            ["dump_syms", "-v", go_binary],
            returncode=1,
            stderr=(
                f"{go_binary}: file contains no debugging information "
                '(no ".stab" or ".debug_info" sections)'
            ),
        )
        num_errors = ctypes.c_int()
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            go_binary, go_debug_file, self.breakpad_dir
        )
        self.assertEqual(ret, 0)
        self.assertEqual(self.rc.call_count, 4)
        self.assertCommandArgs(0, ["/usr/bin/file", go_binary])
        # Only one call (at the beginning of _DumpAllowingBasicFallback())
        # to "dump_syms -v"
        self.assertCommandArgs(
            1, ["dump_syms", "-v", go_binary, self.debug_dir]
        )
        self.assertCommandArgs(
            2, ["dump_syms", "-v", "-c", "-r", go_binary, self.debug_dir]
        )
        self.assertCommandArgs(3, ["dump_syms", "-v", go_binary])
        self.assertNotExists(self.sym_file)
        self.assertEqual(num_errors.value, 0)

    def testAllowlist(self):
        """Binaries in the allowlist should call _DumpAllowingBasicFallback()"""
        binary = os.path.join(self.tempdir, "usr/bin/goldctl")
        osutils.Touch(binary, makedirs=True)
        debug_dir = os.path.join(self.debug_dir, "usr/bin")
        debug_file = os.path.join(debug_dir, "goldctl.debug")
        osutils.Touch(debug_file, makedirs=True)
        self.rc.AddCmdResult(["/usr/bin/file", binary], stdout=self.FILE_OUT)
        self.rc.AddCmdResult(
            ["dump_syms", "-v", binary, debug_dir], returncode=1
        )
        self.rc.AddCmdResult(
            ["dump_syms", "-v", "-c", "-r", binary, debug_dir],
            returncode=1,
        )
        self.rc.AddCmdResult(
            ["dump_syms", "-v", binary],
            returncode=1,
            stderr=(
                f"{binary}: file contains no debugging information "
                '(no ".stab" or ".debug_info" sections)'
            ),
        )
        num_errors = ctypes.c_int()
        ret = cros_generate_breakpad_symbols.GenerateBreakpadSymbol(
            binary, debug_file, self.breakpad_dir, sysroot=self.tempdir
        )
        self.assertEqual(ret, 0)
        self.assertEqual(self.rc.call_count, 4)
        self.assertCommandArgs(0, ["/usr/bin/file", binary])
        # Only one call (at the beginning of _DumpAllowingBasicFallback())
        # to "dump_syms -v"
        self.assertCommandArgs(1, ["dump_syms", "-v", binary, debug_dir])
        self.assertCommandArgs(
            2, ["dump_syms", "-v", "-c", "-r", binary, debug_dir]
        )
        self.assertCommandArgs(3, ["dump_syms", "-v", binary])
        self.assertNotExists(self.sym_file)
        self.assertEqual(num_errors.value, 0)


class UtilsTestDir(cros_test_lib.TempDirTestCase):
    """Tests ReadSymsHeader."""

    def testReadSymsHeaderGoodFile(self):
        """Make sure ReadSymsHeader can parse sym files"""
        sym_file = os.path.join(self.tempdir, "sym")
        osutils.WriteFile(sym_file, "MODULE Linux x86 s0m31D chrooome")
        result = cros_generate_breakpad_symbols.ReadSymsHeader(
            sym_file, "unused_elfname"
        )
        self.assertEqual(result.cpu, "x86")
        self.assertEqual(result.id, "s0m31D")
        self.assertEqual(result.name, "chrooome")
        self.assertEqual(result.os, "Linux")


class UtilsTest(cros_test_lib.TestCase):
    """Tests ReadSymsHeader."""

    def testReadSymsHeaderGoodBuffer(self):
        """Make sure ReadSymsHeader can parse sym file handles"""
        result = cros_generate_breakpad_symbols.ReadSymsHeader(
            io.BytesIO(b"MODULE Linux arm MY-ID-HERE blkid"), "unused_elfname"
        )
        self.assertEqual(result.cpu, "arm")
        self.assertEqual(result.id, "MY-ID-HERE")
        self.assertEqual(result.name, "blkid")
        self.assertEqual(result.os, "Linux")

    def testReadSymsHeaderBadd(self):
        """Make sure ReadSymsHeader throws on bad sym files"""
        self.assertRaises(
            ValueError,
            cros_generate_breakpad_symbols.ReadSymsHeader,
            io.BytesIO(b"asdf"),
            "unused_elfname",
        )

    def testBreakpadDir(self):
        """Make sure board->breakpad path expansion works"""
        expected = "/build/blah/usr/lib/debug/breakpad"
        result = cros_generate_breakpad_symbols.FindBreakpadDir("blah")
        self.assertEqual(expected, result)

    def testDebugDir(self):
        """Make sure board->debug path expansion works"""
        expected = "/build/blah/usr/lib/debug"
        result = cros_generate_breakpad_symbols.FindDebugDir("blah")
        self.assertEqual(expected, result)


def main(_argv):
    # pylint: disable=protected-access
    # Set timeouts small so that if the unit test hangs, it won't hang for long.
    parallel._BackgroundTask.STARTUP_TIMEOUT = 5
    parallel._BackgroundTask.EXIT_TIMEOUT = 5

    # Run the tests.
    cros_test_lib.main(level="info", module=__name__)