{"repo": "0xricksanchez/like-dbg", "n_pairs": 76, "version": "v2_function_scoped", "contexts": {"src/tests/test_debuggee.py::73": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee", "Path", "patch"], "enclosing_function": "test_assert_normal_mode", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_debuggee.py::124": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee"], "enclosing_function": "test_add_smep", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_docker_runner.py::199": {"resolved_imports": ["src/docker_runner.py"], "used_names": ["DockerRunner", "pytest"], "enclosing_function": "test_no_kroot", "extracted_code": "# Source: src/docker_runner.py\nclass DockerRunner:\n    def __init__(self, **kwargs) -> None:\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.update_containers = kwargs.get(\"update_containers\", False)\n        self.ctf = kwargs.get(\"ctf_ctx\", False)\n        self.ssh_conn = None\n        self.image = None\n        self.tag = None\n        self.ssh_fwd_port = None\n        self.container = None\n        cfg_setter(self, [\"general\"], user_cfg=\"\", exclude_keys=[])\n        self.buildargs = {\"USER\": self.user}\n        self.dockerfile_ctx = Path.cwd()\n        self.client = docker.from_env()\n        self.cli = docker.APIClient(base_url=self.docker_sock)\n        if not kwargs.get(\"ctf_ctx\", False):\n            self.kernel_root = kwargs.get(\"kroot\", None)\n            if not self.kernel_root:\n                logger.critical(f\"{type(self).__name__} got invalid kernel root: '{self.kernel_root}'\")\n                exit(-1)\n\n    def guarantee_ssh(self, ssh_dir: Path) -> str:\n        if Path(ssh_dir).exists() and \"like.id_rsa\" in os.listdir(ssh_dir):\n            logger.debug(f\"Reusing local ssh keys from {ssh_dir}...\")\n        else:\n            logger.debug(\"Generating new ssh key pair...\")\n            if not Path(ssh_dir).exists():\n                Path(ssh_dir).mkdir()\n            sp.run(f'ssh-keygen -f {Path(ssh_dir) / \"like.id_rsa\"} -t rsa -N \"\"', shell=True)\n        return str(ssh_dir)\n\n    def init_ssh(self):\n        tries = 0\n        while True:\n            try:\n                self.ssh_conn = Connection(\n                    f\"{self.user}@localhost:{self.ssh_fwd_port}\", connect_kwargs={\"key_filename\": \".ssh/like.id_rsa\"}\n                )\n            except Exception as e:  # noqa PERF203\n                tries += 1\n                logger.error(f\"Failed to initialize SSH connection to {type(self).__name__}: {e}\")\n                logger.error(\"Retrying in 5 seconds...\")\n                if tries >= 5:\n                    logger.critical(f\"{tries} attempts failed! Exiting...\")\n                    exit(-1)\n                time.sleep(5)\n            else:\n                logger.debug(\"Established SSH connection!\")\n                break\n\n    def build_image(self, dockerfile=None, buildargs=None, image_tag=None):\n        dockerfile = dockerfile if dockerfile else self.dockerfile\n        buildargs = buildargs if buildargs else self.buildargs\n        tag = image_tag if image_tag else self.tag\n        nocache = True if self.update_containers else False\n        try:\n            for log_entry in self.cli.build(\n                path=str(self.dockerfile_ctx),\n                dockerfile=dockerfile,\n                tag=tag,\n                decode=True,\n                buildargs=buildargs,\n                nocache=nocache,\n                rm=True,\n            ):\n                v = next(iter(log_entry.values()))\n                if isinstance(v, str):\n                    v = \" \".join(v.strip().split())\n                    if v and not self.update_containers:\n                        logger.debug(v)\n                    elif v and self.update_containers:\n                        logger.info(v)\n            if self.update_containers:\n                self.cli.prune_images(filters={\"dangling\": True})\n            return 0\n        except docker_errors.APIError:\n            return 1\n\n    def get_image(self, tag=None) -> Image:\n        to_check = tag if tag else self.tag\n        try:\n            return self.client.images.get(to_check)\n        except docker_errors.ImageNotFound:\n            return None\n\n    def is_base_image(self) -> bool:\n        if self.get_image(tag=self.tag_base_image):\n            return True\n        else:\n            return False\n\n    def build_base_img(self) -> int:\n        return self.build_image(dockerfile=self.dockerfile_base_img, image_tag=self.tag_base_image)\n\n    def run(self, check_existing: bool = False) -> int:\n        if self.update_containers:\n            self.build_image()\n            return 1\n        if check_existing:\n            self.check_existing()\n        if not self.image:\n            if not self.is_base_image():\n                logger.debug(\"Could not find 'like-dbg'-base image! Building it!\")\n                self.build_base_img()\n            logger.info(f\"Building fresh image for {type(self).__name__}\")\n            self.build_image()\n            self.image = self.get_image()\n        self.run_container()\n        return 0\n\n    def run_container(self) -> None:\n        pass\n\n    def stop_container(self) -> None:\n        self.container.stop()\n\n    def list_running_containers(self) -> list[docker.client.DockerClient.containers]:\n        return self.client.containers.list()\n\n    # This one requires a HEALTHCHECK in the dockerfile\n    def wait_for_container(self) -> None:\n        logger.info(\"Waiting for Container to be up...\")\n        while True:\n            c = self.cli.inspect_container(self.container.id)\n            if c[\"State\"][\"Health\"][\"Status\"] != \"healthy\":\n                time.sleep(1)\n            else:\n                break\n\n    def pull_image(self, repo: str, tag: None) -> Image:\n        tag = tag if tag else self.tag\n        return self.client.images.pull(repo, tag=tag)\n\n    def check_existing(self) -> Image:\n        if self.update_containers:\n            return None\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            return self.image\n        self.image = self.get_image()\n        if self.image and self.skip_prompts:\n            return self.image\n        if self.image and not is_reuse(self.image.tags[0]):\n            self.image = None\n        return self.image", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 5678}, "src/tests/test_kernel_downloader.py::37": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path", "requests"], "enclosing_function": "test_commit", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_kernel_unpacker.py::38": {"resolved_imports": ["src/kernel_unpacker.py"], "used_names": [], "enclosing_function": "test_no_tag", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "src/tests/test_kernel_builder.py::245": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "Path", "patch"], "enclosing_function": "test_apply_patches", "extracted_code": "# Source: src/kernel_builder.py\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8259}, "src/tests/test_debuggee.py::63": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee", "Path"], "enclosing_function": "test_assert_ctf_ctx_mode", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_rootfs_builder.py::18": {"resolved_imports": ["src/docker_runner.py", "src/rootfs_builder.py"], "used_names": ["Path", "RootFSBuilder"], "enclosing_function": "test_is_exist_success", "extracted_code": "# Source: src/rootfs_builder.py\nclass RootFSBuilder(DockerRunner):\n    def __init__(self, partial_run: bool = False, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"rootfs_general\", \"rootfs_builder\"], user_cfg)\n        self.partial = partial_run\n        self.fs_name = self.rootfs_base + self.arch + self.rootfs_ftype\n        self.rootfs_path = self.rootfs_dir + self.fs_name\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n\n    def run_container(self) -> None:\n        try:\n            qemu_arch = adjust_qemu_arch(self.arch)\n            command = f\"/bin/bash -c '{self.script_logging}; . /home/{self.user}/rootfs.sh -n {self.fs_name} -a {qemu_arch} -d {self.distribution} -p {self.packages} -u {self.user}\"\n            if self.hostname:\n                command += f\" -h {self.hostname.strip()}'\"\n            else:\n                command += \"'\"\n            self.container = self.client.containers.run(\n                self.image,\n                volumes={f\"{Path.cwd() / 'io'}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}},\n                detach=True,\n                privileged=True,\n                remove=True,\n                command=command,\n            )\n            gen = self.container.logs(stream=True, follow=True)\n            [logger.info(log.strip().decode()) for log in gen]\n            # self.wait_for_container()\n        except Exception as e:\n            logger.critical(f\"Oops: {e}\")\n            exit(-1)\n\n    def is_exist(self) -> bool:\n        logger.debug(f\"Checking for existing rootfs: {self.rootfs_path}\")\n        if Path(self.rootfs_path).exists():\n            return True\n        else:\n            return False\n\n    def _run(self) -> None:\n        self.image = self.get_image()\n        logger.debug(f\"Found rootfs_builder: {self.image}\")\n        super().run(check_existing=False)\n\n    def run(self) -> None:\n        if self.update_containers:\n            super().run(check_existing=False)\n            return\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            super().run(check_existing=False)\n        else:\n            e = self.is_exist()\n            if self.partial or not e:\n                self._run()\n            elif e and self.skip_prompts:\n                logger.info(f\"Re-using {self.rootfs_path} for file system\")\n                return\n            elif e and is_reuse(self.rootfs_path):\n                return\n            else:\n                self._run()", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 2688}, "src/tests/test_debuggee.py::61": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee", "Path"], "enclosing_function": "test_assert_ctf_ctx_mode", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_kernel_builder.py::127": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "MISC_DRVS_PATH", "Path", "uuid"], "enclosing_function": "test_add_modules", "extracted_code": "# Source: src/kernel_builder.py\nMISC_DRVS_PATH = Path(\"drivers/misc/\")\n\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8299}, "src/tests/test_kernel_unpacker.py::97": {"resolved_imports": ["src/kernel_unpacker.py"], "used_names": ["Path"], "enclosing_function": "test_no_unpack_vmlinux_and_reuse", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "src/tests/test_kernel_downloader.py::9": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader"], "enclosing_function": "test_uris", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_docker_runner.py::56": {"resolved_imports": ["src/docker_runner.py"], "used_names": ["DockerRunner"], "enclosing_function": "test_is_base_image", "extracted_code": "# Source: src/docker_runner.py\nclass DockerRunner:\n    def __init__(self, **kwargs) -> None:\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.update_containers = kwargs.get(\"update_containers\", False)\n        self.ctf = kwargs.get(\"ctf_ctx\", False)\n        self.ssh_conn = None\n        self.image = None\n        self.tag = None\n        self.ssh_fwd_port = None\n        self.container = None\n        cfg_setter(self, [\"general\"], user_cfg=\"\", exclude_keys=[])\n        self.buildargs = {\"USER\": self.user}\n        self.dockerfile_ctx = Path.cwd()\n        self.client = docker.from_env()\n        self.cli = docker.APIClient(base_url=self.docker_sock)\n        if not kwargs.get(\"ctf_ctx\", False):\n            self.kernel_root = kwargs.get(\"kroot\", None)\n            if not self.kernel_root:\n                logger.critical(f\"{type(self).__name__} got invalid kernel root: '{self.kernel_root}'\")\n                exit(-1)\n\n    def guarantee_ssh(self, ssh_dir: Path) -> str:\n        if Path(ssh_dir).exists() and \"like.id_rsa\" in os.listdir(ssh_dir):\n            logger.debug(f\"Reusing local ssh keys from {ssh_dir}...\")\n        else:\n            logger.debug(\"Generating new ssh key pair...\")\n            if not Path(ssh_dir).exists():\n                Path(ssh_dir).mkdir()\n            sp.run(f'ssh-keygen -f {Path(ssh_dir) / \"like.id_rsa\"} -t rsa -N \"\"', shell=True)\n        return str(ssh_dir)\n\n    def init_ssh(self):\n        tries = 0\n        while True:\n            try:\n                self.ssh_conn = Connection(\n                    f\"{self.user}@localhost:{self.ssh_fwd_port}\", connect_kwargs={\"key_filename\": \".ssh/like.id_rsa\"}\n                )\n            except Exception as e:  # noqa PERF203\n                tries += 1\n                logger.error(f\"Failed to initialize SSH connection to {type(self).__name__}: {e}\")\n                logger.error(\"Retrying in 5 seconds...\")\n                if tries >= 5:\n                    logger.critical(f\"{tries} attempts failed! Exiting...\")\n                    exit(-1)\n                time.sleep(5)\n            else:\n                logger.debug(\"Established SSH connection!\")\n                break\n\n    def build_image(self, dockerfile=None, buildargs=None, image_tag=None):\n        dockerfile = dockerfile if dockerfile else self.dockerfile\n        buildargs = buildargs if buildargs else self.buildargs\n        tag = image_tag if image_tag else self.tag\n        nocache = True if self.update_containers else False\n        try:\n            for log_entry in self.cli.build(\n                path=str(self.dockerfile_ctx),\n                dockerfile=dockerfile,\n                tag=tag,\n                decode=True,\n                buildargs=buildargs,\n                nocache=nocache,\n                rm=True,\n            ):\n                v = next(iter(log_entry.values()))\n                if isinstance(v, str):\n                    v = \" \".join(v.strip().split())\n                    if v and not self.update_containers:\n                        logger.debug(v)\n                    elif v and self.update_containers:\n                        logger.info(v)\n            if self.update_containers:\n                self.cli.prune_images(filters={\"dangling\": True})\n            return 0\n        except docker_errors.APIError:\n            return 1\n\n    def get_image(self, tag=None) -> Image:\n        to_check = tag if tag else self.tag\n        try:\n            return self.client.images.get(to_check)\n        except docker_errors.ImageNotFound:\n            return None\n\n    def is_base_image(self) -> bool:\n        if self.get_image(tag=self.tag_base_image):\n            return True\n        else:\n            return False\n\n    def build_base_img(self) -> int:\n        return self.build_image(dockerfile=self.dockerfile_base_img, image_tag=self.tag_base_image)\n\n    def run(self, check_existing: bool = False) -> int:\n        if self.update_containers:\n            self.build_image()\n            return 1\n        if check_existing:\n            self.check_existing()\n        if not self.image:\n            if not self.is_base_image():\n                logger.debug(\"Could not find 'like-dbg'-base image! Building it!\")\n                self.build_base_img()\n            logger.info(f\"Building fresh image for {type(self).__name__}\")\n            self.build_image()\n            self.image = self.get_image()\n        self.run_container()\n        return 0\n\n    def run_container(self) -> None:\n        pass\n\n    def stop_container(self) -> None:\n        self.container.stop()\n\n    def list_running_containers(self) -> list[docker.client.DockerClient.containers]:\n        return self.client.containers.list()\n\n    # This one requires a HEALTHCHECK in the dockerfile\n    def wait_for_container(self) -> None:\n        logger.info(\"Waiting for Container to be up...\")\n        while True:\n            c = self.cli.inspect_container(self.container.id)\n            if c[\"State\"][\"Health\"][\"Status\"] != \"healthy\":\n                time.sleep(1)\n            else:\n                break\n\n    def pull_image(self, repo: str, tag: None) -> Image:\n        tag = tag if tag else self.tag\n        return self.client.images.pull(repo, tag=tag)\n\n    def check_existing(self) -> Image:\n        if self.update_containers:\n            return None\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            return self.image\n        self.image = self.get_image()\n        if self.image and self.skip_prompts:\n            return self.image\n        if self.image and not is_reuse(self.image.tags[0]):\n            self.image = None\n        return self.image", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 5678}, "src/tests/test_kernel_builder.py::253": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "Path", "patch"], "enclosing_function": "test_apply_patches_fail", "extracted_code": "# Source: src/kernel_builder.py\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8259}, "src/tests/test_rootfs_builder.py::11": {"resolved_imports": ["src/docker_runner.py", "src/rootfs_builder.py"], "used_names": ["Path", "RootFSBuilder"], "enclosing_function": "test_is_exist_fail", "extracted_code": "# Source: src/rootfs_builder.py\nclass RootFSBuilder(DockerRunner):\n    def __init__(self, partial_run: bool = False, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"rootfs_general\", \"rootfs_builder\"], user_cfg)\n        self.partial = partial_run\n        self.fs_name = self.rootfs_base + self.arch + self.rootfs_ftype\n        self.rootfs_path = self.rootfs_dir + self.fs_name\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n\n    def run_container(self) -> None:\n        try:\n            qemu_arch = adjust_qemu_arch(self.arch)\n            command = f\"/bin/bash -c '{self.script_logging}; . /home/{self.user}/rootfs.sh -n {self.fs_name} -a {qemu_arch} -d {self.distribution} -p {self.packages} -u {self.user}\"\n            if self.hostname:\n                command += f\" -h {self.hostname.strip()}'\"\n            else:\n                command += \"'\"\n            self.container = self.client.containers.run(\n                self.image,\n                volumes={f\"{Path.cwd() / 'io'}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}},\n                detach=True,\n                privileged=True,\n                remove=True,\n                command=command,\n            )\n            gen = self.container.logs(stream=True, follow=True)\n            [logger.info(log.strip().decode()) for log in gen]\n            # self.wait_for_container()\n        except Exception as e:\n            logger.critical(f\"Oops: {e}\")\n            exit(-1)\n\n    def is_exist(self) -> bool:\n        logger.debug(f\"Checking for existing rootfs: {self.rootfs_path}\")\n        if Path(self.rootfs_path).exists():\n            return True\n        else:\n            return False\n\n    def _run(self) -> None:\n        self.image = self.get_image()\n        logger.debug(f\"Found rootfs_builder: {self.image}\")\n        super().run(check_existing=False)\n\n    def run(self) -> None:\n        if self.update_containers:\n            super().run(check_existing=False)\n            return\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            super().run(check_existing=False)\n        else:\n            e = self.is_exist()\n            if self.partial or not e:\n                self._run()\n            elif e and self.skip_prompts:\n                logger.info(f\"Re-using {self.rootfs_path} for file system\")\n                return\n            elif e and is_reuse(self.rootfs_path):\n                return\n            else:\n                self._run()", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 2688}, "src/tests/test_debuggee.py::99": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee"], "enclosing_function": "test_infer_panic_behavior_wait_split_fail", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_kernel_builder.py::29": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "patch"], "enclosing_function": "test_make_sudo_user", "extracted_code": "# Source: src/kernel_builder.py\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8259}, "src/tests/test_misc.py::49": {"resolved_imports": ["src/debuggee.py", "src/debugger.py", "src/kernel_builder.py", "src/misc.py", "src/rootfs_builder.py"], "used_names": ["adjust_arch", "pytest"], "enclosing_function": "test_adjust_arch", "extracted_code": "# Source: src/misc.py\ndef adjust_arch(arch: str) -> str:\n    if arch == \"riscv64\":\n        return \"riscv\"\n    elif arch in [\"x86_64\", \"arm64\"]:\n        return arch\n    else:\n        logger.error(\"Unknown arch\")\n        exit(-1)", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 227}, "src/tests/test_rootfs_builder.py::64": {"resolved_imports": ["src/docker_runner.py", "src/rootfs_builder.py"], "used_names": ["DockerRunner", "MagicMock", "RootFSBuilder", "patch"], "enclosing_function": "test_run_is_reuse", "extracted_code": "# Source: src/docker_runner.py\nclass DockerRunner:\n    def __init__(self, **kwargs) -> None:\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.update_containers = kwargs.get(\"update_containers\", False)\n        self.ctf = kwargs.get(\"ctf_ctx\", False)\n        self.ssh_conn = None\n        self.image = None\n        self.tag = None\n        self.ssh_fwd_port = None\n        self.container = None\n        cfg_setter(self, [\"general\"], user_cfg=\"\", exclude_keys=[])\n        self.buildargs = {\"USER\": self.user}\n        self.dockerfile_ctx = Path.cwd()\n        self.client = docker.from_env()\n        self.cli = docker.APIClient(base_url=self.docker_sock)\n        if not kwargs.get(\"ctf_ctx\", False):\n            self.kernel_root = kwargs.get(\"kroot\", None)\n            if not self.kernel_root:\n                logger.critical(f\"{type(self).__name__} got invalid kernel root: '{self.kernel_root}'\")\n                exit(-1)\n\n    def guarantee_ssh(self, ssh_dir: Path) -> str:\n        if Path(ssh_dir).exists() and \"like.id_rsa\" in os.listdir(ssh_dir):\n            logger.debug(f\"Reusing local ssh keys from {ssh_dir}...\")\n        else:\n            logger.debug(\"Generating new ssh key pair...\")\n            if not Path(ssh_dir).exists():\n                Path(ssh_dir).mkdir()\n            sp.run(f'ssh-keygen -f {Path(ssh_dir) / \"like.id_rsa\"} -t rsa -N \"\"', shell=True)\n        return str(ssh_dir)\n\n    def init_ssh(self):\n        tries = 0\n        while True:\n            try:\n                self.ssh_conn = Connection(\n                    f\"{self.user}@localhost:{self.ssh_fwd_port}\", connect_kwargs={\"key_filename\": \".ssh/like.id_rsa\"}\n                )\n            except Exception as e:  # noqa PERF203\n                tries += 1\n                logger.error(f\"Failed to initialize SSH connection to {type(self).__name__}: {e}\")\n                logger.error(\"Retrying in 5 seconds...\")\n                if tries >= 5:\n                    logger.critical(f\"{tries} attempts failed! Exiting...\")\n                    exit(-1)\n                time.sleep(5)\n            else:\n                logger.debug(\"Established SSH connection!\")\n                break\n\n    def build_image(self, dockerfile=None, buildargs=None, image_tag=None):\n        dockerfile = dockerfile if dockerfile else self.dockerfile\n        buildargs = buildargs if buildargs else self.buildargs\n        tag = image_tag if image_tag else self.tag\n        nocache = True if self.update_containers else False\n        try:\n            for log_entry in self.cli.build(\n                path=str(self.dockerfile_ctx),\n                dockerfile=dockerfile,\n                tag=tag,\n                decode=True,\n                buildargs=buildargs,\n                nocache=nocache,\n                rm=True,\n            ):\n                v = next(iter(log_entry.values()))\n                if isinstance(v, str):\n                    v = \" \".join(v.strip().split())\n                    if v and not self.update_containers:\n                        logger.debug(v)\n                    elif v and self.update_containers:\n                        logger.info(v)\n            if self.update_containers:\n                self.cli.prune_images(filters={\"dangling\": True})\n            return 0\n        except docker_errors.APIError:\n            return 1\n\n    def get_image(self, tag=None) -> Image:\n        to_check = tag if tag else self.tag\n        try:\n            return self.client.images.get(to_check)\n        except docker_errors.ImageNotFound:\n            return None\n\n    def is_base_image(self) -> bool:\n        if self.get_image(tag=self.tag_base_image):\n            return True\n        else:\n            return False\n\n    def build_base_img(self) -> int:\n        return self.build_image(dockerfile=self.dockerfile_base_img, image_tag=self.tag_base_image)\n\n    def run(self, check_existing: bool = False) -> int:\n        if self.update_containers:\n            self.build_image()\n            return 1\n        if check_existing:\n            self.check_existing()\n        if not self.image:\n            if not self.is_base_image():\n                logger.debug(\"Could not find 'like-dbg'-base image! Building it!\")\n                self.build_base_img()\n            logger.info(f\"Building fresh image for {type(self).__name__}\")\n            self.build_image()\n            self.image = self.get_image()\n        self.run_container()\n        return 0\n\n    def run_container(self) -> None:\n        pass\n\n    def stop_container(self) -> None:\n        self.container.stop()\n\n    def list_running_containers(self) -> list[docker.client.DockerClient.containers]:\n        return self.client.containers.list()\n\n    # This one requires a HEALTHCHECK in the dockerfile\n    def wait_for_container(self) -> None:\n        logger.info(\"Waiting for Container to be up...\")\n        while True:\n            c = self.cli.inspect_container(self.container.id)\n            if c[\"State\"][\"Health\"][\"Status\"] != \"healthy\":\n                time.sleep(1)\n            else:\n                break\n\n    def pull_image(self, repo: str, tag: None) -> Image:\n        tag = tag if tag else self.tag\n        return self.client.images.pull(repo, tag=tag)\n\n    def check_existing(self) -> Image:\n        if self.update_containers:\n            return None\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            return self.image\n        self.image = self.get_image()\n        if self.image and self.skip_prompts:\n            return self.image\n        if self.image and not is_reuse(self.image.tags[0]):\n            self.image = None\n        return self.image\n\n\n# Source: src/rootfs_builder.py\nclass RootFSBuilder(DockerRunner):\n    def __init__(self, partial_run: bool = False, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"rootfs_general\", \"rootfs_builder\"], user_cfg)\n        self.partial = partial_run\n        self.fs_name = self.rootfs_base + self.arch + self.rootfs_ftype\n        self.rootfs_path = self.rootfs_dir + self.fs_name\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n\n    def run_container(self) -> None:\n        try:\n            qemu_arch = adjust_qemu_arch(self.arch)\n            command = f\"/bin/bash -c '{self.script_logging}; . /home/{self.user}/rootfs.sh -n {self.fs_name} -a {qemu_arch} -d {self.distribution} -p {self.packages} -u {self.user}\"\n            if self.hostname:\n                command += f\" -h {self.hostname.strip()}'\"\n            else:\n                command += \"'\"\n            self.container = self.client.containers.run(\n                self.image,\n                volumes={f\"{Path.cwd() / 'io'}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}},\n                detach=True,\n                privileged=True,\n                remove=True,\n                command=command,\n            )\n            gen = self.container.logs(stream=True, follow=True)\n            [logger.info(log.strip().decode()) for log in gen]\n            # self.wait_for_container()\n        except Exception as e:\n            logger.critical(f\"Oops: {e}\")\n            exit(-1)\n\n    def is_exist(self) -> bool:\n        logger.debug(f\"Checking for existing rootfs: {self.rootfs_path}\")\n        if Path(self.rootfs_path).exists():\n            return True\n        else:\n            return False\n\n    def _run(self) -> None:\n        self.image = self.get_image()\n        logger.debug(f\"Found rootfs_builder: {self.image}\")\n        super().run(check_existing=False)\n\n    def run(self) -> None:\n        if self.update_containers:\n            super().run(check_existing=False)\n            return\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            super().run(check_existing=False)\n        else:\n            e = self.is_exist()\n            if self.partial or not e:\n                self._run()\n            elif e and self.skip_prompts:\n                logger.info(f\"Re-using {self.rootfs_path} for file system\")\n                return\n            elif e and is_reuse(self.rootfs_path):\n                return\n            else:\n                self._run()", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 8369}, "src/tests/test_kernel_downloader.py::25": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path", "requests"], "enclosing_function": "test_tag", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_kernel_unpacker.py::75": {"resolved_imports": ["src/kernel_unpacker.py"], "used_names": [], "enclosing_function": "test_unpack_targz_success", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "src/tests/test_misc.py::88": {"resolved_imports": ["src/debuggee.py", "src/debugger.py", "src/kernel_builder.py", "src/misc.py", "src/rootfs_builder.py"], "used_names": ["is_reuse", "patch"], "enclosing_function": "test_is_reuse", "extracted_code": "# Source: src/misc.py\ndef is_reuse(p: str) -> bool:\n    choice = \"y\"\n    logger.info(f\"Found {p}. Re-use it? [Y/n]\")\n    termios.tcflush(stdin, termios.TCIFLUSH)\n    tmp = input().lower()\n    if tmp != \"\":\n        choice = tmp\n    if choice in [\"y\", \"yes\"]:\n        logger.debug(f\"Reusing existing {p}...\")\n        return True\n    else:\n        return False", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 357}, "src/tests/test_kernel_downloader.py::54": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader"], "enclosing_function": "test_version_hierachy", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_kernel_unpacker.py::43": {"resolved_imports": ["src/kernel_unpacker.py"], "used_names": [], "enclosing_function": "test_dst_empty", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "src/tests/test_debuggee.py::87": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee"], "enclosing_function": "test_infer_panic_behavior_halt", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_rootfs_builder.py::25": {"resolved_imports": ["src/docker_runner.py", "src/rootfs_builder.py"], "used_names": ["MagicMock", "Path", "RootFSBuilder"], "enclosing_function": "test_run_container_full_cfg", "extracted_code": "# Source: src/rootfs_builder.py\nclass RootFSBuilder(DockerRunner):\n    def __init__(self, partial_run: bool = False, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"rootfs_general\", \"rootfs_builder\"], user_cfg)\n        self.partial = partial_run\n        self.fs_name = self.rootfs_base + self.arch + self.rootfs_ftype\n        self.rootfs_path = self.rootfs_dir + self.fs_name\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n\n    def run_container(self) -> None:\n        try:\n            qemu_arch = adjust_qemu_arch(self.arch)\n            command = f\"/bin/bash -c '{self.script_logging}; . /home/{self.user}/rootfs.sh -n {self.fs_name} -a {qemu_arch} -d {self.distribution} -p {self.packages} -u {self.user}\"\n            if self.hostname:\n                command += f\" -h {self.hostname.strip()}'\"\n            else:\n                command += \"'\"\n            self.container = self.client.containers.run(\n                self.image,\n                volumes={f\"{Path.cwd() / 'io'}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}},\n                detach=True,\n                privileged=True,\n                remove=True,\n                command=command,\n            )\n            gen = self.container.logs(stream=True, follow=True)\n            [logger.info(log.strip().decode()) for log in gen]\n            # self.wait_for_container()\n        except Exception as e:\n            logger.critical(f\"Oops: {e}\")\n            exit(-1)\n\n    def is_exist(self) -> bool:\n        logger.debug(f\"Checking for existing rootfs: {self.rootfs_path}\")\n        if Path(self.rootfs_path).exists():\n            return True\n        else:\n            return False\n\n    def _run(self) -> None:\n        self.image = self.get_image()\n        logger.debug(f\"Found rootfs_builder: {self.image}\")\n        super().run(check_existing=False)\n\n    def run(self) -> None:\n        if self.update_containers:\n            super().run(check_existing=False)\n            return\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            super().run(check_existing=False)\n        else:\n            e = self.is_exist()\n            if self.partial or not e:\n                self._run()\n            elif e and self.skip_prompts:\n                logger.info(f\"Re-using {self.rootfs_path} for file system\")\n                return\n            elif e and is_reuse(self.rootfs_path):\n                return\n            else:\n                self._run()", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 2688}, "src/tests/test_kernel_downloader.py::18": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path", "requests"], "enclosing_function": "test_mmp", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_kernel_builder.py::236": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "patch", "pytest"], "enclosing_function": "test_make_fail", "extracted_code": "# Source: src/kernel_builder.py\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8259}, "src/tests/test_kernel_builder.py::129": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "MISC_DRVS_PATH", "Path", "uuid"], "enclosing_function": "test_add_modules", "extracted_code": "# Source: src/kernel_builder.py\nMISC_DRVS_PATH = Path(\"drivers/misc/\")\n\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8299}, "src/tests/test_docker_runner.py::40": {"resolved_imports": ["src/docker_runner.py"], "used_names": ["DockerRunner"], "enclosing_function": "test_pull_image", "extracted_code": "# Source: src/docker_runner.py\nclass DockerRunner:\n    def __init__(self, **kwargs) -> None:\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.update_containers = kwargs.get(\"update_containers\", False)\n        self.ctf = kwargs.get(\"ctf_ctx\", False)\n        self.ssh_conn = None\n        self.image = None\n        self.tag = None\n        self.ssh_fwd_port = None\n        self.container = None\n        cfg_setter(self, [\"general\"], user_cfg=\"\", exclude_keys=[])\n        self.buildargs = {\"USER\": self.user}\n        self.dockerfile_ctx = Path.cwd()\n        self.client = docker.from_env()\n        self.cli = docker.APIClient(base_url=self.docker_sock)\n        if not kwargs.get(\"ctf_ctx\", False):\n            self.kernel_root = kwargs.get(\"kroot\", None)\n            if not self.kernel_root:\n                logger.critical(f\"{type(self).__name__} got invalid kernel root: '{self.kernel_root}'\")\n                exit(-1)\n\n    def guarantee_ssh(self, ssh_dir: Path) -> str:\n        if Path(ssh_dir).exists() and \"like.id_rsa\" in os.listdir(ssh_dir):\n            logger.debug(f\"Reusing local ssh keys from {ssh_dir}...\")\n        else:\n            logger.debug(\"Generating new ssh key pair...\")\n            if not Path(ssh_dir).exists():\n                Path(ssh_dir).mkdir()\n            sp.run(f'ssh-keygen -f {Path(ssh_dir) / \"like.id_rsa\"} -t rsa -N \"\"', shell=True)\n        return str(ssh_dir)\n\n    def init_ssh(self):\n        tries = 0\n        while True:\n            try:\n                self.ssh_conn = Connection(\n                    f\"{self.user}@localhost:{self.ssh_fwd_port}\", connect_kwargs={\"key_filename\": \".ssh/like.id_rsa\"}\n                )\n            except Exception as e:  # noqa PERF203\n                tries += 1\n                logger.error(f\"Failed to initialize SSH connection to {type(self).__name__}: {e}\")\n                logger.error(\"Retrying in 5 seconds...\")\n                if tries >= 5:\n                    logger.critical(f\"{tries} attempts failed! Exiting...\")\n                    exit(-1)\n                time.sleep(5)\n            else:\n                logger.debug(\"Established SSH connection!\")\n                break\n\n    def build_image(self, dockerfile=None, buildargs=None, image_tag=None):\n        dockerfile = dockerfile if dockerfile else self.dockerfile\n        buildargs = buildargs if buildargs else self.buildargs\n        tag = image_tag if image_tag else self.tag\n        nocache = True if self.update_containers else False\n        try:\n            for log_entry in self.cli.build(\n                path=str(self.dockerfile_ctx),\n                dockerfile=dockerfile,\n                tag=tag,\n                decode=True,\n                buildargs=buildargs,\n                nocache=nocache,\n                rm=True,\n            ):\n                v = next(iter(log_entry.values()))\n                if isinstance(v, str):\n                    v = \" \".join(v.strip().split())\n                    if v and not self.update_containers:\n                        logger.debug(v)\n                    elif v and self.update_containers:\n                        logger.info(v)\n            if self.update_containers:\n                self.cli.prune_images(filters={\"dangling\": True})\n            return 0\n        except docker_errors.APIError:\n            return 1\n\n    def get_image(self, tag=None) -> Image:\n        to_check = tag if tag else self.tag\n        try:\n            return self.client.images.get(to_check)\n        except docker_errors.ImageNotFound:\n            return None\n\n    def is_base_image(self) -> bool:\n        if self.get_image(tag=self.tag_base_image):\n            return True\n        else:\n            return False\n\n    def build_base_img(self) -> int:\n        return self.build_image(dockerfile=self.dockerfile_base_img, image_tag=self.tag_base_image)\n\n    def run(self, check_existing: bool = False) -> int:\n        if self.update_containers:\n            self.build_image()\n            return 1\n        if check_existing:\n            self.check_existing()\n        if not self.image:\n            if not self.is_base_image():\n                logger.debug(\"Could not find 'like-dbg'-base image! Building it!\")\n                self.build_base_img()\n            logger.info(f\"Building fresh image for {type(self).__name__}\")\n            self.build_image()\n            self.image = self.get_image()\n        self.run_container()\n        return 0\n\n    def run_container(self) -> None:\n        pass\n\n    def stop_container(self) -> None:\n        self.container.stop()\n\n    def list_running_containers(self) -> list[docker.client.DockerClient.containers]:\n        return self.client.containers.list()\n\n    # This one requires a HEALTHCHECK in the dockerfile\n    def wait_for_container(self) -> None:\n        logger.info(\"Waiting for Container to be up...\")\n        while True:\n            c = self.cli.inspect_container(self.container.id)\n            if c[\"State\"][\"Health\"][\"Status\"] != \"healthy\":\n                time.sleep(1)\n            else:\n                break\n\n    def pull_image(self, repo: str, tag: None) -> Image:\n        tag = tag if tag else self.tag\n        return self.client.images.pull(repo, tag=tag)\n\n    def check_existing(self) -> Image:\n        if self.update_containers:\n            return None\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            return self.image\n        self.image = self.get_image()\n        if self.image and self.skip_prompts:\n            return self.image\n        if self.image and not is_reuse(self.image.tags[0]):\n            self.image = None\n        return self.image", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 5678}, "src/tests/test_misc.py::51": {"resolved_imports": ["src/debuggee.py", "src/debugger.py", "src/kernel_builder.py", "src/misc.py", "src/rootfs_builder.py"], "used_names": ["adjust_arch", "pytest"], "enclosing_function": "test_adjust_arch", "extracted_code": "# Source: src/misc.py\ndef adjust_arch(arch: str) -> str:\n    if arch == \"riscv64\":\n        return \"riscv\"\n    elif arch in [\"x86_64\", \"arm64\"]:\n        return arch\n    else:\n        logger.error(\"Unknown arch\")\n        exit(-1)", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 227}, "src/tests/test_kernel_downloader.py::10": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader"], "enclosing_function": "test_uris", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_debugger.py::80": {"resolved_imports": ["src/debugger.py"], "used_names": ["Debugger", "Path"], "enclosing_function": "test_extract_vmlinux_fail", "extracted_code": "# Source: src/debugger.py\nclass Debugger(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"debugger\"], user_cfg, exclude_keys=[\"kernel_root\"])\n        if kwargs.get(\"ctf_ctx\", False):\n            self.ctf = True\n            self._set_ctf_ctx(kwargs)\n        else:\n            self.ctf = False\n            self.project_dir = Path.cwd() / self.kernel_root\n        self.custom_gdb_script = Path(\"/home/\") / self.user / Path(self.gdb_script).name\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.debuggee_name = get_value_from_section_by_key(SYSTEM_CFG, \"debuggee_docker\", \"tag\")\n\n    def _set_ctf_ctx(self, kwargs) -> None:\n        self.ctf_kernel = Path(kwargs.get(\"ctf_kernel\", \"\"))\n        self.project_dir = Path(self.ctf_dir).resolve().absolute()\n        vmlinux = Path(self.project_dir) / \"vmlinux\"\n        if not vmlinux.exists() or b\"ELF\" not in sp.run(f\"file {vmlinux}\", shell=True, capture_output=True).stdout:\n            if self._extract_vmlinux():\n                exit(-1)\n\n    def _extract_vmlinux(self) -> int:\n        vml_ext = next(Path.cwd().rglob(\"extract-vmlinux.sh\")).resolve().absolute()\n        pkernel = self.ctf_kernel.resolve().absolute()\n        with new_context(self.ctf_dir):\n            cmd = f\"{vml_ext} {pkernel}\"\n            ret = sp.run(f\"{cmd}\", shell=True, capture_output=True)\n            if ret.returncode == 0:\n                logger.info(\"Successfully extracted 'vmlinux' from compressed kernel\")\n                return 0\n            else:\n                logger.error(\"Failed to extract 'vmlinux'\")\n                return 1\n\n    def run_container(self) -> None:\n        entrypoint = f'/bin/bash -c \"{self.script_logging}; . /home/{self.user}/debugger.sh -a {self.arch} -p {self.docker_mnt} -c {int(self.ctf)} -g {self.custom_gdb_script} -e {self.ext}\"'\n        runner = f'docker run --pid=container:{self.debuggee_name} -it --rm --security-opt seccomp=unconfined --cap-add=SYS_PTRACE -v {self.project_dir}:/io --net=\"host\" {self.tag} {entrypoint}'\n        tmux(\"selectp -t 2\")\n        tmux_shell(runner)\n\n    @staticmethod\n    def _is_gdb_script_hist() -> bool:\n        return GDB_SCRIPT_HIST.exists()\n\n    def _handle_gdb_change(self) -> None:\n        src = get_sha256_from_file(Path(self.gdb_script))\n        if self._is_gdb_script_hist():\n            dst = GDB_SCRIPT_HIST.read_text()\n            if dst != src:\n                logger.debug(f\"Detected changes in {self.gdb_script}. Rebuilding debugger!\")\n                self.force_rebuild = True\n                GDB_SCRIPT_HIST.write_text(src)\n        else:\n            GDB_SCRIPT_HIST.write_text(src)\n\n    def run(self) -> None:\n        self._handle_gdb_change()\n        super().run(check_existing=True)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2940}, "src/tests/test_debuggee.py::42": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee", "MagicMock", "patch", "pytest"], "enclosing_function": "test_infer_qemu_fs_mount_error", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_kernel_builder.py::225": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "pytest"], "enclosing_function": "test_general_exception", "extracted_code": "# Source: src/kernel_builder.py\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8259}, "src/tests/test_docker_runner.py::69": {"resolved_imports": ["src/docker_runner.py"], "used_names": ["DockerRunner"], "enclosing_function": "test_build_base_image", "extracted_code": "# Source: src/docker_runner.py\nclass DockerRunner:\n    def __init__(self, **kwargs) -> None:\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.update_containers = kwargs.get(\"update_containers\", False)\n        self.ctf = kwargs.get(\"ctf_ctx\", False)\n        self.ssh_conn = None\n        self.image = None\n        self.tag = None\n        self.ssh_fwd_port = None\n        self.container = None\n        cfg_setter(self, [\"general\"], user_cfg=\"\", exclude_keys=[])\n        self.buildargs = {\"USER\": self.user}\n        self.dockerfile_ctx = Path.cwd()\n        self.client = docker.from_env()\n        self.cli = docker.APIClient(base_url=self.docker_sock)\n        if not kwargs.get(\"ctf_ctx\", False):\n            self.kernel_root = kwargs.get(\"kroot\", None)\n            if not self.kernel_root:\n                logger.critical(f\"{type(self).__name__} got invalid kernel root: '{self.kernel_root}'\")\n                exit(-1)\n\n    def guarantee_ssh(self, ssh_dir: Path) -> str:\n        if Path(ssh_dir).exists() and \"like.id_rsa\" in os.listdir(ssh_dir):\n            logger.debug(f\"Reusing local ssh keys from {ssh_dir}...\")\n        else:\n            logger.debug(\"Generating new ssh key pair...\")\n            if not Path(ssh_dir).exists():\n                Path(ssh_dir).mkdir()\n            sp.run(f'ssh-keygen -f {Path(ssh_dir) / \"like.id_rsa\"} -t rsa -N \"\"', shell=True)\n        return str(ssh_dir)\n\n    def init_ssh(self):\n        tries = 0\n        while True:\n            try:\n                self.ssh_conn = Connection(\n                    f\"{self.user}@localhost:{self.ssh_fwd_port}\", connect_kwargs={\"key_filename\": \".ssh/like.id_rsa\"}\n                )\n            except Exception as e:  # noqa PERF203\n                tries += 1\n                logger.error(f\"Failed to initialize SSH connection to {type(self).__name__}: {e}\")\n                logger.error(\"Retrying in 5 seconds...\")\n                if tries >= 5:\n                    logger.critical(f\"{tries} attempts failed! Exiting...\")\n                    exit(-1)\n                time.sleep(5)\n            else:\n                logger.debug(\"Established SSH connection!\")\n                break\n\n    def build_image(self, dockerfile=None, buildargs=None, image_tag=None):\n        dockerfile = dockerfile if dockerfile else self.dockerfile\n        buildargs = buildargs if buildargs else self.buildargs\n        tag = image_tag if image_tag else self.tag\n        nocache = True if self.update_containers else False\n        try:\n            for log_entry in self.cli.build(\n                path=str(self.dockerfile_ctx),\n                dockerfile=dockerfile,\n                tag=tag,\n                decode=True,\n                buildargs=buildargs,\n                nocache=nocache,\n                rm=True,\n            ):\n                v = next(iter(log_entry.values()))\n                if isinstance(v, str):\n                    v = \" \".join(v.strip().split())\n                    if v and not self.update_containers:\n                        logger.debug(v)\n                    elif v and self.update_containers:\n                        logger.info(v)\n            if self.update_containers:\n                self.cli.prune_images(filters={\"dangling\": True})\n            return 0\n        except docker_errors.APIError:\n            return 1\n\n    def get_image(self, tag=None) -> Image:\n        to_check = tag if tag else self.tag\n        try:\n            return self.client.images.get(to_check)\n        except docker_errors.ImageNotFound:\n            return None\n\n    def is_base_image(self) -> bool:\n        if self.get_image(tag=self.tag_base_image):\n            return True\n        else:\n            return False\n\n    def build_base_img(self) -> int:\n        return self.build_image(dockerfile=self.dockerfile_base_img, image_tag=self.tag_base_image)\n\n    def run(self, check_existing: bool = False) -> int:\n        if self.update_containers:\n            self.build_image()\n            return 1\n        if check_existing:\n            self.check_existing()\n        if not self.image:\n            if not self.is_base_image():\n                logger.debug(\"Could not find 'like-dbg'-base image! Building it!\")\n                self.build_base_img()\n            logger.info(f\"Building fresh image for {type(self).__name__}\")\n            self.build_image()\n            self.image = self.get_image()\n        self.run_container()\n        return 0\n\n    def run_container(self) -> None:\n        pass\n\n    def stop_container(self) -> None:\n        self.container.stop()\n\n    def list_running_containers(self) -> list[docker.client.DockerClient.containers]:\n        return self.client.containers.list()\n\n    # This one requires a HEALTHCHECK in the dockerfile\n    def wait_for_container(self) -> None:\n        logger.info(\"Waiting for Container to be up...\")\n        while True:\n            c = self.cli.inspect_container(self.container.id)\n            if c[\"State\"][\"Health\"][\"Status\"] != \"healthy\":\n                time.sleep(1)\n            else:\n                break\n\n    def pull_image(self, repo: str, tag: None) -> Image:\n        tag = tag if tag else self.tag\n        return self.client.images.pull(repo, tag=tag)\n\n    def check_existing(self) -> Image:\n        if self.update_containers:\n            return None\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            return self.image\n        self.image = self.get_image()\n        if self.image and self.skip_prompts:\n            return self.image\n        if self.image and not is_reuse(self.image.tags[0]):\n            self.image = None\n        return self.image", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 5678}, "src/tests/test_kernel_downloader.py::20": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path", "requests"], "enclosing_function": "test_mmp", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_misc.py::188": {"resolved_imports": ["src/debuggee.py", "src/debugger.py", "src/kernel_builder.py", "src/misc.py", "src/rootfs_builder.py"], "used_names": ["RootFSBuilder"], "enclosing_function": "test_cfg_setter_rootfs", "extracted_code": "# Source: src/rootfs_builder.py\nclass RootFSBuilder(DockerRunner):\n    def __init__(self, partial_run: bool = False, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"rootfs_general\", \"rootfs_builder\"], user_cfg)\n        self.partial = partial_run\n        self.fs_name = self.rootfs_base + self.arch + self.rootfs_ftype\n        self.rootfs_path = self.rootfs_dir + self.fs_name\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n\n    def run_container(self) -> None:\n        try:\n            qemu_arch = adjust_qemu_arch(self.arch)\n            command = f\"/bin/bash -c '{self.script_logging}; . /home/{self.user}/rootfs.sh -n {self.fs_name} -a {qemu_arch} -d {self.distribution} -p {self.packages} -u {self.user}\"\n            if self.hostname:\n                command += f\" -h {self.hostname.strip()}'\"\n            else:\n                command += \"'\"\n            self.container = self.client.containers.run(\n                self.image,\n                volumes={f\"{Path.cwd() / 'io'}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}},\n                detach=True,\n                privileged=True,\n                remove=True,\n                command=command,\n            )\n            gen = self.container.logs(stream=True, follow=True)\n            [logger.info(log.strip().decode()) for log in gen]\n            # self.wait_for_container()\n        except Exception as e:\n            logger.critical(f\"Oops: {e}\")\n            exit(-1)\n\n    def is_exist(self) -> bool:\n        logger.debug(f\"Checking for existing rootfs: {self.rootfs_path}\")\n        if Path(self.rootfs_path).exists():\n            return True\n        else:\n            return False\n\n    def _run(self) -> None:\n        self.image = self.get_image()\n        logger.debug(f\"Found rootfs_builder: {self.image}\")\n        super().run(check_existing=False)\n\n    def run(self) -> None:\n        if self.update_containers:\n            super().run(check_existing=False)\n            return\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            super().run(check_existing=False)\n        else:\n            e = self.is_exist()\n            if self.partial or not e:\n                self._run()\n            elif e and self.skip_prompts:\n                logger.info(f\"Re-using {self.rootfs_path} for file system\")\n                return\n            elif e and is_reuse(self.rootfs_path):\n                return\n            else:\n                self._run()", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 2688}, "src/tests/test_debugger.py::21": {"resolved_imports": ["src/debugger.py"], "used_names": ["Debugger", "Path", "patch"], "enclosing_function": "test_is_gdb_script_fail", "extracted_code": "# Source: src/debugger.py\nclass Debugger(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"debugger\"], user_cfg, exclude_keys=[\"kernel_root\"])\n        if kwargs.get(\"ctf_ctx\", False):\n            self.ctf = True\n            self._set_ctf_ctx(kwargs)\n        else:\n            self.ctf = False\n            self.project_dir = Path.cwd() / self.kernel_root\n        self.custom_gdb_script = Path(\"/home/\") / self.user / Path(self.gdb_script).name\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.debuggee_name = get_value_from_section_by_key(SYSTEM_CFG, \"debuggee_docker\", \"tag\")\n\n    def _set_ctf_ctx(self, kwargs) -> None:\n        self.ctf_kernel = Path(kwargs.get(\"ctf_kernel\", \"\"))\n        self.project_dir = Path(self.ctf_dir).resolve().absolute()\n        vmlinux = Path(self.project_dir) / \"vmlinux\"\n        if not vmlinux.exists() or b\"ELF\" not in sp.run(f\"file {vmlinux}\", shell=True, capture_output=True).stdout:\n            if self._extract_vmlinux():\n                exit(-1)\n\n    def _extract_vmlinux(self) -> int:\n        vml_ext = next(Path.cwd().rglob(\"extract-vmlinux.sh\")).resolve().absolute()\n        pkernel = self.ctf_kernel.resolve().absolute()\n        with new_context(self.ctf_dir):\n            cmd = f\"{vml_ext} {pkernel}\"\n            ret = sp.run(f\"{cmd}\", shell=True, capture_output=True)\n            if ret.returncode == 0:\n                logger.info(\"Successfully extracted 'vmlinux' from compressed kernel\")\n                return 0\n            else:\n                logger.error(\"Failed to extract 'vmlinux'\")\n                return 1\n\n    def run_container(self) -> None:\n        entrypoint = f'/bin/bash -c \"{self.script_logging}; . /home/{self.user}/debugger.sh -a {self.arch} -p {self.docker_mnt} -c {int(self.ctf)} -g {self.custom_gdb_script} -e {self.ext}\"'\n        runner = f'docker run --pid=container:{self.debuggee_name} -it --rm --security-opt seccomp=unconfined --cap-add=SYS_PTRACE -v {self.project_dir}:/io --net=\"host\" {self.tag} {entrypoint}'\n        tmux(\"selectp -t 2\")\n        tmux_shell(runner)\n\n    @staticmethod\n    def _is_gdb_script_hist() -> bool:\n        return GDB_SCRIPT_HIST.exists()\n\n    def _handle_gdb_change(self) -> None:\n        src = get_sha256_from_file(Path(self.gdb_script))\n        if self._is_gdb_script_hist():\n            dst = GDB_SCRIPT_HIST.read_text()\n            if dst != src:\n                logger.debug(f\"Detected changes in {self.gdb_script}. Rebuilding debugger!\")\n                self.force_rebuild = True\n                GDB_SCRIPT_HIST.write_text(src)\n        else:\n            GDB_SCRIPT_HIST.write_text(src)\n\n    def run(self) -> None:\n        self._handle_gdb_change()\n        super().run(check_existing=True)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2940}, "src/tests/test_kernel_unpacker.py::49": {"resolved_imports": ["src/kernel_unpacker.py"], "used_names": [], "enclosing_function": "test_dst_not_empty", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "src/tests/test_debuggee.py::134": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee"], "enclosing_function": "test_add_smap", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_kernel_downloader.py::31": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path", "requests"], "enclosing_function": "test_tag", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_debuggee.py::93": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee"], "enclosing_function": "test_infer_panic_behavior_wait_90", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_kernel_builder.py::35": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "patch"], "enclosing_function": "test_make_sudo_root", "extracted_code": "# Source: src/kernel_builder.py\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8259}, "src/tests/test_misc.py::55": {"resolved_imports": ["src/debuggee.py", "src/debugger.py", "src/kernel_builder.py", "src/misc.py", "src/rootfs_builder.py"], "used_names": ["adjust_arch", "pytest"], "enclosing_function": "test_adjust_arch", "extracted_code": "# Source: src/misc.py\ndef adjust_arch(arch: str) -> str:\n    if arch == \"riscv64\":\n        return \"riscv\"\n    elif arch in [\"x86_64\", \"arm64\"]:\n        return arch\n    else:\n        logger.error(\"Unknown arch\")\n        exit(-1)", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 227}, "src/tests/test_misc.py::139": {"resolved_imports": ["src/debuggee.py", "src/debugger.py", "src/kernel_builder.py", "src/misc.py", "src/rootfs_builder.py"], "used_names": ["Mock", "_set_base_cfg", "configparser"], "enclosing_function": "test_set_base_cfg", "extracted_code": "# Source: src/misc.py\ndef _set_base_cfg(cfg, exclude_keys, obj, sections, ignore_empty) -> None:\n    for sect in sections:\n        if sect not in cfg:\n            continue\n        for key in cfg[sect]:\n            if key not in exclude_keys:\n                _set_cfg(cfg, obj, sect, key, ignore_empty)", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 301}, "src/tests/test_debuggee.py::81": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee"], "enclosing_function": "test_infer_panic_behavior_panic", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_docker_runner.py::74": {"resolved_imports": ["src/docker_runner.py"], "used_names": ["DockerRunner"], "enclosing_function": "test_list_running_containers_is_empty", "extracted_code": "# Source: src/docker_runner.py\nclass DockerRunner:\n    def __init__(self, **kwargs) -> None:\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.update_containers = kwargs.get(\"update_containers\", False)\n        self.ctf = kwargs.get(\"ctf_ctx\", False)\n        self.ssh_conn = None\n        self.image = None\n        self.tag = None\n        self.ssh_fwd_port = None\n        self.container = None\n        cfg_setter(self, [\"general\"], user_cfg=\"\", exclude_keys=[])\n        self.buildargs = {\"USER\": self.user}\n        self.dockerfile_ctx = Path.cwd()\n        self.client = docker.from_env()\n        self.cli = docker.APIClient(base_url=self.docker_sock)\n        if not kwargs.get(\"ctf_ctx\", False):\n            self.kernel_root = kwargs.get(\"kroot\", None)\n            if not self.kernel_root:\n                logger.critical(f\"{type(self).__name__} got invalid kernel root: '{self.kernel_root}'\")\n                exit(-1)\n\n    def guarantee_ssh(self, ssh_dir: Path) -> str:\n        if Path(ssh_dir).exists() and \"like.id_rsa\" in os.listdir(ssh_dir):\n            logger.debug(f\"Reusing local ssh keys from {ssh_dir}...\")\n        else:\n            logger.debug(\"Generating new ssh key pair...\")\n            if not Path(ssh_dir).exists():\n                Path(ssh_dir).mkdir()\n            sp.run(f'ssh-keygen -f {Path(ssh_dir) / \"like.id_rsa\"} -t rsa -N \"\"', shell=True)\n        return str(ssh_dir)\n\n    def init_ssh(self):\n        tries = 0\n        while True:\n            try:\n                self.ssh_conn = Connection(\n                    f\"{self.user}@localhost:{self.ssh_fwd_port}\", connect_kwargs={\"key_filename\": \".ssh/like.id_rsa\"}\n                )\n            except Exception as e:  # noqa PERF203\n                tries += 1\n                logger.error(f\"Failed to initialize SSH connection to {type(self).__name__}: {e}\")\n                logger.error(\"Retrying in 5 seconds...\")\n                if tries >= 5:\n                    logger.critical(f\"{tries} attempts failed! Exiting...\")\n                    exit(-1)\n                time.sleep(5)\n            else:\n                logger.debug(\"Established SSH connection!\")\n                break\n\n    def build_image(self, dockerfile=None, buildargs=None, image_tag=None):\n        dockerfile = dockerfile if dockerfile else self.dockerfile\n        buildargs = buildargs if buildargs else self.buildargs\n        tag = image_tag if image_tag else self.tag\n        nocache = True if self.update_containers else False\n        try:\n            for log_entry in self.cli.build(\n                path=str(self.dockerfile_ctx),\n                dockerfile=dockerfile,\n                tag=tag,\n                decode=True,\n                buildargs=buildargs,\n                nocache=nocache,\n                rm=True,\n            ):\n                v = next(iter(log_entry.values()))\n                if isinstance(v, str):\n                    v = \" \".join(v.strip().split())\n                    if v and not self.update_containers:\n                        logger.debug(v)\n                    elif v and self.update_containers:\n                        logger.info(v)\n            if self.update_containers:\n                self.cli.prune_images(filters={\"dangling\": True})\n            return 0\n        except docker_errors.APIError:\n            return 1\n\n    def get_image(self, tag=None) -> Image:\n        to_check = tag if tag else self.tag\n        try:\n            return self.client.images.get(to_check)\n        except docker_errors.ImageNotFound:\n            return None\n\n    def is_base_image(self) -> bool:\n        if self.get_image(tag=self.tag_base_image):\n            return True\n        else:\n            return False\n\n    def build_base_img(self) -> int:\n        return self.build_image(dockerfile=self.dockerfile_base_img, image_tag=self.tag_base_image)\n\n    def run(self, check_existing: bool = False) -> int:\n        if self.update_containers:\n            self.build_image()\n            return 1\n        if check_existing:\n            self.check_existing()\n        if not self.image:\n            if not self.is_base_image():\n                logger.debug(\"Could not find 'like-dbg'-base image! Building it!\")\n                self.build_base_img()\n            logger.info(f\"Building fresh image for {type(self).__name__}\")\n            self.build_image()\n            self.image = self.get_image()\n        self.run_container()\n        return 0\n\n    def run_container(self) -> None:\n        pass\n\n    def stop_container(self) -> None:\n        self.container.stop()\n\n    def list_running_containers(self) -> list[docker.client.DockerClient.containers]:\n        return self.client.containers.list()\n\n    # This one requires a HEALTHCHECK in the dockerfile\n    def wait_for_container(self) -> None:\n        logger.info(\"Waiting for Container to be up...\")\n        while True:\n            c = self.cli.inspect_container(self.container.id)\n            if c[\"State\"][\"Health\"][\"Status\"] != \"healthy\":\n                time.sleep(1)\n            else:\n                break\n\n    def pull_image(self, repo: str, tag: None) -> Image:\n        tag = tag if tag else self.tag\n        return self.client.images.pull(repo, tag=tag)\n\n    def check_existing(self) -> Image:\n        if self.update_containers:\n            return None\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            return self.image\n        self.image = self.get_image()\n        if self.image and self.skip_prompts:\n            return self.image\n        if self.image and not is_reuse(self.image.tags[0]):\n            self.image = None\n        return self.image", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 5678}, "src/tests/test_misc.py::128": {"resolved_imports": ["src/debuggee.py", "src/debugger.py", "src/kernel_builder.py", "src/misc.py", "src/rootfs_builder.py"], "used_names": ["MagicMock", "_cherry_pick", "configparser"], "enclosing_function": "test_cherry_pick", "extracted_code": "# Source: src/misc.py\ndef _cherry_pick(cfg, cherry_pick, obj, ignore_empty) -> None:\n    for sect in cherry_pick.keys():\n        if sect not in cfg:\n            continue\n        for key in cfg[sect]:\n            if key in cherry_pick[sect]:\n                _set_cfg(cfg, obj, sect, key, ignore_empty)", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 300}, "src/tests/test_kernel_downloader.py::56": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader"], "enclosing_function": "test_version_hierachy", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_kernel_downloader.py::52": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader"], "enclosing_function": "test_version_hierachy", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_misc.py::45": {"resolved_imports": ["src/debuggee.py", "src/debugger.py", "src/kernel_builder.py", "src/misc.py", "src/rootfs_builder.py"], "used_names": ["adjust_toolchain_arch"], "enclosing_function": "test_adjust_toolchain_arch", "extracted_code": "# Source: src/misc.py\ndef adjust_toolchain_arch(arch: str) -> str:\n    if arch == \"arm64\":\n        return \"aarch64\"\n    elif arch == \"x86_64\":\n        return \"x86-64\"\n    else:\n        return arch", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 196}, "src/tests/test_rootfs_builder.py::55": {"resolved_imports": ["src/docker_runner.py", "src/rootfs_builder.py"], "used_names": ["DockerRunner", "MagicMock", "RootFSBuilder", "patch"], "enclosing_function": "test__run", "extracted_code": "# Source: src/docker_runner.py\nclass DockerRunner:\n    def __init__(self, **kwargs) -> None:\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.update_containers = kwargs.get(\"update_containers\", False)\n        self.ctf = kwargs.get(\"ctf_ctx\", False)\n        self.ssh_conn = None\n        self.image = None\n        self.tag = None\n        self.ssh_fwd_port = None\n        self.container = None\n        cfg_setter(self, [\"general\"], user_cfg=\"\", exclude_keys=[])\n        self.buildargs = {\"USER\": self.user}\n        self.dockerfile_ctx = Path.cwd()\n        self.client = docker.from_env()\n        self.cli = docker.APIClient(base_url=self.docker_sock)\n        if not kwargs.get(\"ctf_ctx\", False):\n            self.kernel_root = kwargs.get(\"kroot\", None)\n            if not self.kernel_root:\n                logger.critical(f\"{type(self).__name__} got invalid kernel root: '{self.kernel_root}'\")\n                exit(-1)\n\n    def guarantee_ssh(self, ssh_dir: Path) -> str:\n        if Path(ssh_dir).exists() and \"like.id_rsa\" in os.listdir(ssh_dir):\n            logger.debug(f\"Reusing local ssh keys from {ssh_dir}...\")\n        else:\n            logger.debug(\"Generating new ssh key pair...\")\n            if not Path(ssh_dir).exists():\n                Path(ssh_dir).mkdir()\n            sp.run(f'ssh-keygen -f {Path(ssh_dir) / \"like.id_rsa\"} -t rsa -N \"\"', shell=True)\n        return str(ssh_dir)\n\n    def init_ssh(self):\n        tries = 0\n        while True:\n            try:\n                self.ssh_conn = Connection(\n                    f\"{self.user}@localhost:{self.ssh_fwd_port}\", connect_kwargs={\"key_filename\": \".ssh/like.id_rsa\"}\n                )\n            except Exception as e:  # noqa PERF203\n                tries += 1\n                logger.error(f\"Failed to initialize SSH connection to {type(self).__name__}: {e}\")\n                logger.error(\"Retrying in 5 seconds...\")\n                if tries >= 5:\n                    logger.critical(f\"{tries} attempts failed! Exiting...\")\n                    exit(-1)\n                time.sleep(5)\n            else:\n                logger.debug(\"Established SSH connection!\")\n                break\n\n    def build_image(self, dockerfile=None, buildargs=None, image_tag=None):\n        dockerfile = dockerfile if dockerfile else self.dockerfile\n        buildargs = buildargs if buildargs else self.buildargs\n        tag = image_tag if image_tag else self.tag\n        nocache = True if self.update_containers else False\n        try:\n            for log_entry in self.cli.build(\n                path=str(self.dockerfile_ctx),\n                dockerfile=dockerfile,\n                tag=tag,\n                decode=True,\n                buildargs=buildargs,\n                nocache=nocache,\n                rm=True,\n            ):\n                v = next(iter(log_entry.values()))\n                if isinstance(v, str):\n                    v = \" \".join(v.strip().split())\n                    if v and not self.update_containers:\n                        logger.debug(v)\n                    elif v and self.update_containers:\n                        logger.info(v)\n            if self.update_containers:\n                self.cli.prune_images(filters={\"dangling\": True})\n            return 0\n        except docker_errors.APIError:\n            return 1\n\n    def get_image(self, tag=None) -> Image:\n        to_check = tag if tag else self.tag\n        try:\n            return self.client.images.get(to_check)\n        except docker_errors.ImageNotFound:\n            return None\n\n    def is_base_image(self) -> bool:\n        if self.get_image(tag=self.tag_base_image):\n            return True\n        else:\n            return False\n\n    def build_base_img(self) -> int:\n        return self.build_image(dockerfile=self.dockerfile_base_img, image_tag=self.tag_base_image)\n\n    def run(self, check_existing: bool = False) -> int:\n        if self.update_containers:\n            self.build_image()\n            return 1\n        if check_existing:\n            self.check_existing()\n        if not self.image:\n            if not self.is_base_image():\n                logger.debug(\"Could not find 'like-dbg'-base image! Building it!\")\n                self.build_base_img()\n            logger.info(f\"Building fresh image for {type(self).__name__}\")\n            self.build_image()\n            self.image = self.get_image()\n        self.run_container()\n        return 0\n\n    def run_container(self) -> None:\n        pass\n\n    def stop_container(self) -> None:\n        self.container.stop()\n\n    def list_running_containers(self) -> list[docker.client.DockerClient.containers]:\n        return self.client.containers.list()\n\n    # This one requires a HEALTHCHECK in the dockerfile\n    def wait_for_container(self) -> None:\n        logger.info(\"Waiting for Container to be up...\")\n        while True:\n            c = self.cli.inspect_container(self.container.id)\n            if c[\"State\"][\"Health\"][\"Status\"] != \"healthy\":\n                time.sleep(1)\n            else:\n                break\n\n    def pull_image(self, repo: str, tag: None) -> Image:\n        tag = tag if tag else self.tag\n        return self.client.images.pull(repo, tag=tag)\n\n    def check_existing(self) -> Image:\n        if self.update_containers:\n            return None\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            return self.image\n        self.image = self.get_image()\n        if self.image and self.skip_prompts:\n            return self.image\n        if self.image and not is_reuse(self.image.tags[0]):\n            self.image = None\n        return self.image\n\n\n# Source: src/rootfs_builder.py\nclass RootFSBuilder(DockerRunner):\n    def __init__(self, partial_run: bool = False, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"rootfs_general\", \"rootfs_builder\"], user_cfg)\n        self.partial = partial_run\n        self.fs_name = self.rootfs_base + self.arch + self.rootfs_ftype\n        self.rootfs_path = self.rootfs_dir + self.fs_name\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n\n    def run_container(self) -> None:\n        try:\n            qemu_arch = adjust_qemu_arch(self.arch)\n            command = f\"/bin/bash -c '{self.script_logging}; . /home/{self.user}/rootfs.sh -n {self.fs_name} -a {qemu_arch} -d {self.distribution} -p {self.packages} -u {self.user}\"\n            if self.hostname:\n                command += f\" -h {self.hostname.strip()}'\"\n            else:\n                command += \"'\"\n            self.container = self.client.containers.run(\n                self.image,\n                volumes={f\"{Path.cwd() / 'io'}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}},\n                detach=True,\n                privileged=True,\n                remove=True,\n                command=command,\n            )\n            gen = self.container.logs(stream=True, follow=True)\n            [logger.info(log.strip().decode()) for log in gen]\n            # self.wait_for_container()\n        except Exception as e:\n            logger.critical(f\"Oops: {e}\")\n            exit(-1)\n\n    def is_exist(self) -> bool:\n        logger.debug(f\"Checking for existing rootfs: {self.rootfs_path}\")\n        if Path(self.rootfs_path).exists():\n            return True\n        else:\n            return False\n\n    def _run(self) -> None:\n        self.image = self.get_image()\n        logger.debug(f\"Found rootfs_builder: {self.image}\")\n        super().run(check_existing=False)\n\n    def run(self) -> None:\n        if self.update_containers:\n            super().run(check_existing=False)\n            return\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            super().run(check_existing=False)\n        else:\n            e = self.is_exist()\n            if self.partial or not e:\n                self._run()\n            elif e and self.skip_prompts:\n                logger.info(f\"Re-using {self.rootfs_path} for file system\")\n                return\n            elif e and is_reuse(self.rootfs_path):\n                return\n            else:\n                self._run()", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 8369}, "src/tests/test_kernel_downloader.py::36": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path", "requests"], "enclosing_function": "test_commit", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_kernel_builder.py::223": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "pytest"], "enclosing_function": "test_general_exception", "extracted_code": "# Source: src/kernel_builder.py\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8259}, "src/tests/test_docker_runner.py::191": {"resolved_imports": ["src/docker_runner.py"], "used_names": ["DockerRunner", "Path", "shutil", "uuid"], "enclosing_function": "test_guarantee_new_ssh", "extracted_code": "# Source: src/docker_runner.py\nclass DockerRunner:\n    def __init__(self, **kwargs) -> None:\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.update_containers = kwargs.get(\"update_containers\", False)\n        self.ctf = kwargs.get(\"ctf_ctx\", False)\n        self.ssh_conn = None\n        self.image = None\n        self.tag = None\n        self.ssh_fwd_port = None\n        self.container = None\n        cfg_setter(self, [\"general\"], user_cfg=\"\", exclude_keys=[])\n        self.buildargs = {\"USER\": self.user}\n        self.dockerfile_ctx = Path.cwd()\n        self.client = docker.from_env()\n        self.cli = docker.APIClient(base_url=self.docker_sock)\n        if not kwargs.get(\"ctf_ctx\", False):\n            self.kernel_root = kwargs.get(\"kroot\", None)\n            if not self.kernel_root:\n                logger.critical(f\"{type(self).__name__} got invalid kernel root: '{self.kernel_root}'\")\n                exit(-1)\n\n    def guarantee_ssh(self, ssh_dir: Path) -> str:\n        if Path(ssh_dir).exists() and \"like.id_rsa\" in os.listdir(ssh_dir):\n            logger.debug(f\"Reusing local ssh keys from {ssh_dir}...\")\n        else:\n            logger.debug(\"Generating new ssh key pair...\")\n            if not Path(ssh_dir).exists():\n                Path(ssh_dir).mkdir()\n            sp.run(f'ssh-keygen -f {Path(ssh_dir) / \"like.id_rsa\"} -t rsa -N \"\"', shell=True)\n        return str(ssh_dir)\n\n    def init_ssh(self):\n        tries = 0\n        while True:\n            try:\n                self.ssh_conn = Connection(\n                    f\"{self.user}@localhost:{self.ssh_fwd_port}\", connect_kwargs={\"key_filename\": \".ssh/like.id_rsa\"}\n                )\n            except Exception as e:  # noqa PERF203\n                tries += 1\n                logger.error(f\"Failed to initialize SSH connection to {type(self).__name__}: {e}\")\n                logger.error(\"Retrying in 5 seconds...\")\n                if tries >= 5:\n                    logger.critical(f\"{tries} attempts failed! Exiting...\")\n                    exit(-1)\n                time.sleep(5)\n            else:\n                logger.debug(\"Established SSH connection!\")\n                break\n\n    def build_image(self, dockerfile=None, buildargs=None, image_tag=None):\n        dockerfile = dockerfile if dockerfile else self.dockerfile\n        buildargs = buildargs if buildargs else self.buildargs\n        tag = image_tag if image_tag else self.tag\n        nocache = True if self.update_containers else False\n        try:\n            for log_entry in self.cli.build(\n                path=str(self.dockerfile_ctx),\n                dockerfile=dockerfile,\n                tag=tag,\n                decode=True,\n                buildargs=buildargs,\n                nocache=nocache,\n                rm=True,\n            ):\n                v = next(iter(log_entry.values()))\n                if isinstance(v, str):\n                    v = \" \".join(v.strip().split())\n                    if v and not self.update_containers:\n                        logger.debug(v)\n                    elif v and self.update_containers:\n                        logger.info(v)\n            if self.update_containers:\n                self.cli.prune_images(filters={\"dangling\": True})\n            return 0\n        except docker_errors.APIError:\n            return 1\n\n    def get_image(self, tag=None) -> Image:\n        to_check = tag if tag else self.tag\n        try:\n            return self.client.images.get(to_check)\n        except docker_errors.ImageNotFound:\n            return None\n\n    def is_base_image(self) -> bool:\n        if self.get_image(tag=self.tag_base_image):\n            return True\n        else:\n            return False\n\n    def build_base_img(self) -> int:\n        return self.build_image(dockerfile=self.dockerfile_base_img, image_tag=self.tag_base_image)\n\n    def run(self, check_existing: bool = False) -> int:\n        if self.update_containers:\n            self.build_image()\n            return 1\n        if check_existing:\n            self.check_existing()\n        if not self.image:\n            if not self.is_base_image():\n                logger.debug(\"Could not find 'like-dbg'-base image! Building it!\")\n                self.build_base_img()\n            logger.info(f\"Building fresh image for {type(self).__name__}\")\n            self.build_image()\n            self.image = self.get_image()\n        self.run_container()\n        return 0\n\n    def run_container(self) -> None:\n        pass\n\n    def stop_container(self) -> None:\n        self.container.stop()\n\n    def list_running_containers(self) -> list[docker.client.DockerClient.containers]:\n        return self.client.containers.list()\n\n    # This one requires a HEALTHCHECK in the dockerfile\n    def wait_for_container(self) -> None:\n        logger.info(\"Waiting for Container to be up...\")\n        while True:\n            c = self.cli.inspect_container(self.container.id)\n            if c[\"State\"][\"Health\"][\"Status\"] != \"healthy\":\n                time.sleep(1)\n            else:\n                break\n\n    def pull_image(self, repo: str, tag: None) -> Image:\n        tag = tag if tag else self.tag\n        return self.client.images.pull(repo, tag=tag)\n\n    def check_existing(self) -> Image:\n        if self.update_containers:\n            return None\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            return self.image\n        self.image = self.get_image()\n        if self.image and self.skip_prompts:\n            return self.image\n        if self.image and not is_reuse(self.image.tags[0]):\n            self.image = None\n        return self.image", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 5678}, "src/tests/test_debugger.py::71": {"resolved_imports": ["src/debugger.py"], "used_names": ["Debugger"], "enclosing_function": "test_extract_vmlinux_success", "extracted_code": "# Source: src/debugger.py\nclass Debugger(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"debugger\"], user_cfg, exclude_keys=[\"kernel_root\"])\n        if kwargs.get(\"ctf_ctx\", False):\n            self.ctf = True\n            self._set_ctf_ctx(kwargs)\n        else:\n            self.ctf = False\n            self.project_dir = Path.cwd() / self.kernel_root\n        self.custom_gdb_script = Path(\"/home/\") / self.user / Path(self.gdb_script).name\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.debuggee_name = get_value_from_section_by_key(SYSTEM_CFG, \"debuggee_docker\", \"tag\")\n\n    def _set_ctf_ctx(self, kwargs) -> None:\n        self.ctf_kernel = Path(kwargs.get(\"ctf_kernel\", \"\"))\n        self.project_dir = Path(self.ctf_dir).resolve().absolute()\n        vmlinux = Path(self.project_dir) / \"vmlinux\"\n        if not vmlinux.exists() or b\"ELF\" not in sp.run(f\"file {vmlinux}\", shell=True, capture_output=True).stdout:\n            if self._extract_vmlinux():\n                exit(-1)\n\n    def _extract_vmlinux(self) -> int:\n        vml_ext = next(Path.cwd().rglob(\"extract-vmlinux.sh\")).resolve().absolute()\n        pkernel = self.ctf_kernel.resolve().absolute()\n        with new_context(self.ctf_dir):\n            cmd = f\"{vml_ext} {pkernel}\"\n            ret = sp.run(f\"{cmd}\", shell=True, capture_output=True)\n            if ret.returncode == 0:\n                logger.info(\"Successfully extracted 'vmlinux' from compressed kernel\")\n                return 0\n            else:\n                logger.error(\"Failed to extract 'vmlinux'\")\n                return 1\n\n    def run_container(self) -> None:\n        entrypoint = f'/bin/bash -c \"{self.script_logging}; . /home/{self.user}/debugger.sh -a {self.arch} -p {self.docker_mnt} -c {int(self.ctf)} -g {self.custom_gdb_script} -e {self.ext}\"'\n        runner = f'docker run --pid=container:{self.debuggee_name} -it --rm --security-opt seccomp=unconfined --cap-add=SYS_PTRACE -v {self.project_dir}:/io --net=\"host\" {self.tag} {entrypoint}'\n        tmux(\"selectp -t 2\")\n        tmux_shell(runner)\n\n    @staticmethod\n    def _is_gdb_script_hist() -> bool:\n        return GDB_SCRIPT_HIST.exists()\n\n    def _handle_gdb_change(self) -> None:\n        src = get_sha256_from_file(Path(self.gdb_script))\n        if self._is_gdb_script_hist():\n            dst = GDB_SCRIPT_HIST.read_text()\n            if dst != src:\n                logger.debug(f\"Detected changes in {self.gdb_script}. Rebuilding debugger!\")\n                self.force_rebuild = True\n                GDB_SCRIPT_HIST.write_text(src)\n        else:\n            GDB_SCRIPT_HIST.write_text(src)\n\n    def run(self) -> None:\n        self._handle_gdb_change()\n        super().run(check_existing=True)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2940}, "src/tests/test_misc.py::111": {"resolved_imports": ["src/debuggee.py", "src/debugger.py", "src/kernel_builder.py", "src/misc.py", "src/rootfs_builder.py"], "used_names": ["MagicMock", "_set_cfg", "configparser"], "enclosing_function": "test_set_cfg_not_ignore_empty", "extracted_code": "# Source: src/misc.py\ndef _set_cfg(cfg, obj, sect, key, ignore_empty) -> None:\n    tmp = cfg[sect][key]\n    if ignore_empty and not tmp:\n        return\n    val = tmp if tmp not in [\"yes\", \"no\"] else cfg[sect].getboolean(key)\n    setattr(obj, key, val)", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 251}, "src/tests/test_docker_runner.py::135": {"resolved_imports": ["src/docker_runner.py"], "used_names": ["DockerRunner"], "enclosing_function": "test_run_update", "extracted_code": "# Source: src/docker_runner.py\nclass DockerRunner:\n    def __init__(self, **kwargs) -> None:\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.update_containers = kwargs.get(\"update_containers\", False)\n        self.ctf = kwargs.get(\"ctf_ctx\", False)\n        self.ssh_conn = None\n        self.image = None\n        self.tag = None\n        self.ssh_fwd_port = None\n        self.container = None\n        cfg_setter(self, [\"general\"], user_cfg=\"\", exclude_keys=[])\n        self.buildargs = {\"USER\": self.user}\n        self.dockerfile_ctx = Path.cwd()\n        self.client = docker.from_env()\n        self.cli = docker.APIClient(base_url=self.docker_sock)\n        if not kwargs.get(\"ctf_ctx\", False):\n            self.kernel_root = kwargs.get(\"kroot\", None)\n            if not self.kernel_root:\n                logger.critical(f\"{type(self).__name__} got invalid kernel root: '{self.kernel_root}'\")\n                exit(-1)\n\n    def guarantee_ssh(self, ssh_dir: Path) -> str:\n        if Path(ssh_dir).exists() and \"like.id_rsa\" in os.listdir(ssh_dir):\n            logger.debug(f\"Reusing local ssh keys from {ssh_dir}...\")\n        else:\n            logger.debug(\"Generating new ssh key pair...\")\n            if not Path(ssh_dir).exists():\n                Path(ssh_dir).mkdir()\n            sp.run(f'ssh-keygen -f {Path(ssh_dir) / \"like.id_rsa\"} -t rsa -N \"\"', shell=True)\n        return str(ssh_dir)\n\n    def init_ssh(self):\n        tries = 0\n        while True:\n            try:\n                self.ssh_conn = Connection(\n                    f\"{self.user}@localhost:{self.ssh_fwd_port}\", connect_kwargs={\"key_filename\": \".ssh/like.id_rsa\"}\n                )\n            except Exception as e:  # noqa PERF203\n                tries += 1\n                logger.error(f\"Failed to initialize SSH connection to {type(self).__name__}: {e}\")\n                logger.error(\"Retrying in 5 seconds...\")\n                if tries >= 5:\n                    logger.critical(f\"{tries} attempts failed! Exiting...\")\n                    exit(-1)\n                time.sleep(5)\n            else:\n                logger.debug(\"Established SSH connection!\")\n                break\n\n    def build_image(self, dockerfile=None, buildargs=None, image_tag=None):\n        dockerfile = dockerfile if dockerfile else self.dockerfile\n        buildargs = buildargs if buildargs else self.buildargs\n        tag = image_tag if image_tag else self.tag\n        nocache = True if self.update_containers else False\n        try:\n            for log_entry in self.cli.build(\n                path=str(self.dockerfile_ctx),\n                dockerfile=dockerfile,\n                tag=tag,\n                decode=True,\n                buildargs=buildargs,\n                nocache=nocache,\n                rm=True,\n            ):\n                v = next(iter(log_entry.values()))\n                if isinstance(v, str):\n                    v = \" \".join(v.strip().split())\n                    if v and not self.update_containers:\n                        logger.debug(v)\n                    elif v and self.update_containers:\n                        logger.info(v)\n            if self.update_containers:\n                self.cli.prune_images(filters={\"dangling\": True})\n            return 0\n        except docker_errors.APIError:\n            return 1\n\n    def get_image(self, tag=None) -> Image:\n        to_check = tag if tag else self.tag\n        try:\n            return self.client.images.get(to_check)\n        except docker_errors.ImageNotFound:\n            return None\n\n    def is_base_image(self) -> bool:\n        if self.get_image(tag=self.tag_base_image):\n            return True\n        else:\n            return False\n\n    def build_base_img(self) -> int:\n        return self.build_image(dockerfile=self.dockerfile_base_img, image_tag=self.tag_base_image)\n\n    def run(self, check_existing: bool = False) -> int:\n        if self.update_containers:\n            self.build_image()\n            return 1\n        if check_existing:\n            self.check_existing()\n        if not self.image:\n            if not self.is_base_image():\n                logger.debug(\"Could not find 'like-dbg'-base image! Building it!\")\n                self.build_base_img()\n            logger.info(f\"Building fresh image for {type(self).__name__}\")\n            self.build_image()\n            self.image = self.get_image()\n        self.run_container()\n        return 0\n\n    def run_container(self) -> None:\n        pass\n\n    def stop_container(self) -> None:\n        self.container.stop()\n\n    def list_running_containers(self) -> list[docker.client.DockerClient.containers]:\n        return self.client.containers.list()\n\n    # This one requires a HEALTHCHECK in the dockerfile\n    def wait_for_container(self) -> None:\n        logger.info(\"Waiting for Container to be up...\")\n        while True:\n            c = self.cli.inspect_container(self.container.id)\n            if c[\"State\"][\"Health\"][\"Status\"] != \"healthy\":\n                time.sleep(1)\n            else:\n                break\n\n    def pull_image(self, repo: str, tag: None) -> Image:\n        tag = tag if tag else self.tag\n        return self.client.images.pull(repo, tag=tag)\n\n    def check_existing(self) -> Image:\n        if self.update_containers:\n            return None\n        if self.force_rebuild:\n            logger.info(f\"Force-rebuilding {type(self).__name__}\")\n            self.image = None\n            return self.image\n        self.image = self.get_image()\n        if self.image and self.skip_prompts:\n            return self.image\n        if self.image and not is_reuse(self.image.tags[0]):\n            self.image = None\n        return self.image", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 5678}, "src/tests/test_debuggee.py::62": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee", "Path"], "enclosing_function": "test_assert_ctf_ctx_mode", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}, "src/tests/test_debugger.py::15": {"resolved_imports": ["src/debugger.py"], "used_names": ["Debugger", "GDB_SCRIPT_HIST"], "enclosing_function": "test_is_gdb_script_success", "extracted_code": "# Source: src/debugger.py\nGDB_SCRIPT_HIST = Path(\".gdb_hist\")\n\nclass Debugger(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"debugger\"], user_cfg, exclude_keys=[\"kernel_root\"])\n        if kwargs.get(\"ctf_ctx\", False):\n            self.ctf = True\n            self._set_ctf_ctx(kwargs)\n        else:\n            self.ctf = False\n            self.project_dir = Path.cwd() / self.kernel_root\n        self.custom_gdb_script = Path(\"/home/\") / self.user / Path(self.gdb_script).name\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.debuggee_name = get_value_from_section_by_key(SYSTEM_CFG, \"debuggee_docker\", \"tag\")\n\n    def _set_ctf_ctx(self, kwargs) -> None:\n        self.ctf_kernel = Path(kwargs.get(\"ctf_kernel\", \"\"))\n        self.project_dir = Path(self.ctf_dir).resolve().absolute()\n        vmlinux = Path(self.project_dir) / \"vmlinux\"\n        if not vmlinux.exists() or b\"ELF\" not in sp.run(f\"file {vmlinux}\", shell=True, capture_output=True).stdout:\n            if self._extract_vmlinux():\n                exit(-1)\n\n    def _extract_vmlinux(self) -> int:\n        vml_ext = next(Path.cwd().rglob(\"extract-vmlinux.sh\")).resolve().absolute()\n        pkernel = self.ctf_kernel.resolve().absolute()\n        with new_context(self.ctf_dir):\n            cmd = f\"{vml_ext} {pkernel}\"\n            ret = sp.run(f\"{cmd}\", shell=True, capture_output=True)\n            if ret.returncode == 0:\n                logger.info(\"Successfully extracted 'vmlinux' from compressed kernel\")\n                return 0\n            else:\n                logger.error(\"Failed to extract 'vmlinux'\")\n                return 1\n\n    def run_container(self) -> None:\n        entrypoint = f'/bin/bash -c \"{self.script_logging}; . /home/{self.user}/debugger.sh -a {self.arch} -p {self.docker_mnt} -c {int(self.ctf)} -g {self.custom_gdb_script} -e {self.ext}\"'\n        runner = f'docker run --pid=container:{self.debuggee_name} -it --rm --security-opt seccomp=unconfined --cap-add=SYS_PTRACE -v {self.project_dir}:/io --net=\"host\" {self.tag} {entrypoint}'\n        tmux(\"selectp -t 2\")\n        tmux_shell(runner)\n\n    @staticmethod\n    def _is_gdb_script_hist() -> bool:\n        return GDB_SCRIPT_HIST.exists()\n\n    def _handle_gdb_change(self) -> None:\n        src = get_sha256_from_file(Path(self.gdb_script))\n        if self._is_gdb_script_hist():\n            dst = GDB_SCRIPT_HIST.read_text()\n            if dst != src:\n                logger.debug(f\"Detected changes in {self.gdb_script}. Rebuilding debugger!\")\n                self.force_rebuild = True\n                GDB_SCRIPT_HIST.write_text(src)\n        else:\n            GDB_SCRIPT_HIST.write_text(src)\n\n    def run(self) -> None:\n        self._handle_gdb_change()\n        super().run(check_existing=True)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2977}, "src/tests/test_debugger.py::35": {"resolved_imports": ["src/debugger.py"], "used_names": ["Debugger", "Path", "hashlib", "patch"], "enclosing_function": "test_handle_gdb_change_update_existing", "extracted_code": "# Source: src/debugger.py\nclass Debugger(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"debugger\"], user_cfg, exclude_keys=[\"kernel_root\"])\n        if kwargs.get(\"ctf_ctx\", False):\n            self.ctf = True\n            self._set_ctf_ctx(kwargs)\n        else:\n            self.ctf = False\n            self.project_dir = Path.cwd() / self.kernel_root\n        self.custom_gdb_script = Path(\"/home/\") / self.user / Path(self.gdb_script).name\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.debuggee_name = get_value_from_section_by_key(SYSTEM_CFG, \"debuggee_docker\", \"tag\")\n\n    def _set_ctf_ctx(self, kwargs) -> None:\n        self.ctf_kernel = Path(kwargs.get(\"ctf_kernel\", \"\"))\n        self.project_dir = Path(self.ctf_dir).resolve().absolute()\n        vmlinux = Path(self.project_dir) / \"vmlinux\"\n        if not vmlinux.exists() or b\"ELF\" not in sp.run(f\"file {vmlinux}\", shell=True, capture_output=True).stdout:\n            if self._extract_vmlinux():\n                exit(-1)\n\n    def _extract_vmlinux(self) -> int:\n        vml_ext = next(Path.cwd().rglob(\"extract-vmlinux.sh\")).resolve().absolute()\n        pkernel = self.ctf_kernel.resolve().absolute()\n        with new_context(self.ctf_dir):\n            cmd = f\"{vml_ext} {pkernel}\"\n            ret = sp.run(f\"{cmd}\", shell=True, capture_output=True)\n            if ret.returncode == 0:\n                logger.info(\"Successfully extracted 'vmlinux' from compressed kernel\")\n                return 0\n            else:\n                logger.error(\"Failed to extract 'vmlinux'\")\n                return 1\n\n    def run_container(self) -> None:\n        entrypoint = f'/bin/bash -c \"{self.script_logging}; . /home/{self.user}/debugger.sh -a {self.arch} -p {self.docker_mnt} -c {int(self.ctf)} -g {self.custom_gdb_script} -e {self.ext}\"'\n        runner = f'docker run --pid=container:{self.debuggee_name} -it --rm --security-opt seccomp=unconfined --cap-add=SYS_PTRACE -v {self.project_dir}:/io --net=\"host\" {self.tag} {entrypoint}'\n        tmux(\"selectp -t 2\")\n        tmux_shell(runner)\n\n    @staticmethod\n    def _is_gdb_script_hist() -> bool:\n        return GDB_SCRIPT_HIST.exists()\n\n    def _handle_gdb_change(self) -> None:\n        src = get_sha256_from_file(Path(self.gdb_script))\n        if self._is_gdb_script_hist():\n            dst = GDB_SCRIPT_HIST.read_text()\n            if dst != src:\n                logger.debug(f\"Detected changes in {self.gdb_script}. Rebuilding debugger!\")\n                self.force_rebuild = True\n                GDB_SCRIPT_HIST.write_text(src)\n        else:\n            GDB_SCRIPT_HIST.write_text(src)\n\n    def run(self) -> None:\n        self._handle_gdb_change()\n        super().run(check_existing=True)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2940}, "src/tests/test_kernel_unpacker.py::68": {"resolved_imports": ["src/kernel_unpacker.py"], "used_names": [], "enclosing_function": "test_unpack_targz_invalid", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "src/tests/test_kernel_builder.py::262": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "MagicMock"], "enclosing_function": "test_run_ssh_success", "extracted_code": "# Source: src/kernel_builder.py\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8259}, "src/tests/test_kernel_downloader.py::27": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path", "requests"], "enclosing_function": "test_tag", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_misc.py::94": {"resolved_imports": ["src/debuggee.py", "src/debugger.py", "src/kernel_builder.py", "src/misc.py", "src/rootfs_builder.py"], "used_names": ["is_reuse", "patch"], "enclosing_function": "test_is_not_reuse", "extracted_code": "# Source: src/misc.py\ndef is_reuse(p: str) -> bool:\n    choice = \"y\"\n    logger.info(f\"Found {p}. Re-use it? [Y/n]\")\n    termios.tcflush(stdin, termios.TCIFLUSH)\n    tmp = input().lower()\n    if tmp != \"\":\n        choice = tmp\n    if choice in [\"y\", \"yes\"]:\n        logger.debug(f\"Reusing existing {p}...\")\n        return True\n    else:\n        return False", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 357}, "src/tests/test_kernel_unpacker.py::82": {"resolved_imports": ["src/kernel_unpacker.py"], "used_names": [], "enclosing_function": "test_fresh_unpack", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "src/tests/test_kernel_builder.py::50": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder"], "enclosing_function": "test_extra_args", "extracted_code": "# Source: src/kernel_builder.py\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8259}, "src/tests/test_kernel_downloader.py::73": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path", "hashlib"], "enclosing_function": "test_run", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_kernel_downloader.py::16": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path", "requests"], "enclosing_function": "test_mmp", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_kernel_downloader.py::11": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader"], "enclosing_function": "test_uris", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_kernel_builder.py::226": {"resolved_imports": ["src/kernel_builder.py"], "used_names": ["KernelBuilder", "pytest"], "enclosing_function": "test_general_exception", "extracted_code": "# Source: src/kernel_builder.py\nclass KernelBuilder(DockerRunner):\n    def __init__(self, **kwargs) -> None:\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self,\n            [\"general\", \"kernel_builder\", \"kernel_builder_docker\"],\n            user_cfg,\n            exclude_keys=[\"kernel_root\"],\n            cherry_pick={\"debuggee\": [\"kvm\"]},\n        )\n        self.cc = f\"CC={self.compiler}\" if self.compiler else \"\"\n        self.llvm_flag = \"\" if \"gcc\" in self.cc else \"LLVM=1\"\n        self.guarantee_ssh(self.ssh_dir)\n        self.tag = self.tag + f\"_{self.arch}\"\n        self.dirty = kwargs.get(\"assume_dirty\", False)\n        tmp_arch = adjust_arch(self.arch)\n        self.config = Path(self.config)\n        self.buildargs = self.buildargs | {\n            \"CC\": self.compiler,\n            \"LLVM\": \"0\" if self.compiler == \"gcc\" else \"1\",\n            \"TOOLCHAIN_ARCH\": adjust_toolchain_arch(self.arch),\n            \"CROSS_COMPILE\": cross_compile(self.arch),\n            \"ARCH\": tmp_arch,\n        }\n        self.arch = tmp_arch\n\n    @staticmethod\n    def make_sudo(cmd: str) -> str:\n        if os.getuid() == 0:\n            return f\"sudo {cmd}\"\n        else:\n            return cmd\n\n    def _run_ssh(self, cmd: str, **kwargs) -> int:\n        cmd = self.make_sudo(cmd)\n        warn = kwargs.get(\"warn\", False)\n        return self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root} && {cmd}\", echo=True, warn=warn).exited\n\n    def _apply_patches(self) -> int:\n        ret = 0\n        if self.patch_dir and Path(self.patch_dir).exists():\n            patch_files = list(Path(self.patch_dir).iterdir())\n            if patch_files:\n                for pfile in patch_files:\n                    logger.debug(f\"Patching: {pfile}\")\n                    if self._run_ssh(f\"patch -p1 < ../../{self.patch_dir}/{pfile.name} > /dev/null\", warn=True) != 0:\n                        logger.error(f\"Failed to apply patch: {pfile}... Continuing anyway!\")\n                        ret = 1\n        return ret\n\n    def _build_mrproper(self) -> int:\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} make mrproper\")\n\n    def _build_arch(self) -> int:\n        cmd = f\"{self.cc} {self.llvm_flag} \"\n        if self.arch == \"x86_64\":\n            cmd += f\"make {self.arch}_defconfig\"\n        else:\n            cmd += f\"ARCH={self.arch} make defconfig\"\n        return self._run_ssh(f\"{cmd}\")\n\n    def _build_kvm_guest(self) -> int:\n        return self._run_ssh(f\"{self.cc} {self.llvm_flag} ARCH={self.arch} make kvm_guest.config\")\n\n    def _configure_kernel(self) -> int:\n        params = self._get_params()\n        return self._run_ssh(f\"./scripts/config {params}\")\n\n    def _get_params(self) -> str:\n        params = \"\"\n        if self.llvm_flag:\n            # TODO: Allow LTO_CLANG_FULL & LTO_CLANG_THIN options once they're not experiment anymore\n            params += \"-e LTO_NONE -d LTO_CLANG_FULL -d LTO_CLANG_THIN \"\n        if self.mode == \"syzkaller\":\n            params += self.syzkaller_args\n        elif self.mode == \"generic\":\n            params += self.generic_args\n        elif self.mode == \"custom\":\n            params += self._custom_args()\n        if self.extra_args:\n            params = self._extra_args(params)\n        if params:\n            self._run_ssh(f\"./scripts/config {params}\")\n        return params\n\n    def _extra_args(self, params: str) -> str:\n        splt = self.extra_args.split()\n        for idx in range(0, len(splt)):\n            if idx % 2 == 0:\n                continue\n\n            new_opt = \" \".join(splt[idx - 1 : idx + 1])\n            if splt[idx] in params:\n                pattern = rf\"[-][ed]{{1}}\\s{splt[idx]}\"\n                params = re.sub(pattern, new_opt, params)\n            else:\n                params += f\" {new_opt}\"\n        logger.debug(params)\n        return params.strip()\n\n    def _custom_args(self) -> str:\n        params = \"-e \" + \" -e \".join(self.enable_args.split())\n        params += \" -d \" + \" -d \".join(self.disable_args.split())\n        return params\n\n    def _make_clean(self) -> int:\n        logger.debug(\"Running 'make clean' just in case...\")\n        return self._run_ssh(\"make clean\")\n\n    def _make(self) -> int:\n        ret = self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) all\")\n        if ret != 0:\n            logger.error(\"Failed to run 'make all'i\")\n            self.stop_container()\n            exit(-1)\n        return self._run_ssh(f\"{self.cc} ARCH={self.arch} {self.llvm_flag} make -j$(nproc) modules\")\n\n    def _add_multiple_mods(self, modules: list[Path]) -> None:\n        for d in modules:\n            if not d.is_dir():\n                continue\n            logger.debug(f\"Adding module: {d}\")\n            self._add_single_mod(Path(d))\n\n    def _add_single_mod(self, mod: Path) -> None:\n        dst = Path(self.kernel_root) / MISC_DRVS_PATH\n        sp.run(f\"cp -fr {mod} {dst}\", shell=True)\n        kcfg_mod_path = dst / mod.name / \"Kconfig\"\n        mod_kcfg_content = kcfg_mod_path.read_text()\n        tmp = \"_\".join(re.search(r\"config .*\", mod_kcfg_content)[0].upper().split())\n        ins = f\"obj-$({tmp}) += {mod.name}/\\n\"\n\n        makefile_path = dst / \"Makefile\"\n        if ins.strip() not in makefile_path.read_text():\n            with makefile_path.open(\"a\") as g:\n                g.write(ins)\n\n        kconfig_path = dst / \"Kconfig\"\n        contents = kconfig_path.read_text().splitlines(True)\n        ins = f\"\"\"source \"{MISC_DRVS_PATH / mod.name / 'Kconfig'}\"\\n\"\"\"\n        if ins not in contents:\n            contents.insert(len(contents) - 1, ins)\n            kconfig_path.write_text(\"\".join(contents))\n\n        logger.debug(f\"Added module {mod} to the kernel\")\n\n    def _add_modules(self) -> None:\n        mods = list(Path(self.custom_modules).iterdir())\n        if all(ele in [x.name for x in mods] for ele in [\"Kconfig\", \"Makefile\"]):\n            self._add_single_mod(Path(self.custom_modules))\n        else:\n            self._add_multiple_mods(mods)\n\n    def run_container(self) -> None:\n        logger.info(\"Building kernel. This may take a while...\")\n        try:\n            self.prepare_volumes_and_modules()\n            self.start_container()\n            self.prepare_kernel_build()\n            self.configure_and_make_kernel()\n        except FileNotFoundError as e:\n            logger.error(f\"Failed to find file: {e}\")\n            exit(-1)\n        except Exception as e:\n            logger.error(f\"A command caused an unexpected exit: {e}\")\n            exit(-2)\n        else:\n            self.post_build_tasks()\n        finally:\n            self.cleanup_container()\n\n    def prepare_volumes_and_modules(self):\n        if self.custom_modules:\n            self._add_modules()\n        volumes = {f\"{Path.cwd()}\": {\"bind\": f\"{self.docker_mnt}\", \"mode\": \"rw\"}}\n        if self.mode == \"config\":\n            volumes |= {f\"{self.config.absolute().parent}\": {\"bind\": \"/tmp/\", \"mode\": \"rw\"}}\n        self.volumes = volumes\n\n    def start_container(self):\n        self.container = self.client.containers.run(\n            self.image,\n            volumes=self.volumes,\n            ports={\"22/tcp\": self.ssh_fwd_port},\n            detach=True,\n            tty=True,\n        )\n        self.wait_for_container()\n        self.init_ssh()\n\n    def prepare_kernel_build(self):\n        if self.dirty:\n            self._make_clean()\n        if self.mode != \"config\":\n            self._build_mrproper()\n            self._apply_patches()\n            self._build_arch()\n            if self.kvm:\n                self._build_kvm_guest()\n        else:\n            self._run_ssh(f\"cp /tmp/{self.config.stem} .config\")\n\n    def configure_and_make_kernel(self):\n        self._configure_kernel()\n        self._make()\n\n    def post_build_tasks(self):\n        logger.info(\"Successfully build the kernel\")\n        if self.arch == \"x86_64\":\n            cmd = self.make_sudo(\"ln -s bzImage Image\")\n            self.ssh_conn.run(f\"cd {self.docker_mnt}/{self.kernel_root}/arch/{self.arch}/boot && {cmd}\", echo=True)\n\n    def cleanup_container(self):\n        try:\n            self.stop_container()\n        except AttributeError:\n            pass\n\n    def run(self) -> None:\n        super().run(check_existing=True)", "n_imports_parsed": 8, "n_files_resolved": 1, "n_chars_extracted": 8259}, "src/tests/test_kernel_downloader.py::64": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path"], "enclosing_function": "test_is_present", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_debugger.py::94": {"resolved_imports": ["src/debugger.py"], "used_names": ["Debugger", "patch"], "enclosing_function": "test_run_container", "extracted_code": "# Source: src/debugger.py\nclass Debugger(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"general\", \"debugger\"], user_cfg, exclude_keys=[\"kernel_root\"])\n        if kwargs.get(\"ctf_ctx\", False):\n            self.ctf = True\n            self._set_ctf_ctx(kwargs)\n        else:\n            self.ctf = False\n            self.project_dir = Path.cwd() / self.kernel_root\n        self.custom_gdb_script = Path(\"/home/\") / self.user / Path(self.gdb_script).name\n        self.script_logging = \"set -e\" if kwargs.get(\"log_level\", \"INFO\") == \"INFO\" else \"set -eux\"\n        self.skip_prompts = kwargs.get(\"skip_prompts\", False)\n        self.debuggee_name = get_value_from_section_by_key(SYSTEM_CFG, \"debuggee_docker\", \"tag\")\n\n    def _set_ctf_ctx(self, kwargs) -> None:\n        self.ctf_kernel = Path(kwargs.get(\"ctf_kernel\", \"\"))\n        self.project_dir = Path(self.ctf_dir).resolve().absolute()\n        vmlinux = Path(self.project_dir) / \"vmlinux\"\n        if not vmlinux.exists() or b\"ELF\" not in sp.run(f\"file {vmlinux}\", shell=True, capture_output=True).stdout:\n            if self._extract_vmlinux():\n                exit(-1)\n\n    def _extract_vmlinux(self) -> int:\n        vml_ext = next(Path.cwd().rglob(\"extract-vmlinux.sh\")).resolve().absolute()\n        pkernel = self.ctf_kernel.resolve().absolute()\n        with new_context(self.ctf_dir):\n            cmd = f\"{vml_ext} {pkernel}\"\n            ret = sp.run(f\"{cmd}\", shell=True, capture_output=True)\n            if ret.returncode == 0:\n                logger.info(\"Successfully extracted 'vmlinux' from compressed kernel\")\n                return 0\n            else:\n                logger.error(\"Failed to extract 'vmlinux'\")\n                return 1\n\n    def run_container(self) -> None:\n        entrypoint = f'/bin/bash -c \"{self.script_logging}; . /home/{self.user}/debugger.sh -a {self.arch} -p {self.docker_mnt} -c {int(self.ctf)} -g {self.custom_gdb_script} -e {self.ext}\"'\n        runner = f'docker run --pid=container:{self.debuggee_name} -it --rm --security-opt seccomp=unconfined --cap-add=SYS_PTRACE -v {self.project_dir}:/io --net=\"host\" {self.tag} {entrypoint}'\n        tmux(\"selectp -t 2\")\n        tmux_shell(runner)\n\n    @staticmethod\n    def _is_gdb_script_hist() -> bool:\n        return GDB_SCRIPT_HIST.exists()\n\n    def _handle_gdb_change(self) -> None:\n        src = get_sha256_from_file(Path(self.gdb_script))\n        if self._is_gdb_script_hist():\n            dst = GDB_SCRIPT_HIST.read_text()\n            if dst != src:\n                logger.debug(f\"Detected changes in {self.gdb_script}. Rebuilding debugger!\")\n                self.force_rebuild = True\n                GDB_SCRIPT_HIST.write_text(src)\n        else:\n            GDB_SCRIPT_HIST.write_text(src)\n\n    def run(self) -> None:\n        self._handle_gdb_change()\n        super().run(check_existing=True)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2940}, "src/tests/test_kernel_downloader.py::39": {"resolved_imports": ["src/linux_kernel_dl.py"], "used_names": ["KernelDownloader", "Path", "requests"], "enclosing_function": "test_commit", "extracted_code": "# Source: src/linux_kernel_dl.py\nclass KernelDownloader:\n    def __init__(self, **kwargs) -> None:\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(self, [\"kernel_dl\"], user_cfg)\n        self.commit = self._set_commit()\n        self.choice = self._set_choice()\n        logger.info(f\"Using kernel with (tag/commit/version) {self.choice}\")\n        self.dl_uri = self._set_dl_uri()\n        if not Path(self.kernel_dl_path).exists():\n            Path(self.kernel_dl_path).mkdir()\n        self.archive = Path(self.kernel_dl_path) / f\"linux-{self.choice}.tar.gz\"\n        logger.debug(f\"Kernel snap: {self.dl_uri}\")\n\n    def _set_commit(self):\n        if any([self.tag, self.mmp]):\n            return self.commit\n        elif self.commit:\n            return self.commit\n        else:\n            return self._resolve_latest()\n\n    def _resolve_latest(self) -> str:\n        commit_re = rb\"commit\\/\\?id=[0-9a-z]*\"\n        r = requests.get(self.commit_uri)\n        search_res = re.search(commit_re, r.content)\n        if search_res and search_res.group():\n            commit = search_res.group().split(b\"=\")[1].decode()\n            logger.debug(f\"Found latest commit: {commit}\")\n            return commit\n        else:\n            logger.critical(\"Resolving latest commit\")\n            exit(-1)\n\n    def _set_choice(self):\n        if self.mmp:\n            return self.mmp\n        elif self.tag:\n            return self.tag\n        else:\n            return self.commit\n\n    def _set_dl_uri(self):\n        if self.mmp:\n            (major, minor, patch) = tuple(self.mmp.split(\".\"))\n            self.mmp_uri = self.mmp_uri.replace(\"KMAJOR\", major)\n            self.mmp_uri = self.mmp_uri.replace(\"KMINOR\", minor)\n            self.mmp_uri = self.mmp_uri.replace(\"KPATCH\", patch)\n            return self.mmp_uri\n        else:\n            return f\"{self.snap_uri}{self.choice}.tar.gz\"\n\n    def is_present(self) -> bool:\n        if Path(self.archive).exists():\n            logger.info(\"Kernel archive already exists locally. Skipping downloading phase...\")\n            return True\n        else:\n            return False\n\n    def download_kernel_archive(self) -> None:\n        logger.info(f\"Downloading {self.dl_uri}... This may take a while!\")\n        with DLProgressBarTQDM(unit=\"B\", unit_scale=True, miniters=1, desc=self.archive.name) as t:\n            urllib.request.urlretrieve(self.dl_uri, filename=self.archive, reporthook=t.update_to)\n            t.total = t.n\n\n    def run(self) -> Path:\n        if not self.is_present():\n            self.download_kernel_archive()\n        return self.archive", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 2600}, "src/tests/test_debuggee.py::44": {"resolved_imports": ["src/debuggee.py"], "used_names": ["Debuggee", "MagicMock", "patch", "pytest"], "enclosing_function": "test_infer_qemu_fs_mount_error", "extracted_code": "# Source: src/debuggee.py\nclass Debuggee(DockerRunner):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        user_cfg = kwargs.get(\"user_cfg\", \"\")\n        cfg_setter(\n            self, [\"general\", \"debuggee\", \"debuggee_docker\", \"rootfs_general\"], user_cfg, exclude_keys=[\"kernel_root\"]\n        )\n        if self.ctf:\n            self.ctf_mount = kwargs.get(\"ctf_mount\")\n            self.kernel = Path(self.docker_mnt) / kwargs.get(\"ctf_kernel\", \"\")\n            self.rootfs = Path(self.docker_mnt) / kwargs.get(\"ctf_fs\", \"\")\n        else:\n            self.kernel = Path(self.docker_mnt) / self.kernel_root / \"arch\" / self.arch / \"boot\" / \"Image\"\n            self.rootfs = Path(self.docker_mnt) / self.rootfs_dir / (self.rootfs_base + self.arch + self.rootfs_ftype)\n        self.qemu_arch = adjust_qemu_arch(self.arch)\n        self.cmd = \"\"\n\n    def run(self):\n        super().run(check_existing=True)\n\n    def infer_qemu_fs_mount(self) -> str:\n        r = self.rootfs if self.ctf else Path(*self.rootfs.parts[2:])\n        magic = sp.run(f\"file {r}\", shell=True, capture_output=True)\n        rootfs = self.rootfs.name if self.ctf else self.rootfs\n        if b\"cpio archive\" in magic.stdout:\n            return f\" -initrd {rootfs}\"\n        elif b\"filesystem data\" in magic.stdout:\n            return f\" -drive file={rootfs},format=raw\"\n        elif b\"qemu qcow\" in magic.stdout.lower():\n            return f\" -drive file={rootfs}\"\n        else:\n            logger.error(f\"Unsupported rootfs type: {magic.stdout}\")\n            exit(-1)\n\n    def infer_panic_behavior(self) -> int:\n        if self.panic == \"reboot\":\n            return -1\n        elif self.panic == \"halt\":\n            return 0\n        elif \"wait\" in self.panic:\n            try:\n                ret = int(self.panic.split(\" \")[1])\n                return ret\n            except (IndexError, ValueError):\n                return 15\n        else:\n            logger.error(\"Unknown requested panic behavior...\")\n            exit(-1)\n\n    def _add_smep_smap(self) -> None:\n        if self.smep:\n            self.cmd += \",+smep\"\n        if self.smap:\n            self.cmd += \",+smap\"\n\n    def _ensure_container_is_up(self):\n        import time\n\n        # FIXME: Ugly hack to make us allow getting the container object.\n        time.sleep(1)\n        self.container = self.client.containers.get(f\"{self.tag}\")\n        self.wait_for_container()\n\n    def run_container(self):\n        mount_point = self.ctf_mount if self.ctf else Path.cwd()\n        kernel = Path(self.docker_mnt) / self.kernel.name if self.ctf else self.kernel\n        dcmd = f'docker run --name {self.tag} -it --rm -v {mount_point}:/io --net=\"host\" like_debuggee '\n        self.cmd = f\"qemu-system-{self.qemu_arch} -m {self.memory} -smp {self.smp} -kernel {kernel}\"\n        if self.qemu_arch == \"aarch64\":\n            self.cmd += \" -cpu cortex-a72\"\n            self.cmd += ' -machine type=virt -append \"console=ttyAMA0 root=/dev/vda'\n        elif self.qemu_arch == \"x86_64\":\n            self.cmd += \" -cpu qemu64\"\n            self._add_smep_smap()\n            self.cmd += ' -append \"console=ttyS0 root=/dev/sda'\n        else:\n            logger.error(f\"Unsupported architecture: {self.qemu_arch}\")\n            exit(-1)\n        self.cmd += \" earlyprintk=serial net.ifnames=0\"\n        if not self.kaslr:\n            self.cmd += \" nokaslr\"\n        else:\n            self.cmd += \" kaslr\"\n        if not self.smep:\n            self.cmd += \" nosmep\"\n        if not self.smap:\n            self.cmd += \" nosmap\"\n        if not self.kpti:\n            self.cmd += \" nopti\"\n        else:\n            self.cmd += \" pti=on\"\n        self.cmd += f' oops=panic panic={self.infer_panic_behavior()}\"'\n        self.cmd += self.infer_qemu_fs_mount()\n        self.cmd += (\n            \" -net user,host=10.0.2.10,hostfwd=tcp:127.0.0.1:10021-:22 -net nic,model=e1000 -nographic -pidfile vm.pid\"\n        )\n        if self.kvm and self.qemu_arch == \"x86_64\":\n            self.cmd += \" -enable-kvm\"\n        if self.gdb:\n            self.cmd += \" -S -s\"\n        tmux(\"selectp -t 1\")\n        runner = f\"{dcmd} {self.cmd}\"\n        tmux_shell(runner)\n        self._ensure_container_is_up()", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 4202}}}