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(","))
Codebase Browser
llvm