from __future__ import print_function import lldb import unittest import os import json import stat import sys from textwrap import dedent import lldbsuite.test.lldbutil from lldbsuite.test.lldbtest import * from lldbsuite.test.decorators import * from lldbsuite.test.gdbclientutils import * @skipIfRemote @skipIfWindows class TestQemuLaunch(TestBase): NO_DEBUG_INFO_TESTCASE = True def set_emulator_setting(self, name, value): self.runCmd("settings set -- platform.plugin.qemu-user.%s %s" % (name, value)) def setUp(self): super().setUp() emulator = self.getBuildArtifact("qemu.py") with os.fdopen(os.open(emulator, os.O_WRONLY|os.O_CREAT, stat.S_IRWXU), "w") as e: e.write(dedent("""\ #! {exec!s} import runpy import sys sys.path = {path!r} runpy.run_path({source!r}, run_name='__main__') """).format(exec=sys.executable, path=sys.path, source=self.getSourcePath("qemu.py"))) self.set_emulator_setting("architecture", self.getArchitecture()) self.set_emulator_setting("emulator-path", emulator) def _create_target(self): self.build() exe = self.getBuildArtifact() # Create a target using our platform error = lldb.SBError() target = self.dbg.CreateTarget(exe, '', 'qemu-user', False, error) self.assertSuccess(error) self.assertEqual(target.GetPlatform().GetName(), "qemu-user") return target def _run_and_get_state(self, target=None, info=None): if target is None: target = self._create_target() if info is None: info = target.GetLaunchInfo() # "Launch" the process. Our fake qemu implementation will pretend it # immediately exited. info.SetArguments(["dump:" + self.getBuildArtifact("state.log")], True) error = lldb.SBError() process = target.Launch(info, error) self.assertSuccess(error) self.assertIsNotNone(process) self.assertState(process.GetState(), lldb.eStateExited) self.assertEqual(process.GetExitStatus(), 0x47) # Verify the qemu invocation parameters. with open(self.getBuildArtifact("state.log")) as s: return json.load(s) def test_basic_launch(self): state = self._run_and_get_state() self.assertEqual(state["program"], self.getBuildArtifact()) self.assertEqual(state["args"], ["dump:" + self.getBuildArtifact("state.log")]) def test_stdio_pty(self): target = self._create_target() info = target.GetLaunchInfo() info.SetArguments([ "stdin:stdin", "stdout:STDOUT CONTENT\n", "stderr:STDERR CONTENT\n", "dump:" + self.getBuildArtifact("state.log"), ], False) listener = lldb.SBListener("test_stdio") info.SetListener(listener) self.dbg.SetAsync(True) error = lldb.SBError() process = target.Launch(info, error) self.assertSuccess(error) lldbutil.expect_state_changes(self, listener, process, [lldb.eStateRunning]) process.PutSTDIN("STDIN CONTENT\n") lldbutil.expect_state_changes(self, listener, process, [lldb.eStateExited]) # Echoed stdin, stdout and stderr. With a pty we cannot split standard # output and error. self.assertEqual(process.GetSTDOUT(1000), "STDIN CONTENT\r\nSTDOUT CONTENT\r\nSTDERR CONTENT\r\n") with open(self.getBuildArtifact("state.log")) as s: state = json.load(s) self.assertEqual(state["stdin"], "STDIN CONTENT\n") def test_stdio_redirect(self): self.build() exe = self.getBuildArtifact() # Create a target using our platform error = lldb.SBError() target = self.dbg.CreateTarget(exe, '', 'qemu-user', False, error) self.assertSuccess(error) info = lldb.SBLaunchInfo([ "stdin:stdin", "stdout:STDOUT CONTENT", "stderr:STDERR CONTENT", "dump:" + self.getBuildArtifact("state.log"), ]) info.AddOpenFileAction(0, self.getBuildArtifact("stdin.txt"), True, False) info.AddOpenFileAction(1, self.getBuildArtifact("stdout.txt"), False, True) info.AddOpenFileAction(2, self.getBuildArtifact("stderr.txt"), False, True) with open(self.getBuildArtifact("stdin.txt"), "w") as f: f.write("STDIN CONTENT") process = target.Launch(info, error) self.assertSuccess(error) self.assertState(process.GetState(), lldb.eStateExited) with open(self.getBuildArtifact("stdout.txt")) as f: self.assertEqual(f.read(), "STDOUT CONTENT") with open(self.getBuildArtifact("stderr.txt")) as f: self.assertEqual(f.read(), "STDERR CONTENT") with open(self.getBuildArtifact("state.log")) as s: state = json.load(s) self.assertEqual(state["stdin"], "STDIN CONTENT") def test_find_in_PATH(self): emulator = self.getBuildArtifact("qemu-" + self.getArchitecture()) os.rename(self.getBuildArtifact("qemu.py"), emulator) self.set_emulator_setting("emulator-path", "''") original_path = os.environ["PATH"] os.environ["PATH"] = (self.getBuildDir() + self.platformContext.shlib_path_separator + original_path) def cleanup(): os.environ["PATH"] = original_path self.addTearDownHook(cleanup) state = self._run_and_get_state() self.assertEqual(state["program"], self.getBuildArtifact()) self.assertEqual(state["args"], ["dump:" + self.getBuildArtifact("state.log")]) def test_bad_emulator_path(self): self.set_emulator_setting("emulator-path", self.getBuildArtifact("nonexistent.file")) target = self._create_target() info = lldb.SBLaunchInfo([]) error = lldb.SBError() target.Launch(info, error) self.assertTrue(error.Fail()) self.assertIn("doesn't exist", error.GetCString()) def test_extra_args(self): self.set_emulator_setting("emulator-args", "-fake-arg fake-value") state = self._run_and_get_state() self.assertEqual(state["fake-arg"], "fake-value") def test_env_vars(self): # First clear any global environment to have a clean slate for this test self.runCmd("settings clear target.env-vars") self.runCmd("settings clear target.unset-env-vars") def var(i): return "LLDB_TEST_QEMU_VAR%d" % i # Set some variables in the host environment. for i in range(4): os.environ[var(i)]="from host" def cleanup(): for i in range(4): del os.environ[var(i)] self.addTearDownHook(cleanup) # Set some emulator-only variables. self.set_emulator_setting("emulator-env-vars", "%s='emulator only'"%var(4)) # And through the platform setting. self.set_emulator_setting("target-env-vars", "%s='from platform' %s='from platform'" % (var(1), var(2))) target = self._create_target() info = target.GetLaunchInfo() env = info.GetEnvironment() # Platform settings should trump host values. Emulator-only variables # should not be visible. self.assertEqual(env.Get(var(0)), "from host") self.assertEqual(env.Get(var(1)), "from platform") self.assertEqual(env.Get(var(2)), "from platform") self.assertEqual(env.Get(var(3)), "from host") self.assertIsNone(env.Get(var(4))) # Finally, make some launch_info specific changes. env.Set(var(2), "from target", True) env.Unset(var(3)) info.SetEnvironment(env, False) # Now check everything. Launch info changes should trump everything, but # only for the target environment -- the emulator should still get the # host values. state = self._run_and_get_state(target, info) for i in range(4): self.assertEqual(state["environ"][var(i)], "from host") self.assertEqual(state["environ"][var(4)], "emulator only") self.assertEqual(state["environ"]["QEMU_SET_ENV"], "%s=from platform,%s=from target" % (var(1), var(2))) self.assertEqual(state["environ"]["QEMU_UNSET_ENV"], "%s,%s,QEMU_SET_ENV,QEMU_UNSET_ENV" % (var(3), var(4))) def test_arg0(self): target = self._create_target() self.runCmd("settings set target.arg0 ARG0") state = self._run_and_get_state(target) self.assertEqual(state["program"], self.getBuildArtifact()) self.assertEqual(state["0"], "ARG0") def test_sysroot(self): sysroot = self.getBuildArtifact("sysroot") self.runCmd("platform select qemu-user --sysroot %s" % sysroot) state = self._run_and_get_state() self.assertEqual(state["environ"]["QEMU_LD_PREFIX"], sysroot) self.assertIn("QEMU_LD_PREFIX", state["environ"]["QEMU_UNSET_ENV"].split(","))