mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 13:55:58 +00:00
fix(session): preserve guest monotonic time after long pauses (#2393)
This commit is contained in:
1 parent
cd05c96d10
commit
01bfe8519e
14 files changed
+519
-13
No files matched your search
@@ -1,19 +1,34 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
import queue
|
||||
import re
|
||||
import shlex
|
||||
import shutil
|
||||
import struct
|
||||
import subprocess
|
||||
import tempfile
|
||||
import threading
|
||||
import unittest
|
||||
|
||||
PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
|
||||
|
||||
|
||||
def clock_reset_command(control):
|
||||
script = (PRELOAD.parent / "overlay/usr/local/bin/droiddeck-session").read_text()
|
||||
start = script.index('if [ -z "${BL_INSIDE:-}" ]; then\n if [ "${BL_ZRAM:-0}"')
|
||||
end = script.index("\nfi", start) + len("\nfi")
|
||||
paths = {"/tmp/.bl-clock": shlex.quote(str(control)),
|
||||
"/tmp/.bl-zram": shlex.quote(str(control.parent / "zram"))}
|
||||
pattern = "|".join(re.escape(token) for token in paths)
|
||||
return 'BL_INSIDE=; BL_ZRAM=0; ' + re.sub(pattern, lambda match: paths[match.group(0)], script[start:end])
|
||||
|
||||
PROGRAM = r"""
|
||||
#define _GNU_SOURCE
|
||||
#include <linux/futex.h>
|
||||
#include <pthread.h>
|
||||
#include <semaphore.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <sys/timerfd.h>
|
||||
@@ -36,12 +51,26 @@ static int64_t start;
|
||||
static void begin(void) { start = ns(CLOCK_BOOTTIME); }
|
||||
static void end(const char *name) { printf("%s %lld\n", name, (long long)((ns(CLOCK_BOOTTIME) - start) / 1000000LL)); }
|
||||
|
||||
static unsigned long long memory_probe(void) {
|
||||
static volatile unsigned char memory[4 * 1024 * 1024];
|
||||
unsigned long long checksum = 0;
|
||||
for (size_t i = 0; i < sizeof(memory); i += 4096) memory[i] = (unsigned char)(i / 4096 + 1);
|
||||
for (size_t i = 0; i < sizeof(memory); i += 4096) checksum += memory[i];
|
||||
return checksum;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
const int64_t wait = 60000000LL;
|
||||
printf("gap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ns(CLOCK_MONOTONIC)) / 1000000LL));
|
||||
struct timespec raw;
|
||||
syscall(SYS_clock_gettime, CLOCK_MONOTONIC, &raw);
|
||||
printf("rawgap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ((int64_t)raw.tv_sec * 1000000000LL + raw.tv_nsec)) / 1000000LL));
|
||||
printf("memory %llu\n", memory_probe());
|
||||
if (getenv("CLOCK_PAUSE_WAIT")) { puts("ready"); fflush(stdout); getchar(); }
|
||||
if (getenv("CLOCK_PAUSE_WAIT")) {
|
||||
printf("livegap %lld\n", (long long)((ns(CLOCK_BOOTTIME) - ns(CLOCK_MONOTONIC)) / 1000000LL));
|
||||
printf("livememory %llu\n", memory_probe());
|
||||
}
|
||||
|
||||
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
pthread_condattr_t attr;
|
||||
@@ -124,14 +153,124 @@ class ClockPausePreloadTest(unittest.TestCase):
|
||||
self.assertGreaterEqual(paused[name], 50, name)
|
||||
self.assertLess(paused[name], 1000, name)
|
||||
|
||||
def test_other_programs_keep_the_real_clock(self):
|
||||
def test_program_without_preload_keeps_the_real_clock(self):
|
||||
plain = self.run_program(self.other, 0, preload=False)
|
||||
paused = self.run_program(self.other, SHIFT_MS)
|
||||
paused = self.run_program(self.other, SHIFT_MS, preload=False)
|
||||
self.assertAlmostEqual(paused["gap"], plain["gap"], delta=50)
|
||||
for name in ("cond_mono", "clockwait", "sem", "nanosleep", "timerfd", "futex"):
|
||||
self.assertGreaterEqual(paused[name], 50, name)
|
||||
self.assertLess(paused[name], 1000, name)
|
||||
|
||||
def test_every_session_program_stops_monotonic_clock_and_keeps_memory_access(self):
|
||||
plain = self.run_program(self.other, 0)
|
||||
paused = self.run_program(self.other, SHIFT_MS)
|
||||
self.assertAlmostEqual(paused["gap"] - plain["gap"], SHIFT_MS, delta=50)
|
||||
self.assertAlmostEqual(paused["rawgap"] - plain["rawgap"], SHIFT_MS, delta=50)
|
||||
self.assertEqual(plain["memory"], 130560)
|
||||
self.assertEqual(paused["memory"], 130560)
|
||||
|
||||
def test_running_session_program_observes_pause_offset_update(self):
|
||||
self.check_running_offset_update(False)
|
||||
|
||||
def test_session_reset_preserves_live_guest_mapping(self):
|
||||
self.check_running_offset_update(True)
|
||||
|
||||
def check_running_offset_update(self, reset):
|
||||
self.control.write_bytes(struct.pack("<q", 0))
|
||||
env = dict(os.environ)
|
||||
env["LD_PRELOAD"] = str(self.preload)
|
||||
env["CLOCK_PAUSE_WAIT"] = "1"
|
||||
with tempfile.TemporaryFile(mode="w+") as errors:
|
||||
process = subprocess.Popen([str(self.other)], env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
|
||||
stderr=errors, text=True)
|
||||
lines = queue.Queue()
|
||||
|
||||
def read_handshake():
|
||||
for _ in range(4):
|
||||
line = process.stdout.readline()
|
||||
lines.put(line)
|
||||
if not line:
|
||||
break
|
||||
|
||||
threading.Thread(target=read_handshake, daemon=True).start()
|
||||
try:
|
||||
handshake = []
|
||||
for _ in range(4):
|
||||
try:
|
||||
line = lines.get(timeout=5)
|
||||
except queue.Empty:
|
||||
line = ""
|
||||
if not line:
|
||||
if process.poll() is None:
|
||||
process.kill()
|
||||
process.wait(timeout=5)
|
||||
errors.seek(0)
|
||||
self.fail(f"child handshake timed out or ended early (exit {process.returncode}): {errors.read()}")
|
||||
handshake.append(line.strip())
|
||||
self.assertEqual(handshake[3], "ready")
|
||||
self.assertTrue(handshake[0].startswith("gap "))
|
||||
initial_gap = int(handshake[0].split()[1])
|
||||
rawgap = handshake[1]
|
||||
memory = handshake[2]
|
||||
self.assertTrue(rawgap.startswith("rawgap "))
|
||||
self.assertEqual(memory, "memory 130560")
|
||||
if reset:
|
||||
inode = self.control.stat().st_ino
|
||||
subprocess.run(["bash", "-c", clock_reset_command(self.control)],
|
||||
check=True, timeout=5)
|
||||
self.assertEqual(self.control.stat().st_ino, inode)
|
||||
self.assertEqual(self.control.read_bytes(), struct.pack("<q", 0))
|
||||
with self.control.open("r+b") as control:
|
||||
control.write(struct.pack("<q", SHIFT_MS * 1000000))
|
||||
control.flush()
|
||||
process.stdin.write("\n")
|
||||
process.stdin.flush()
|
||||
output, _ = process.communicate(timeout=5)
|
||||
errors.seek(0)
|
||||
self.assertEqual(process.returncode, 0, errors.read())
|
||||
values = dict(line.split() for line in output.splitlines())
|
||||
self.assertAlmostEqual(int(values["livegap"]) - initial_gap, SHIFT_MS, delta=50)
|
||||
self.assertEqual(int(values["livememory"]), 130560)
|
||||
finally:
|
||||
if process.poll() is None:
|
||||
process.kill()
|
||||
process.communicate()
|
||||
|
||||
|
||||
class ClockResetCommandTest(unittest.TestCase):
|
||||
def test_reset_keeps_paths_with_spaces_and_shell_syntax_as_single_arguments(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
folder = root / "session dir; touch injected $(touch substituted) 'quoted'"
|
||||
folder.mkdir()
|
||||
control = folder / "clock"
|
||||
control.write_bytes(struct.pack("<q", 10_000_000_000) + b"tail")
|
||||
(folder / "zram").write_text("1")
|
||||
bystander = root / "session"
|
||||
bystander.write_text("keep")
|
||||
inode = control.stat().st_ino
|
||||
subprocess.run(["bash", "-c", clock_reset_command(control)], cwd=root, check=True, timeout=5)
|
||||
self.assertEqual(control.stat().st_ino, inode)
|
||||
self.assertEqual(control.read_bytes(), struct.pack("<q", 0) + b"tail")
|
||||
self.assertFalse((folder / "zram").exists())
|
||||
self.assertEqual(bystander.read_text(), "keep")
|
||||
self.assertEqual(sorted(path.name for path in root.iterdir()), sorted([folder.name, bystander.name]))
|
||||
|
||||
def test_reset_does_not_rewrite_placeholders_inside_substituted_paths(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
folder = root / "tmp/.bl-zram/$(touch injected)"
|
||||
folder.mkdir(parents=True)
|
||||
control = folder / "clock"
|
||||
control.write_bytes(struct.pack("<q", 10_000_000_000))
|
||||
(folder / "zram").write_text("1")
|
||||
inode = control.stat().st_ino
|
||||
subprocess.run(["bash", "-c", clock_reset_command(control)], cwd=root, check=True, timeout=5)
|
||||
self.assertEqual(control.stat().st_ino, inode)
|
||||
self.assertEqual(control.read_bytes(), struct.pack("<q", 0))
|
||||
self.assertFalse((folder / "zram").exists())
|
||||
self.assertEqual([path.name for path in root.iterdir()], ["tmp"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,267 @@
|
||||
import ctypes
|
||||
import mmap
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
import struct
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from tools.tests.test_clock_pause_preload import clock_reset_command
|
||||
from tools.tests.test_output_refresh import extract_function as extract_void_function
|
||||
from tools.tests.test_scene_limit_hold import extract_function
|
||||
|
||||
SOURCE = Path(__file__).resolve().parents[2] / "app/src/main/cpp/waylandcomp/src/clock_domain.c"
|
||||
HEADER = SOURCE.with_suffix(".h")
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which("cc"), "needs a C compiler")
|
||||
class WaylandClockDomainTest(unittest.TestCase):
|
||||
def test_host_timestamp_uses_the_guest_domain(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
control.write_bytes(struct.pack("<q", 10_000_000_000))
|
||||
program = root / "program.c"
|
||||
program.write_text(
|
||||
'#include <stdio.h>\n'
|
||||
'#include "clock_domain.h"\n'
|
||||
'int main(int argc, char **argv) { (void)argc;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld %u %lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL), '
|
||||
' droiddeck_clock_domain_now_ms(), (long long)droiddeck_clock_domain_adjust_ns(5LL * 1000000000LL));\n'
|
||||
' return 0;\n'
|
||||
'}\n'
|
||||
)
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)],
|
||||
check=True)
|
||||
result = subprocess.run([str(binary), str(control)], capture_output=True, text=True, check=True)
|
||||
adjusted, now_ms, clamped = map(int, result.stdout.split())
|
||||
self.assertEqual(adjusted, 20_000_000_000)
|
||||
self.assertGreaterEqual(now_ms, 0)
|
||||
self.assertLessEqual(now_ms, 0xFFFFFFFF)
|
||||
self.assertEqual(clamped, 0)
|
||||
|
||||
def test_paced_release_uses_kernel_time_across_pause_offsets(self):
|
||||
compositor = SOURCE.with_name("compositor.c").read_text()
|
||||
functions = extract_function(compositor, "now_ns") + "\n" + extract_void_function(compositor, "arm_release_timer")
|
||||
harness = r'''
|
||||
#define _GNU_SOURCE
|
||||
#include <assert.h>
|
||||
#include <fcntl.h>
|
||||
#include <poll.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/timerfd.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include "clock_domain.h"
|
||||
|
||||
struct pending_release { void *buffer; int64_t at_ns; struct pending_release *next; };
|
||||
static struct pending_release *g_pending_releases;
|
||||
static int g_release_timer_fd;
|
||||
#define wl_list_for_each(pr, list, link) for (pr = *(list); pr; pr = pr->next)
|
||||
static int buffer_release_blocked(void *buffer) { return buffer != NULL; }
|
||||
|
||||
@FUNCTIONS@
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
(void)argc;
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
int control = open(argv[1], O_WRONLY);
|
||||
assert(control >= 0);
|
||||
g_release_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
|
||||
assert(g_release_timer_fd >= 0);
|
||||
const int64_t offsets[] = {0, 10000000000LL, 300000000000LL};
|
||||
for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) {
|
||||
assert(pwrite(control, &offsets[i], sizeof(offsets[i]), 0) == sizeof(offsets[i]));
|
||||
struct timespec started, ended;
|
||||
clock_gettime(CLOCK_MONOTONIC, &started);
|
||||
int64_t start = now_ns();
|
||||
struct pending_release blocked = {(void *)1, start + 1000000LL, NULL};
|
||||
struct pending_release release = {NULL, start + 60000000LL, &blocked};
|
||||
g_pending_releases = &release;
|
||||
arm_release_timer();
|
||||
int64_t next_offset = offsets[i] + 10000000000LL;
|
||||
assert(pwrite(control, &next_offset, sizeof(next_offset), 0) == sizeof(next_offset));
|
||||
struct pollfd pollfd = {g_release_timer_fd, POLLIN, 0};
|
||||
assert(poll(&pollfd, 1, 1000) == 1);
|
||||
clock_gettime(CLOCK_MONOTONIC, &ended);
|
||||
int64_t elapsed = (ended.tv_sec - started.tv_sec) * 1000000000LL + ended.tv_nsec - started.tv_nsec;
|
||||
assert(elapsed >= 50000000LL && elapsed < 1000000000LL);
|
||||
uint64_t expirations;
|
||||
assert(read(g_release_timer_fd, &expirations, sizeof(expirations)) == sizeof(expirations));
|
||||
assert(expirations == 1);
|
||||
g_pending_releases = &blocked;
|
||||
arm_release_timer();
|
||||
struct itimerspec remaining;
|
||||
assert(timerfd_gettime(g_release_timer_fd, &remaining) == 0);
|
||||
assert(remaining.it_value.tv_sec == 0 && remaining.it_value.tv_nsec == 0);
|
||||
}
|
||||
close(g_release_timer_fd);
|
||||
close(control);
|
||||
return 0;
|
||||
}
|
||||
'''
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
control.write_bytes(struct.pack("<q", 0))
|
||||
program = root / "program.c"
|
||||
program.write_text(harness.replace("@FUNCTIONS@", functions))
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent),
|
||||
"-o", str(binary), str(program), str(SOURCE)], check=True)
|
||||
subprocess.run([str(binary), str(control)], check=True, timeout=5)
|
||||
|
||||
def test_zero_and_missing_offsets_are_unchanged(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
control.write_bytes(struct.pack("<q", 0))
|
||||
program = root / "program.c"
|
||||
program.write_text(
|
||||
'#include <stdio.h>\n'
|
||||
'#include "clock_domain.h"\n'
|
||||
'int main(int argc, char **argv) { (void)argc;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' droiddeck_clock_domain_set_control(argv[2]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' return 0;\n'
|
||||
'}\n'
|
||||
)
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)],
|
||||
check=True)
|
||||
result = subprocess.run([str(binary), str(control), str(root / "missing")], capture_output=True, text=True, check=True)
|
||||
self.assertEqual(result.stdout.split(), ["30000000000", "30000000000"])
|
||||
|
||||
def test_replaced_control_file_updates_offset_without_invalidating_readers(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
replacement = root / "replacement"
|
||||
control.write_bytes(struct.pack("<q", 10_000_000_000))
|
||||
replacement.write_bytes(struct.pack("<q", 20_000_000_000))
|
||||
program = root / "program.c"
|
||||
program.write_text(
|
||||
'#include <stdio.h>\n'
|
||||
'#include "clock_domain.h"\n'
|
||||
'int main(int argc, char **argv) { (void)argc;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' if (rename(argv[2], argv[1]) != 0) return 1;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' return 0;\n'
|
||||
'}\n'
|
||||
)
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent), "-o", str(binary), str(program), str(SOURCE)],
|
||||
check=True)
|
||||
result = subprocess.run([str(binary), str(control), str(replacement)], capture_output=True, text=True, check=True)
|
||||
self.assertEqual(result.stdout.split(), ["20000000000", "10000000000"])
|
||||
|
||||
def test_session_transition_clears_stale_offset_but_live_failures_preserve_it(self):
|
||||
harness = r'''
|
||||
#include <assert.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
#include "clock_domain.h"
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
(void)argc;
|
||||
int64_t shift = 10000000000LL;
|
||||
int fd = open(argv[1], O_CREAT | O_RDWR, 0600);
|
||||
assert(fd >= 0);
|
||||
assert(write(fd, &shift, sizeof(shift)) == sizeof(shift));
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL);
|
||||
assert(unlink(argv[1]) == 0);
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL);
|
||||
int replacement = open(argv[1], O_CREAT | O_RDWR, 0600);
|
||||
assert(replacement >= 0);
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 20000000000LL);
|
||||
droiddeck_clock_domain_set_control(NULL);
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 30000000000LL);
|
||||
shift = 20000000000LL;
|
||||
assert(write(replacement, &shift, sizeof(shift)) == sizeof(shift));
|
||||
droiddeck_clock_domain_set_control(argv[1]);
|
||||
assert(droiddeck_clock_domain_adjust_ns(30000000000LL) == 10000000000LL);
|
||||
close(replacement);
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
'''
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
program = root / "program.c"
|
||||
program.write_text(harness)
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent),
|
||||
"-o", str(binary), str(program), str(SOURCE)], check=True)
|
||||
subprocess.run([str(binary), str(root / "clock")], check=True, timeout=5)
|
||||
host = SOURCE.parents[3] / "java/com/droiddeck/launcher/wayland/CompositorHost.kt"
|
||||
self.assertIn("nativeSetClockControl(null)", host.read_text().split("fun newSession() {", 1)[1].split("}", 1)[0])
|
||||
|
||||
def test_startup_reset_keeps_host_and_guest_on_the_same_inode(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
control.write_bytes(struct.pack("<q", 10_000_000_000))
|
||||
library = root / "clock.so"
|
||||
subprocess.run(["cc", "-shared", "-fPIC", "-pthread", "-Wall", "-Wextra", "-Werror",
|
||||
"-o", str(library), str(SOURCE)], check=True)
|
||||
host = ctypes.CDLL(str(library))
|
||||
host.droiddeck_clock_domain_set_control.argtypes = [ctypes.c_char_p]
|
||||
host.droiddeck_clock_domain_adjust_ns.argtypes = [ctypes.c_int64]
|
||||
host.droiddeck_clock_domain_adjust_ns.restype = ctypes.c_int64
|
||||
host.droiddeck_clock_domain_set_control(str(control).encode())
|
||||
with control.open("r+b") as file, mmap.mmap(file.fileno(), 8) as guest:
|
||||
inode = control.stat().st_ino
|
||||
subprocess.run(["bash", "-c", clock_reset_command(control)],
|
||||
check=True, timeout=5)
|
||||
self.assertEqual(control.stat().st_ino, inode)
|
||||
self.assertEqual(struct.unpack("<q", guest[:])[0], 0)
|
||||
self.assertEqual(host.droiddeck_clock_domain_adjust_ns(30_000_000_000), 30_000_000_000)
|
||||
file.seek(0)
|
||||
file.write(struct.pack("<q", 20_000_000_000))
|
||||
file.flush()
|
||||
self.assertEqual(struct.unpack("<q", guest[:])[0], 20_000_000_000)
|
||||
self.assertEqual(host.droiddeck_clock_domain_adjust_ns(30_000_000_000), 10_000_000_000)
|
||||
host.droiddeck_clock_domain_set_control(None)
|
||||
|
||||
def test_initially_missing_control_is_mapped_after_creation(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
control = root / "clock"
|
||||
replacement = root / "replacement"
|
||||
replacement.write_bytes(struct.pack("<q", 20_000_000_000))
|
||||
program = root / "program.c"
|
||||
program.write_text(
|
||||
'#include <stdio.h>\n'
|
||||
'#include "clock_domain.h"\n'
|
||||
'int main(int argc, char **argv) { (void)argc;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' if (rename(argv[2], argv[1]) != 0) return 1;\n'
|
||||
' droiddeck_clock_domain_set_control(argv[1]);\n'
|
||||
' printf("%lld\\n", (long long)droiddeck_clock_domain_adjust_ns(30LL * 1000000000LL));\n'
|
||||
' return 0;\n'
|
||||
'}\n'
|
||||
)
|
||||
binary = root / "program"
|
||||
subprocess.run(["cc", "-Wall", "-Wextra", "-Werror", "-O2", "-I", str(SOURCE.parent),
|
||||
"-o", str(binary), str(program), str(SOURCE)], check=True)
|
||||
result = subprocess.run([str(binary), str(control), str(replacement)], capture_output=True, text=True, check=True)
|
||||
self.assertEqual(result.stdout.split(), ["30000000000", "10000000000"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user