Files
totk-pc-recomp/tests/exefs_plugins_test.py
T
Valiantsin DzerakhandClaude Opus 5.5 81c004094d The installer's plugin service run finds its DLLs: they go beside the totk.exe it builds in temp (#845)
On the release path the service run's totk.exe in <temp>/build stopped before main with 0xc0000135 (SDL3.dll not
found): the DLLs are copied next to totk.exe in the install folder only by the compile step, after the lift. Every
plugin was skipped with warn.plugins_skipped. The fake-tool tests did not see it; installer_test now checks the copy.
exefs_plugins_test covers run()'s hang and crash reasons.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 09:52:37 +03:00

592 lines
29 KiB
Python

"""recomp/layout.py with and without mod plugins, and tools/exefs_plugins.py's check of a plugin service run record:
a synthetic exlaunch-shaped record with one inline hook that passes, and one bad record per rule; the check of the
code the hooks reach; the patch lines of the three hook kinds; and what recomp/patches.py and recomp/gen.py make of
those lines (the hook call, the stub's return, the unpatched copy a replace hook's trampoline reaches, the start-up
record in patches.h). The start-up comparison itself runs in the game (runtime/plugin_init.c plugins_start); its
mods.c side is in totk.exe --probe-mods. No game files.
Run with .venv (lz4 and numpy, as recomp/): python tests/exefs_plugins_test.py
"""
import hashlib
import json
import struct
import sys
import tempfile
import unittest
from types import SimpleNamespace
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(ROOT / 'tools'))
sys.path.insert(0, str(ROOT / 'recomp'))
import exefs_plugins as xp # noqa: E402
import gen # noqa: E402
import layout # noqa: E402
import patches # noqa: E402
from nso import Nso # noqa: E402
def nso(size_text, bss=0x1000):
"""An uncompressed NSO: .text of size_text bytes (b over MOD0's offset word), .rodata with MOD0 at 0x1000 past
.text, .data with an empty .dynamic."""
text = bytearray(size_text)
struct.pack_into('<II', text, 0, 0x14000002, size_text) # b +8; the MOD0 offset
ro = b'MOD0' + struct.pack('<6i', 0x1000, 0, 0, 0, 0, 0) # .dynamic at .rodata + 0x1000 = .data
data = bytes(16) # DT_NULL
segs = [(0, bytes(text)), (size_text, ro), (size_text + 0x1000, data)]
hdr = bytearray(0x100)
hdr[0:4] = b'NSO0'
off = 0x100
for i, (mem, d) in enumerate(segs):
struct.pack_into('<IIII', hdr, 0x10 + 0x10 * i, off, mem, len(d), bss if i == 2 else 0)
struct.pack_into('<I', hdr, 0x60 + 4 * i, len(d))
off += len(d)
return bytes(hdr) + b''.join(d for _, d in segs)
def dev_layout_files(exefs, out):
"""layout.json and layout.h as recomp/layout.py wrote them before plugins (dev f8505807), the reference for the
no-plugin case."""
out.mkdir(parents=True, exist_ok=True)
mods, base = [], layout.FIRST_BASE
for name in layout.ORDER:
if (exefs / name).exists():
size = Nso(str(exefs / name)).size
mods.append((name, base, size))
base = layout.align_up(base + size)
(out / 'layout.json').write_text(json.dumps(
[{'name': n, 'base': f'{b:#x}', 'size': f'{s:#x}'} for n, b, s in mods], indent=1) + '\n')
lines = ['// Module layout chosen by recomp/layout.py. Generated; do not edit.', '#pragma once', '']
for n, b, s in mods:
lines.append(f'#define MOD_{n.upper()}_BASE {b:#x}ull')
lines.append(f'#define MOD_{n.upper()}_SIZE {s:#x}ull')
lines += ['', f'#define MOD_COUNT {len(mods)}',
'#define MOD_LIST(X) ' + ' '.join(f'X({n}, {n.upper()})' for n, _, _ in mods), '']
(out / 'layout.h').write_text('\n'.join(lines))
class Layout(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp = tempfile.TemporaryDirectory()
cls.dir = Path(cls.tmp.name)
cls.exefs = cls.dir / 'exefs'
cls.exefs.mkdir()
for name, size in (('main', 0x30000), ('subsdk0', 0x5000), ('sdk', 0x21000)):
(cls.exefs / name).write_bytes(nso(size))
cls.plugins = [cls.dir / 'mod a' / 'subsdk9', cls.dir / 'mod b' / 'subsdk8']
for p, size in zip(cls.plugins, (0x9000, 0x3000)):
p.parent.mkdir()
p.write_bytes(nso(size))
@classmethod
def tearDownClass(cls):
cls.tmp.cleanup()
def test_no_plugins_identical(self):
dev, ours = self.dir / 'dev', self.dir / 'ours'
dev_layout_files(self.exefs, dev)
layout.write(layout.layout(self.exefs), ours, layout.plugin_files([]))
for f in ('layout.json', 'layout.h'):
self.assertEqual((dev / f).read_bytes(), (ours / f).read_bytes(), f)
def test_plugins_after_sdk(self):
plain = layout.layout(self.exefs)
mods = layout.layout(self.exefs, self.plugins)
self.assertEqual(mods[:3], plain) # the game modules keep their bases
self.assertEqual([n for n, _, _ in mods], ['main', 'subsdk0', 'sdk', 'plugin0', 'plugin1'])
for (_, b0, s0), (_, b1, _) in zip(mods, mods[1:]):
self.assertEqual(b1, layout.align_up(b0 + s0))
self.assertEqual(mods[3][2], Nso(str(self.plugins[0])).size)
out = self.dir / 'with'
files = layout.plugin_files(self.plugins)
layout.write(mods, out, files)
data = json.loads((out / 'layout.json').read_text())
self.assertNotIn('file', data[2])
self.assertEqual(data[3]['file'], self.plugins[0].resolve().as_posix())
self.assertEqual(len(data[3]['sha256']), 64)
self.assertEqual(layout.read(out), mods)
self.assertIn('#define MOD_PLUGIN1_BASE', (out / 'layout.h').read_text())
self.assertIn('#define MOD_COUNT 5', (out / 'layout.h').read_text())
def test_address_limit(self):
old = layout.FIRST_BASE
layout.FIRST_BASE = layout.ADDRESS_LIMIT - 0x400000 # the plugins end above 2^39
try:
with self.assertRaises(ValueError):
layout.layout(self.exefs, self.plugins)
finally:
layout.FIRST_BASE = old
# ---- records
MAIN, PLUGIN = 0x7000000000, 0x7005200000
SITE_OFF, STUB_OFF, TRAMP_OFF, CB_OFF, IMPL_OFF, THUNK_OFF = 0x1000, 0x4000, 0x2000, 0x66f0, 0x73ec, 0xf00
MAIN_TEXT, PLUGIN_TEXT = 0x100000, 0x9000
def b(src, dst, link=False):
return (0x94000000 if link else 0x14000000) | ((dst - src) >> 2) & 0x3FFFFFF
def record(original=0x94000010, trampoline_first=None, stub=None, writes=None, **extra):
"""A record of one inline hook at main+SITE_OFF whose original is `original` (default bl main+SITE_OFF+0x40)."""
site, stub_at, tramp = MAIN + SITE_OFF, PLUGIN + STUB_OFF, PLUGIN + TRAMP_OFF
img = bytearray(0x14000)
words = stub or [xp.STUR_X30, b(stub_at + 4, PLUGIN + IMPL_OFF, True), xp.LDUR_X30, b(stub_at + 12, tramp)]
struct.pack_into('<4IQ', img, STUB_OFF, *words, PLUGIN + CB_OFF)
if trampoline_first is None:
rel = xp.pc_relative(original, site)
trampoline_first = (b(tramp, rel[1], True) if rel and rel[0][0] == 'b' else original)
struct.pack_into('<II', img, TRAMP_OFF, trampoline_first, b(tramp + 4, site + 4))
rec = {
'refused': None, 'svcs': {'0x6': 52, '0x1e': 10, '0x27': 18, '0x29': 17, '0x74': 11, '0x75': 7},
'get_info': {'2': 1, '3': 1, '12': 1, '13': 1, '65001': 1},
'imports': {'_ZN2nn4util8SNPrintfEPcmPKcz': 20, '_ZN2nn2oe17GetDisplayVersionEPNS0_14DisplayVersionE': 1},
'modules': [
{'name': 'main', 'base': MAIN, 'size': 0x200000, 'text_end': MAIN_TEXT, 'data_off': 0x180000, 'init': 0,
'plugin': False},
{'name': 'sdk', 'base': 0x7004400000, 'size': 0x100000, 'text_end': 0x80000, 'data_off': 0xc0000,
'init': 0, 'plugin': False},
{'name': 'plugin0', 'base': PLUGIN, 'size': 0x14000, 'text_end': PLUGIN_TEXT, 'data_off': 0xd000,
'init': PLUGIN + 0x50a0, 'plugin': True, 'functions': [hex(CB_OFF), hex(IMPL_OFF), hex(THUNK_OFF)]}],
'writes': writes if writes is not None else [
{'module': 'main', 'offset': SITE_OFF, 'old': original, 'new': b(site, stub_at)}],
'aliases': [], 'images': {'plugin0': bytes(img)}}
rec.update(extra)
return rec
IMPLS = {PLUGIN + IMPL_OFF: 'exl_inline_hook_impl'}
class Check(unittest.TestCase):
def reasons(self, rec):
return xp.check_record(rec, IMPLS)[1]
def refused(self, rec, text):
r = self.reasons(rec)
self.assertTrue(r, 'accepted')
self.assertTrue(any(text in x for x in r), r)
def test_good(self):
hooks, reasons = xp.check_record(record(), IMPLS)
self.assertEqual(reasons, [])
self.assertEqual(len(hooks), 1)
self.assertEqual(hooks[0]['callback'], f'plugin0+{CB_OFF:#x}')
self.assertEqual(hooks[0]['trampoline'], f'plugin0+{TRAMP_OFF:#x}')
def test_good_plain_original(self):
self.assertEqual(self.reasons(record(original=0xAA0003F3)), []) # mov x19, x0, copied as it is
def test_call_site_rewrite(self): # Quick Weapon Durability: bl straight to a thunk of the plugin
site = MAIN + SITE_OFF
w = [{'module': 'main', 'offset': SITE_OFF, 'old': 0x94000010, 'new': b(site, PLUGIN + THUNK_OFF, True)}]
hooks, reasons = xp.check_record(record(writes=w), IMPLS)
self.assertEqual(reasons, [])
self.assertEqual(hooks[0]['kind'], 'call')
self.assertEqual(hooks[0]['target'], f'plugin0+{THUNK_OFF:#x}')
def test_replace_hook(self): # Full Inventory Expansion: b from a main function start, Orig trampoline in the pool
site, prologue = MAIN + SITE_OFF, 0xA9BA7BFD # stp x29, x30, [sp, #-0x60]!
w = [{'module': 'main', 'offset': SITE_OFF, 'old': prologue, 'new': b(site, PLUGIN + THUNK_OFF),
'fn_start': True}]
hooks, reasons = xp.check_record(record(original=prologue, writes=w), IMPLS)
self.assertEqual(reasons, [])
self.assertEqual(hooks[0]['kind'], 'replace')
self.assertEqual(hooks[0]['trampoline'], f'plugin0+{TRAMP_OFF:#x}')
def test_replace_inside_function(self):
w = [{'module': 'main', 'offset': SITE_OFF, 'old': 0x94000010, 'new': b(MAIN + SITE_OFF, PLUGIN + THUNK_OFF),
'fn_start': False}]
self.refused(record(writes=w), 'from inside a main function')
def test_call_into_function_middle(self):
w = [{'module': 'main', 'offset': SITE_OFF, 'old': 0x94000010, 'new': b(MAIN + SITE_OFF, PLUGIN + 0xf08, True)}]
self.refused(record(writes=w), 'neither an inline-hook stub nor a function start')
def test_bl_to_stub(self): # an inline stub is entered by b; a bl there would skip the saved x30
w = [{'module': 'main', 'offset': SITE_OFF, 'old': 0x94000010, 'new': b(MAIN + SITE_OFF, PLUGIN + STUB_OFF, True)}]
self.refused(record(writes=w), 'neither an inline-hook stub nor a function start')
def test_refused_run(self):
self.refused(record(refused='svc 0x40 at plugin0+0x76a0'), 'the run was refused')
def test_svc(self):
self.refused(record(svcs={'0x6': 1, '0x40': 1}), 'svc 0x40')
def test_get_info(self):
self.refused(record(get_info={'2': 1, '18': 1}), 'GetInfo id 18')
def test_import(self):
self.refused(record(imports={'_ZN2nn2fs8MountRomEPKcPvm': 1}), 'the import _ZN2nn2fs8MountRom')
def test_write_main_data(self):
w = [{'module': 'main', 'offset': 0x180008, 'old': 0, 'new': 1}]
self.refused(record(writes=w), "outside main's .text: main+0x180008")
def test_write_other_module(self):
w = [{'module': 'sdk', 'offset': 0x100, 'old': 0, 'new': 1}]
self.refused(record(writes=w), "outside main's .text: sdk+0x100")
def test_not_a_branch(self):
w = [{'module': 'main', 'offset': SITE_OFF, 'old': 0x94000010, 'new': 0xD503201F}]
self.refused(record(writes=w), 'is no b')
def test_branch_elsewhere(self):
w = [{'module': 'main', 'offset': SITE_OFF, 'old': 0x94000010, 'new': b(MAIN + SITE_OFF, MAIN + 0x8000)}]
self.refused(record(writes=w), "does not reach into a plugin's .text")
def test_stub_shape(self):
stub_at = PLUGIN + STUB_OFF
words = [0xD503201F, b(stub_at + 4, PLUGIN + IMPL_OFF, True), xp.LDUR_X30, b(stub_at + 12, PLUGIN + TRAMP_OFF)]
self.refused(record(stub=words), 'neither an inline-hook stub nor a function start')
def test_stub_impl(self):
stub_at = PLUGIN + STUB_OFF
words = [xp.STUR_X30, b(stub_at + 4, PLUGIN + 0x100, True), xp.LDUR_X30, b(stub_at + 12, PLUGIN + TRAMP_OFF)]
self.refused(record(stub=words), 'not exl_inline_hook_impl')
def test_callback_outside(self):
rec = record()
img = bytearray(rec['images']['plugin0'])
struct.pack_into('<Q', img, STUB_OFF + 16, MAIN + 0x500)
rec['images']['plugin0'] = bytes(img)
self.refused(rec, "callback 0x7000000500 is outside plugin0's .text")
def test_trampoline_not_original(self):
self.refused(record(original=0xAA0003F3, trampoline_first=0xAA0003F4), 'not the original')
def test_trampoline_bl_elsewhere(self):
tramp = PLUGIN + TRAMP_OFF
self.refused(record(trampoline_first=b(tramp, MAIN + SITE_OFF + 0x44, True)), 'not the original')
def test_trampoline_return(self):
rec = record()
img = bytearray(rec['images']['plugin0'])
struct.pack_into('<I', img, TRAMP_OFF + 4, b(PLUGIN + TRAMP_OFF + 4, MAIN + SITE_OFF + 8))
rec['images']['plugin0'] = bytes(img)
self.refused(rec, 'no b to the site + 4')
def test_indirect_original(self):
self.refused(record(original=0xD65F03C0), 'is a br, blr or ret')
class Diff(unittest.TestCase):
def test_lists_differing_words(self):
a, c = record(), record()
img = bytearray(c['images']['plugin0'])
struct.pack_into('<Q', img, 0x13450, 0x2345000000)
c['images']['plugin0'] = bytes(img)
a['pool'] = c['pool'] = {'base': '0x2000000000', 'size': '0x1000000000'}
lines = xp.diff_records(a, c)
self.assertEqual(len(lines), 1)
self.assertIn('plugin0+0x13450', lines[0])
self.assertIn('alias pool', lines[0])
self.assertEqual(xp.diff_records(a, record()), [])
# ---- the code the hooks reach
SVC_40, RET_W, NOP = 0xD4000801, 0xD65F03C0, 0xD503201F
def code(words, at=0):
img = bytearray(0x200)
for i, w in enumerate(words):
struct.pack_into('<I', img, at + 4 * i, w)
return bytes(img)
class Reach(unittest.TestCase):
BASE = 0x7005200000
def test_follows_calls_and_finds_svc(self):
# root: bl +0x40; ret. callee at 0x40: svc 0x40; ret
img = bytearray(code([b(self.BASE, self.BASE + 0x40, True), RET_W]))
struct.pack_into('<II', img, 0x40, SVC_40, RET_W)
svcs, imports, indirect, outside = xp.reach(bytes(img), self.BASE, 0x200, [self.BASE], {})
self.assertEqual(svcs, {0x40})
def test_imports_through_plt(self):
img = code([b(self.BASE, self.BASE + 0x80, True), RET_W])
svcs, imports, _, _ = xp.reach(img, self.BASE, 0x200, [self.BASE], {self.BASE + 0x80: 'malloc'})
self.assertEqual((svcs, imports), (set(), {'malloc': 1}))
def test_stub_returns_at_its_trampoline_branch(self):
# stur; bl impl; ldur; b trampoline (where an svc sits): the b is the stub's return
stub = [xp.STUR_X30, b(self.BASE + 4, self.BASE + 0x40, True), xp.LDUR_X30, b(self.BASE + 12, self.BASE + 0x100)]
img = bytearray(code(stub))
struct.pack_into('<I', img, 0x40, RET_W)
struct.pack_into('<I', img, 0x100, SVC_40)
self.assertEqual(xp.reach(bytes(img), self.BASE, 0x200, [self.BASE], {}, stubs={self.BASE})[0], set())
self.assertEqual(xp.reach(bytes(img), self.BASE, 0x200, [self.BASE], {})[0], {0x40})
def test_indirect_calls_counted(self):
img = code([0xD63F0100, RET_W]) # blr x8
self.assertEqual(xp.reach(img, self.BASE, 0x200, [self.BASE], {})[2], 1)
def test_check_refuses_svc_in_callback(self):
rec = record()
img = bytearray(rec['images']['plugin0'])
struct.pack_into('<II', img, CB_OFF, SVC_40, RET_W)
struct.pack_into('<I', img, IMPL_OFF, RET_W)
rec['images']['plugin0'] = bytes(img)
hooks, _ = xp.check_record(rec, IMPLS)
reasons, _ = xp.reach_check(rec, hooks, IMPLS)
self.assertTrue(any('svc 0x40' in r for r in reasons), reasons)
def test_check_allows_output_debug_string(self):
rec = record()
img = bytearray(rec['images']['plugin0'])
struct.pack_into('<II', img, CB_OFF, 0xD40004E1, RET_W) # svc 0x27
struct.pack_into('<I', img, IMPL_OFF, RET_W)
rec['images']['plugin0'] = bytes(img)
hooks, _ = xp.check_record(rec, IMPLS)
self.assertEqual(xp.reach_check(rec, hooks, IMPLS)[0], [])
# ---- patch lines of the three hook kinds
class Lines(unittest.TestCase):
def lines(self, rec):
hooks, reasons = xp.check_record(rec, IMPLS)
self.assertEqual(reasons, [])
with tempfile.TemporaryDirectory() as d:
(Path(d) / 'plugin0.img').write_bytes(rec['images']['plugin0'])
rec['modules'][2]['image'] = 'plugin0.img'
return xp.plugin_lines(rec, xp.hooks_of(hooks, 'plugin0'), 'mod_x', d, 'plugin0')
def test_inline(self):
out = self.lines(record(original=0xAA0003F3))
self.assertIn(f'site mod_x main {SITE_OFF:x} aa0003f3 @call:plugin0+{STUB_OFF:x} aa0003f3', out)
self.assertIn(f'stub plugin0 {STUB_OFF:x}', out)
self.assertIn(f'seed plugin0 {CB_OFF:x} {IMPL_OFF:x}', out)
self.assertIn(f'expect mod_x main {SITE_OFF:x} aa0003f3 {b(MAIN + SITE_OFF, PLUGIN + STUB_OFF):08x}', out)
self.assertTrue(out[0].startswith('plugin mod_x plugin0 '))
def test_replace(self):
site, prologue = MAIN + SITE_OFF, 0xA9BA7BFD
new = b(site, PLUGIN + THUNK_OFF)
w = [{'module': 'main', 'offset': SITE_OFF, 'old': prologue, 'new': new, 'fn_start': True}]
out = self.lines(record(original=prologue, writes=w))
self.assertIn(f'site mod_x main {SITE_OFF:x} a9ba7bfd {new:08x}', out)
self.assertIn(f'orig mod_x plugin0 {TRAMP_OFF:x} main {SITE_OFF:x}', out)
self.assertIn(f'seed plugin0 {THUNK_OFF:x}', out)
def test_call(self):
new = b(MAIN + SITE_OFF, PLUGIN + THUNK_OFF, True)
w = [{'module': 'main', 'offset': SITE_OFF, 'old': 0x94000010, 'new': new}]
out = self.lines(record(writes=w))
self.assertIn(f'site mod_x main {SITE_OFF:x} 94000010 {new:08x}', out)
self.assertFalse(any(x.startswith(('orig', 'stub')) for x in out))
# ---- one service run per plugin
class PerPlugin(unittest.TestCase):
"""main() with three plugins in three mods and a stand-in for the service run: plugin0 hooks its site, plugin1's
init ends the run without a record (a crash), plugin2's run is refused (an svc). Each gets its own status line;
only plugin0's set goes into the patch file."""
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
self.d = Path(tmp.name)
self.files = []
for name in ('A', 'B', 'C'):
f = self.d / 'mods' / name / 'exefs' / 'subsdk9'
f.parent.mkdir(parents=True)
f.write_bytes(nso(PLUGIN_TEXT) + name.encode())
self.files.append(f)
(self.d / 'patches.txt').write_text('set fps60 TOTK_FPS60 1\n')
self.runs = []
saved = xp.run, xp.hook_impls
self.real_run = xp.run
self.addCleanup(lambda: (setattr(xp, 'run', saved[0]), setattr(xp, 'hook_impls', saved[1])))
xp.run, xp.hook_impls = self.fake_run, lambda rec: IMPLS
def fake_run(self, exe, out, tick_offset, timeout, only):
self.runs.append(only)
out.mkdir(parents=True, exist_ok=True)
if only == 'plugin1':
return 0xC0000005, 'its init ended the service run without a record (exit 0xc0000005)'
rec = record(writes=[] if only != 'plugin0' else None)
rec['modules'][2]['file'] = str(self.files[0])
for i in (1, 2):
rec['modules'].append(dict(rec['modules'][2], name=f'plugin{i}', base=PLUGIN + i * 0x100000,
file=str(self.files[i])))
for m in rec['modules'][2:]:
m['ran'] = m['name'] == only
if only == 'plugin2':
rec['refused'] = 'svc 0x1 at plugin2+0x50a0'
(out / 'plugin0.img').write_bytes(rec.pop('images')['plugin0'])
rec['modules'][2]['image'] = 'plugin0.img'
(out / 'record.json').write_text(json.dumps(rec))
return 3 if rec['refused'] else 0, None
def test_each_plugin_alone(self):
out, status, patched = self.d / 'rec', self.d / 'plugins.status', self.d / 'patches-out.txt'
argv = sys.argv
sys.argv = ['exefs_plugins.py', '--exe', 'totk.exe', '--out', str(out), '--mods', str(self.d / 'mods'),
'--patches', str(self.d / 'patches.txt'), '--patches-out', str(patched), '--status', str(status)]
try:
code = xp.main()
finally:
sys.argv = argv
self.assertEqual(code, 1)
self.assertEqual(self.runs, ['-', 'plugin0', 'plugin0', 'plugin1', 'plugin2'])
lines = {line.split('\t')[0]: line.split('\t') for line in status.read_text().splitlines()}
key = {n: xp.fnv(f'{n}/exefs/subsdk9'.encode()) for n in 'ABC'}
self.assertEqual(lines[key['A']][2:], ['plugin', '-', 'plugin0, 1 hooks'])
self.assertEqual(lines[key['B']][2], 'unsupported')
self.assertIn('ended the service run', lines[key['B']][4])
self.assertEqual(lines[key['C']][2], 'unsupported')
self.assertIn('svc 0x1', lines[key['C']][4])
text = patched.read_text()
self.assertIn(f'set mod_{key["A"].lower()} ', text)
self.assertNotIn(f'mod_{key["B"].lower()}', text)
self.assertNotIn(f'mod_{key["C"].lower()}', text)
self.assertIn((out / 'plugin0' / 'run1' / 'plugin0.img').resolve().as_posix(), text)
def test_run_reasons(self):
# the real run(): a hang becomes its own reason, a crash names the FATAL line
saved = xp.subprocess.run
self.addCleanup(setattr, xp.subprocess, 'run', saved)
def hang(cmd, **kw):
raise xp.subprocess.TimeoutExpired(cmd, kw['timeout'], output=b'started', stderr=None)
xp.subprocess.run = hang
self.assertEqual(self.real_run(None, self.d / 'h', 0, 7, 'plugin0'), (None, 'its init did not return within 7 s'))
xp.subprocess.run = lambda cmd, **kw: SimpleNamespace(returncode=0xC0000005, stdout='x\nFATAL: access violation '
'(0xc0000005) at host 1\n', stderr='')
code, why = self.real_run(None, self.d / 'c', 0, 7, 'plugin0')
self.assertEqual(why, 'its init crashed the service run: access violation (0xc0000005) at host 1')
def test_ran_view_leaves_out_plugins_that_did_not_run(self):
rec = record()
rec['modules'].append(dict(rec['modules'][2], name='plugin1', base=PLUGIN + 0x100000, ran=False))
rec['modules'][2]['ran'] = True
rec['images']['plugin1'] = rec['images']['plugin0']
view = xp.ran_view(rec)
self.assertEqual([m['name'] for m in view['modules'] if m['plugin']], ['plugin0'])
self.assertEqual(set(view['images']), {'plugin0'})
whole = record() # no "ran": every init ran, the record is its own view
self.assertIs(xp.ran_view(whole), whole)
# ---- the generator on those lines
def code_nso(words_at, size_text=0x5000):
"""An NSO as nso() whose .text holds words_at {offset: word}."""
raw = bytearray(nso(size_text))
for off, w in words_at.items():
struct.pack_into('<I', raw, 0x100 + off, w)
return bytes(raw)
FN = 0x100 # the hooked main function: mov x19, x0; mov x0, x19; ret
class Generator(unittest.TestCase):
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
self.d = Path(tmp.name)
exefs = self.d / 'exefs'
exefs.mkdir()
(exefs / 'main').write_bytes(code_nso({FN: 0xAA0003F3, FN + 4: 0xAA1303E0, FN + 8: RET_W}))
(exefs / 'sdk').write_bytes(nso(0x1000))
stub = PLUGIN_TEXT_STUB = 0x4000
self.plugin_file = self.d / 'subsdk9'
self.plugin_file.write_bytes(nso(0x5000))
self.mods = layout.layout(exefs, [self.plugin_file])
self.bases = {n: b_ for n, b_, _ in self.mods}
pb = self.bases['plugin0']
# the image after the init: a stub at 0x4000 (b to a trampoline at 0x2000), an impl at 0x4100, a callback at
# 0x4200
img = bytearray(Nso(str(self.plugin_file)).image)
struct.pack_into('<4IQ', img, stub, xp.STUR_X30, b(pb + stub + 4, pb + 0x4100, True), xp.LDUR_X30,
b(pb + stub + 12, pb + 0x2000), pb + 0x4200)
struct.pack_into('<I', img, 0x4100, RET_W)
struct.pack_into('<I', img, 0x4200, RET_W)
struct.pack_into('<II', img, 0x2000, 0xAA0003F3, b(pb + 0x2004, self.bases['main'] + FN + 4))
(self.d / 'plugin0.img').write_bytes(bytes(img))
n = Nso(str(self.plugin_file))
self.sha = hashlib.sha256(bytes(img[n.text[0]:n.text[0] + n.text[1]])).hexdigest()
def table(self, site_line, extra=()):
text = '\n'.join(['set mod_x TOTK_MODPATCH_X 0 ordered',
f'plugin mod_x plugin0 {self.sha} {(self.d / "plugin0.img").as_posix()}',
f'expect mod_x main {FN:x} aa0003f3 14000000', site_line, *extra]) + '\n'
(self.d / 'p.txt').write_text(text)
return patches.load(self.d / 'p.txt', self.mods)
def emit(self, table, name, entry, end, origs=()):
mod = gen.open_module(name, self.d / ('exefs/main' if name == 'main' else 'subsdk9'), self.bases[name], table,
plugin=name != 'main')
e = gen.Emitter(mod, {entry}, table.for_module(name, self.bases[name]), origs=set(origs))
return gen.chunk_text(name, 0, e, [(entry, end)])
def test_inline_hook_calls_the_stub_then_the_original(self):
t = self.table(f'site mod_x main {FN:x} aa0003f3 @call:plugin0+4000 aa0003f3', ['stub plugin0 4000',
'seed plugin0 4100 4200'])
m = self.bases['main'] + FN
c = self.emit(t, 'main', m, m + 12)
stub = self.bases['plugin0'] + 0x4000
on = c[c.index('if (rt_patch_on[0])'):]
self.assertLess(on.index(f'f_{stub:x}(c);'), on.index('} else {')) # the hook, then the original, when on
head = on[:on.index(f'f_{stub:x}(c);')]
self.assertNotIn('c->x[30] =', head) # no x30 written for the call
self.assertIn(f'void f_{stub:x}(Cpu *c);', c)
h = patches.header_text(t, 'MARK')
self.assertIn('#define RT_PLUGIN_COUNT 1', h)
self.assertIn(f'X(0, "main", {FN:#x}, 0xaa0003f3u, 0x14000000u)', h)
self.assertIn('X("plugin0", 0x4100) X("plugin0", 0x4200)', h)
def test_stub_returns_instead_of_branching_to_its_trampoline(self):
t = self.table(f'site mod_x main {FN:x} aa0003f3 @call:plugin0+4000 aa0003f3', ['stub plugin0 4000'])
stub = self.bases['plugin0'] + 0x4000
c = self.emit(t, 'plugin0', stub, stub + 16)
body = c[c.index(f'void f_{stub:x}(Cpu *c) {{'):]
self.assertIn('return;', body)
self.assertNotIn(f'{self.bases["plugin0"] + 0x2000:#x}', body) # the trampoline is not reached
def test_replace_hook_keeps_an_unpatched_copy(self):
pb = self.bases['plugin0']
m = self.bases['main'] + FN
new = b(m, pb + 0x4200)
t = self.table(f'site mod_x main {FN:x} aa0003f3 {new:08x}', [f'orig mod_x plugin0 2000 main {FN:x}',
'seed plugin0 4200'])
self.assertEqual(t.origs_for('main', self.bases['main']), {m})
self.assertEqual(t.orig_entries('plugin0', self.bases), {pb + 0x2000: m})
c = self.emit(t, 'main', m, m + 12, origs=[m])
copy = c[c.index(f'void fo_{m:x}(Cpu *c) {{'):]
self.assertNotIn('rt_patch_on', copy)
self.assertIn('rt_patch_on[0]', c[:c.index(f'void fo_{m:x}')])
tab = gen.table_text('plugin0', [pb + 0x4200, pb + 0x2000], {pb + 0x2000: gen.orig_name(m)})
self.assertIn(f'void fo_{m:x}(Cpu *c);', tab)
self.assertIn(f'fo_{m:x}', tab[tab.index('_fn_ptrs'):])
def test_image_must_match_its_hash(self):
t = self.table(f'site mod_x main {FN:x} aa0003f3 @call:plugin0+4000 aa0003f3', ['stub plugin0 4000'])
t.plugins['plugin0']['sha256'] = '0' * 64
with self.assertRaises(patches.PatchError):
gen.open_module('plugin0', self.plugin_file, self.bases['plugin0'], t)
def test_chunk_key_takes_the_unpatched_copy(self):
# the lift cache (recomp/gen.py chunk_key): a chunk whose function gets an unpatched copy is keyed apart, and a
# chunk without one keeps the key it had before plugins
fns = [(0x100, 0x10c)]
plain = gen.chunk_key('m', 0, fns, {}, [], {}, [], None, None)
self.assertEqual(gen.chunk_key('m', 0, fns, {}, [], {}, [], None, None, {0x200}), plain)
self.assertNotEqual(gen.chunk_key('m', 0, fns, {}, [], {}, [], None, None, {0x100}), plain)
site = {0x100: [(0, [('call', 0x7005204000), 0xAA0003F3])]}
self.assertNotEqual(gen.chunk_key('m', 0, fns, site, [0x100], {}, [], None, None),
gen.chunk_key('m', 0, fns, {0x100: [(0, [('call', 0x7005204010), 0xAA0003F3])]}, [0x100],
{}, [], None, None))
def test_no_plugin_lines_no_plugin_header(self):
(self.d / 'q.txt').write_text('set fps60 TOTK_FPS60 0\n')
self.assertNotIn('PLUGIN', patches.header_text(patches.load(self.d / 'q.txt', self.mods), 'MARK'))
if __name__ == '__main__':
unittest.main()