134 lines
8.6 KiB
Python
134 lines
8.6 KiB
Python
#!/usr/bin/env python3
|
|
"""Local-only SYSTEM trace diagnostic build; no VM and no product source edits."""
|
|
import base64
|
|
import hashlib
|
|
import importlib.util
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import uuid
|
|
|
|
ROOT = Path(__file__).resolve().parents[3]
|
|
HERE = Path(__file__).resolve().parent
|
|
STATE = ROOT / 'devstate/windows-clock-system-trace'
|
|
IMAGE = 'sha256:1b2fd985d2c1fcc3545ace602405dc68fa899201bd8a73fa319ff96377203fa9'
|
|
BASELINE = ROOT / 'devstate/windows-clock-midl/diagnostic-builds/181c3a1c-8324-41fd-9b7c-aa8010262912/qualification.json'
|
|
BASELINE_SHA = '2e0de3acf72ab5c3a8e0baa54e8643d086ea7c03d1b38fd89b6bfc00e45f8cbb'
|
|
NATIVE = ROOT / 'devstate/windows-clock-midl/native-cases/149bafe2-3469-4580-b133-988812bcc3db'
|
|
READBACK = NATIVE / 'readback-059c15ef-0f31-41aa-ad1d-ea6b774280d7.json'
|
|
READBACK_SHA = '0dc2373825f7f8f224cda04ecd5c521dd3c37a6e712bc3ed83bc4fa6d0d89c8c'
|
|
|
|
|
|
def require(value, message):
|
|
if not value: raise RuntimeError(message)
|
|
|
|
|
|
def sha(path):
|
|
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
|
|
|
|
|
|
def write(path, raw):
|
|
path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
|
|
fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
|
|
with os.fdopen(fd, 'wb') as output:
|
|
output.write(raw); output.flush(); os.fsync(output.fileno())
|
|
|
|
|
|
def save(path, value):
|
|
write(path, (json.dumps(value, indent=2) + '\n').encode())
|
|
|
|
|
|
def original_sources():
|
|
require(sha(BASELINE) == BASELINE_SHA, 'original b1d3 qualification')
|
|
value = json.loads(BASELINE.read_bytes())
|
|
require(len(value['source_files']) == 131 and value['artifact']['sha256'] == 'b1d3da4f393ddf20bc8e48a9894ee314666f2ac3613ef97f5c228e3d089ca560', 'unchanged complete original131 source set')
|
|
for name, digest in value['source_files'].items():
|
|
path = ROOT / name
|
|
require(not path.is_symlink() and path.is_file() and sha(path) == digest, 'original131 input changed')
|
|
return value
|
|
|
|
|
|
def own_sources():
|
|
return {str((HERE / name).relative_to(ROOT)):sha(HERE / name) for name in ('system_trace.c','build.py','native.py')}
|
|
|
|
|
|
def main():
|
|
os.umask(0o077)
|
|
baseline = original_sources(); before = own_sources()
|
|
require(sha(READBACK) == READBACK_SHA, 'actual Microsoft codegen readback')
|
|
receipt = json.loads(READBACK.read_bytes())
|
|
require(receipt['readback_only'] is True and receipt['result']['complete'] is True
|
|
and receipt['result']['run']['exit_code'] == 0 and receipt['result']['no_rpc'] is True,
|
|
'actual completed MIDL codegen')
|
|
folder = STATE / ('build-' + str(uuid.uuid4())); folder.mkdir(mode=0o700, parents=True)
|
|
source = folder / 'source'; source.mkdir(mode=0o700)
|
|
generated = {}
|
|
for name, digest in baseline['generated_inputs'].items():
|
|
path = NATIVE / ('native-' + name); raw = path.read_bytes()
|
|
item = next(item for item in receipt['files'] if item['name'] == name)
|
|
require(sha(path) == item['sha256'] == digest and len(raw) == item['bytes']
|
|
and base64.b64decode(item['base64'], validate=True) == raw, 'same actual unchanged Microsoft output')
|
|
write(source / name, raw); generated[name] = digest
|
|
wrapper = ROOT / 'crates/agent-windows/native/clock_rpc.c'
|
|
write(source / 'clock_rpc.c', wrapper.read_bytes()); write(source / 'system_trace.c', (HERE / 'system_trace.c').read_bytes())
|
|
save(folder / 'intent.json', dict(image=IMAGE, original131=baseline['source_files'], baseline_sha256=BASELINE_SHA,
|
|
actual_codegen_readback_sha256=READBACK_SHA, generated=generated, own_sources=before,
|
|
wrapper_sha256=sha(wrapper), own_system_token_only=True, exactly_one_trace_call=True, no_vm=True))
|
|
output = folder / 'output'; output.mkdir(mode=0o700)
|
|
checks = {}
|
|
def run(name, args):
|
|
command = ['docker','run','--rm','--network','none','--read-only','--tmpfs','/tmp:rw,size=128m',
|
|
'-v',str(source)+':/src:ro','-v',str(output)+':/out','--entrypoint',args[0],IMAGE,*args[1:]]
|
|
done = subprocess.run(command,capture_output=True,timeout=120)
|
|
write(folder / (name+'.stdout'),done.stdout); write(folder / (name+'.stderr'),done.stderr)
|
|
checks[name] = dict(exit_code=done.returncode,command=command,stdout_sha256=sha(folder / (name+'.stdout')),stderr_sha256=sha(folder / (name+'.stderr')))
|
|
save(folder / (name+'.json'),checks[name]); require(done.returncode == 0,'local diagnostic compile/check failure: '+name)
|
|
return done.stdout
|
|
flags = ['--target=x86_64-w64-windows-gnu','-fms-extensions','-Wall','-Wextra','-Werror','-D_M_AMD64=100','-I/src','-O2']
|
|
run('main',['clang',*flags,'-c','/src/system_trace.c','-o','/out/system_trace.o'])
|
|
run('wrapper',['clang',*flags,'-c','/src/clock_rpc.c','-o','/out/clock_rpc.o'])
|
|
run('actual-midl',['clang',*flags,'-Wno-error=missing-braces','-Wno-error=unused-const-variable','-c','/src/w32time_c.c','-o','/out/w32time_c.o'])
|
|
run('link',['x86_64-w64-mingw32-gcc','-static-libgcc','-municode','/out/system_trace.o','/out/clock_rpc.o','/out/w32time_c.o',
|
|
'-lrpcrt4','-ladvapi32','-lkernel32','-lmincore','-o','/out/ClockSystemTrace.linked.exe'])
|
|
raw_linked = output / 'ClockSystemTrace.linked.exe'
|
|
linked = output / 'ClockSystemTrace.original.exe'; delivery = output / 'ClockSystemTrace.exe'
|
|
# Retain a caller-owned private exact copy; Docker's root-owned raw link is
|
|
# kept too. No chmod/chown of unrelated objects or source mutation.
|
|
shutil.copyfile(raw_linked,linked); linked.chmod(0o600)
|
|
shutil.copyfile(linked,delivery); delivery.chmod(0o600)
|
|
run('strip',['x86_64-w64-mingw32-strip','--strip-debug','/out/ClockSystemTrace.exe'])
|
|
imports = sorted(set(re.findall(r'DLL Name:\s+(\S+)',run('imports',['x86_64-w64-mingw32-objdump','-p','/out/ClockSystemTrace.exe']).decode())))
|
|
require(imports and {name.lower() for name in imports}.issubset({'kernel32.dll','msvcrt.dll','advapi32.dll','rpcrt4.dll','api-ms-win-core-realtime-l1-1-2.dll'}),'reviewed system DLL imports only')
|
|
data = delivery.read_bytes(); offset = int.from_bytes(data[60:64],'little')
|
|
require(data[:2] == b'MZ' and data[offset:offset+6] == b'PE\0\0\x64\x86' and len(data) < 1048576,'bounded standalone C x64 PE')
|
|
spec = importlib.util.spec_from_file_location('system_trace_native',HERE / 'native.py'); native = importlib.util.module_from_spec(spec); spec.loader.exec_module(native)
|
|
script = folder / 'native.ps1'; write(script,native.SCRIPT.encode())
|
|
parser = "$e=$null;$t=$null;[System.Management.Automation.Language.Parser]::ParseFile($args[0],[ref]$t,[ref]$e)|Out-Null;if($e.Count){$e|ForEach-Object{$_.Message};exit 1};'AST_PASS'"
|
|
parser_path = folder / 'parse-native.ps1'; write(parser_path,parser.encode())
|
|
parsed = subprocess.run(['/tmp/rmm-powershell-parser/pwsh','-NoLogo','-NoProfile','-NonInteractive','-File',str(parser_path),str(script)],capture_output=True,timeout=15)
|
|
write(folder / 'powershell-parser.stdout',parsed.stdout); write(folder / 'powershell-parser.stderr',parsed.stderr)
|
|
require(parsed.returncode == 0 and b'AST_PASS' in parsed.stdout and not parsed.stderr,'actual PowerShell AST')
|
|
command_chars = len(native.encoded_command())
|
|
require(command_chars < 32767,'Windows encoded command length')
|
|
require(original_sources()['source_files'] == baseline['source_files'] and own_sources() == before,'all original131 and new sources unchanged')
|
|
manifest = dict(schema_version=1,profile='clock-system-trace-v1',image=IMAGE,baseline_sha256=BASELINE_SHA,
|
|
original131=baseline['source_files'],own_sources=before,wrapper_sha256=sha(wrapper),generated=generated,
|
|
actual_codegen_readback_sha256=READBACK_SHA,checks=checks,script_sha256=hashlib.sha256(native.SCRIPT.encode()).hexdigest(),
|
|
powershell_ast_passed=True,encoded_command_characters=command_chars,
|
|
artifact=dict(path=str(delivery),sha256=sha(delivery),bytes=len(data),imports=imports),
|
|
linked=dict(path=str(linked),sha256=sha(linked)),raw_linked_sha256=sha(raw_linked),native_executed=False,clock_qualified=False,
|
|
adapter_qualified=False,product_gate_open=False,no_vm=True,no_rmm_jobs=True)
|
|
save(folder / 'manifest.json',manifest)
|
|
print(json.dumps(dict(manifest=str(folder / 'manifest.json'),manifest_sha256=sha(folder / 'manifest.json'),artifact=manifest['artifact'],
|
|
original131_unchanged=True,powershell_ast=True,command_characters=command_chars,native_executed=False)))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
try: main()
|
|
except Exception as error:
|
|
print(json.dumps(dict(error='CLOCK_SYSTEM_TRACE_LOCAL_INCOMPLETE',error_class=type(error).__name__,details_suppressed=True)))
|
|
raise SystemExit(2) from None
|