One user-space repair task per eligible HWE debug-diag / compile-deploy base ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content filter. Each ships a public spec with a check-to-basis table, at least two defects with single-fix fixtures, a symptom-masking fixture and an alternative correct implementation. Claude re-checked all 320: structure, the HWE quality items and trace6 Docker calibration receipts against current digests (320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120 ad-hoc family names; the next batch maps them to the canonical list. The batch's 1,256-line progress log stays in its factory report and the 36-local branch batch15-hwe. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
351 lines
18 KiB
Python
351 lines
18 KiB
Python
"""Independent GPIO model; untrusted compiler/program live only in child supervisors."""
|
|
import base64
|
|
import hashlib
|
|
import json
|
|
import math
|
|
import os
|
|
from pathlib import Path
|
|
import random
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
import uuid
|
|
import zlib
|
|
|
|
DEADLINES = {"compiler": 20, "candidate": 8, "cleanup": 5, "absence": 3}
|
|
REAP_ALLOWANCE = 4
|
|
SUPERVISOR = r"""
|
|
import base64, ctypes, hashlib, json, os, signal, subprocess, sys, time
|
|
config=json.loads(sys.argv[1])
|
|
started=time.monotonic()
|
|
errors=[]
|
|
tracked={}
|
|
reaped=[]
|
|
def table():
|
|
result={}
|
|
for entry in os.listdir('/proc'):
|
|
if not entry.isdigit(): continue
|
|
try:
|
|
raw=open('/proc/'+entry+'/stat').read()
|
|
tail=raw[raw.rfind(')')+2:].split()
|
|
result[int(entry)]=(int(tail[19]),int(tail[1]),tail[0])
|
|
except (FileNotFoundError, ProcessLookupError): pass
|
|
except PermissionError: pass
|
|
except Exception as e: errors.append('proc:'+type(e).__name__+':'+str(e))
|
|
return result
|
|
def discover(rows, supervisor, old):
|
|
# Only a current live token can anchor an old lineage. Z/X are exited roots.
|
|
roots={supervisor}
|
|
roots.update(pid for pid,start in old.items()
|
|
if pid in rows and rows[pid][0]==start and rows[pid][2] not in ('Z','X'))
|
|
closure=set(roots)
|
|
changed=True
|
|
while changed:
|
|
changed=False
|
|
for pid,(_,parent,_) in rows.items():
|
|
if parent in closure and pid not in closure:
|
|
closure.add(pid); changed=True
|
|
closure.discard(supervisor)
|
|
return {pid:rows[pid][0] for pid in closure if pid in rows}
|
|
def identity(pid):
|
|
info={}
|
|
for line in open('/proc/'+str(pid)+'/status'):
|
|
key,_,value=line.partition(':')
|
|
if key in ('Uid','Gid','Groups'): info[key]=list(map(int,value.split()))
|
|
return info
|
|
meta=dict(stage=config['stage'],nonce=config['nonce'],deadline=config['deadline'],
|
|
supervisor_pid=os.getpid(),uid=os.getuid(),gid=os.getgid(),groups=os.getgroups(),
|
|
leader_pid=None,leader_start=None,leader_identity=None,leader_rc=None,
|
|
controlled_rc=None,timed_out=False,leader_reaped=False,descendants_absent=False,
|
|
remaining=[],reaped=[],errors=errors,stdout_len=0,stderr_len=0,
|
|
stdout_sha256=hashlib.sha256(b'').hexdigest(),stderr_sha256=hashlib.sha256(b'').hexdigest())
|
|
p=None
|
|
stdout=stderr=b''
|
|
try:
|
|
libc=ctypes.CDLL(None,use_errno=True)
|
|
if libc.prctl(36,1,0,0,0)!=0:
|
|
raise OSError(ctypes.get_errno(),'PR_SET_CHILD_SUBREAPER')
|
|
p=subprocess.Popen(config['argv'],cwd=config['cwd'],stdin=subprocess.PIPE,
|
|
stdout=subprocess.PIPE,stderr=subprocess.PIPE,start_new_session=True)
|
|
meta['leader_pid']=p.pid
|
|
rows=table()
|
|
if p.pid not in rows: raise RuntimeError('leader start unavailable')
|
|
meta['leader_start']=rows[p.pid][0]
|
|
meta['leader_identity']=identity(p.pid)
|
|
tracked[p.pid]=rows[p.pid][0]
|
|
first=True
|
|
while True:
|
|
rows=table(); tracked.update(discover(rows,os.getpid(),tracked))
|
|
left=config['deadline']-(time.monotonic()-started)
|
|
if left<=0:
|
|
meta['timed_out']=True
|
|
break
|
|
try:
|
|
stdout,stderr=p.communicate(base64.b64decode(config['stdin']) if first else None,
|
|
timeout=min(0.04,left))
|
|
break
|
|
except subprocess.TimeoutExpired:
|
|
first=False
|
|
# Poll the own Popen before waitpid(-1), so adopted reaping cannot steal its rc.
|
|
p.poll()
|
|
except BaseException as e:
|
|
errors.append('execute:'+type(e).__name__+':'+str(e))
|
|
finally:
|
|
if p is not None:
|
|
end=time.monotonic()+3
|
|
while True:
|
|
try:
|
|
p.poll()
|
|
rows=table()
|
|
tracked.update(discover(rows,os.getpid(),tracked))
|
|
live={pid:start for pid,start in tracked.items()
|
|
if pid in rows and rows[pid][0]==start}
|
|
for pid,start in live.items():
|
|
now=table().get(pid)
|
|
if now and now[0]==start and now[2] not in ('Z','X'):
|
|
try: os.kill(pid,signal.SIGKILL)
|
|
except ProcessLookupError: pass
|
|
except BaseException as e: errors.append('kill:'+type(e).__name__+':'+str(e))
|
|
p.poll()
|
|
if p.returncode is not None:
|
|
while True:
|
|
try:
|
|
got,status=os.waitpid(-1,os.WNOHANG)
|
|
if got==0: break
|
|
reaped.append([got,status])
|
|
except ChildProcessError: break
|
|
rows=table()
|
|
tracked.update(discover(rows,os.getpid(),tracked))
|
|
remaining=[[pid,start,rows[pid][2]] for pid,start in tracked.items()
|
|
if pid in rows and rows[pid][0]==start]
|
|
if not remaining or time.monotonic()>=end: break
|
|
time.sleep(0.01)
|
|
except BaseException as e:
|
|
errors.append('reclaim:'+type(e).__name__+':'+str(e)); break
|
|
try:
|
|
stdout,stderr=p.communicate(timeout=0.4)
|
|
except BaseException as e:
|
|
errors.append('pipe:'+type(e).__name__+':'+str(e))
|
|
meta['leader_rc']=p.poll()
|
|
meta['leader_reaped']=p.returncode is not None
|
|
rows=table()
|
|
tracked.update(discover(rows,os.getpid(),tracked))
|
|
meta['remaining']=[[pid,start,rows[pid][2]] for pid,start in tracked.items()
|
|
if pid in rows and rows[pid][0]==start]
|
|
meta['descendants_absent']=not meta['remaining']
|
|
meta['controlled_rc']=124 if meta['timed_out'] else meta['leader_rc']
|
|
meta['reaped']=reaped
|
|
meta['elapsed']=time.monotonic()-started
|
|
meta['stdout_len']=len(stdout);meta['stderr_len']=len(stderr)
|
|
meta['stdout_sha256']=hashlib.sha256(stdout).hexdigest()
|
|
meta['stderr_sha256']=hashlib.sha256(stderr).hexdigest()
|
|
print(json.dumps(dict(meta=meta,stdout=base64.b64encode(stdout).decode(),
|
|
stderr=base64.b64encode(stderr).decode()),separators=(',',':')))
|
|
"""
|
|
|
|
|
|
def sha(raw):
|
|
return hashlib.sha256(raw).hexdigest()
|
|
|
|
|
|
def strict_metadata(meta, stage, nonce, stdout, stderr):
|
|
required = {'stage', 'nonce', 'deadline', 'supervisor_pid', 'uid', 'gid', 'groups',
|
|
'leader_pid', 'leader_start', 'leader_identity', 'leader_rc',
|
|
'controlled_rc', 'timed_out', 'leader_reaped', 'descendants_absent',
|
|
'remaining', 'reaped', 'errors', 'stdout_len', 'stderr_len',
|
|
'stdout_sha256', 'stderr_sha256', 'elapsed'}
|
|
if not isinstance(meta, dict) or set(meta) != required:
|
|
raise ValueError('metadata fields')
|
|
if meta['stage'] != stage or meta['nonce'] != nonce:
|
|
raise ValueError('metadata binding')
|
|
expected_uid = 65534 if os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534' else os.getuid()
|
|
expected_gid = 65534 if os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534' else os.getgid()
|
|
expected_groups = [] if expected_uid == 65534 else os.getgroups()
|
|
for key in ('supervisor_pid', 'leader_pid', 'leader_start'):
|
|
if type(meta[key]) is not int or meta[key] <= 0:
|
|
raise ValueError('metadata positive integer '+key)
|
|
if meta['supervisor_pid'] == meta['leader_pid']:
|
|
raise ValueError('metadata process identities')
|
|
if type(meta['uid']) is not int or type(meta['gid']) is not int:
|
|
raise ValueError('metadata identity types')
|
|
if meta['uid'] != expected_uid or meta['gid'] != expected_gid or meta['groups'] != expected_groups:
|
|
raise ValueError('metadata identity')
|
|
if not isinstance(meta['groups'], list) or any(type(x) is not int for x in meta['groups']):
|
|
raise ValueError('metadata group types')
|
|
ident = meta['leader_identity']
|
|
if not isinstance(ident, dict) or set(ident) != {'Uid', 'Gid', 'Groups'}:
|
|
raise ValueError('metadata leader identity fields')
|
|
for key, wanted in (('Uid', [expected_uid]*4), ('Gid', [expected_gid]*4), ('Groups', expected_groups)):
|
|
if not isinstance(ident[key], list) or any(type(x) is not int for x in ident[key]) or ident[key] != wanted:
|
|
raise ValueError('metadata leader identity')
|
|
if type(meta['deadline']) is not int or meta['deadline'] != DEADLINES[stage]:
|
|
raise ValueError('metadata deadline')
|
|
elapsed = meta['elapsed']
|
|
if type(elapsed) not in (int, float) or not math.isfinite(elapsed) or not 0 <= elapsed <= DEADLINES[stage]+REAP_ALLOWANCE:
|
|
raise ValueError('metadata elapsed')
|
|
for key in ('timed_out', 'leader_reaped', 'descendants_absent'):
|
|
if type(meta[key]) is not bool:
|
|
raise ValueError('metadata bool '+key)
|
|
for key in ('leader_rc', 'controlled_rc'):
|
|
if type(meta[key]) is not int:
|
|
raise ValueError('metadata return code')
|
|
if meta['controlled_rc'] != (124 if meta['timed_out'] else meta['leader_rc']):
|
|
raise ValueError('metadata controlled return')
|
|
if meta['timed_out'] and meta['leader_rc'] == 0:
|
|
# A normal leader can exit while a pipe-holding descendant forces the deadline.
|
|
pass
|
|
if not isinstance(meta['errors'], list) or any(not isinstance(x, str) for x in meta['errors']):
|
|
raise ValueError('metadata exceptions')
|
|
if not isinstance(meta['remaining'], list) or not isinstance(meta['reaped'], list):
|
|
raise ValueError('metadata process lists')
|
|
for item in meta['remaining']:
|
|
if not isinstance(item, list) or len(item) != 3 or any(type(x) is not int or x <= 0 for x in item[:2]) or not isinstance(item[2], str):
|
|
raise ValueError('metadata remaining tokens')
|
|
for item in meta['reaped']:
|
|
if not isinstance(item, list) or len(item) != 2 or type(item[0]) is not int or item[0] <= 0 or type(item[1]) is not int:
|
|
raise ValueError('metadata reap facts')
|
|
if meta['descendants_absent'] != (not meta['remaining']):
|
|
raise ValueError('metadata absence consistency')
|
|
for label, raw in (('stdout', stdout), ('stderr', stderr)):
|
|
if type(meta[label+'_len']) is not int or meta[label+'_len'] < 0 or meta[label+'_len'] != len(raw) or meta[label+'_sha256'] != sha(raw):
|
|
raise ValueError('metadata IO '+label)
|
|
if meta['errors'] or not meta['leader_reaped'] or not meta['descendants_absent']:
|
|
raise ValueError('stage exceptions/reap/absence')
|
|
if meta['timed_out'] or meta['leader_rc'] != 0 or meta['controlled_rc'] != 0:
|
|
raise ValueError('stage controlled exit '+str(meta['controlled_rc']))
|
|
|
|
|
|
def stage_run(stage, argv, cwd, stdin, evidence):
|
|
nonce = uuid.uuid4().hex
|
|
config = dict(stage=stage, nonce=nonce, deadline=DEADLINES[stage], argv=argv,
|
|
cwd=str(cwd) if cwd is not None else None, stdin=base64.b64encode(stdin).decode())
|
|
wrapper_argv = [sys.executable, '-I', '-c', SUPERVISOR, json.dumps(config, separators=(',', ':'))]
|
|
fact = dict(stage=stage, argv=argv, cwd=config['cwd'], nonce=nonce,
|
|
stdin_len=len(stdin), stdin_sha256=sha(stdin),
|
|
wrapper_argv_sha256=sha(json.dumps(wrapper_argv).encode()))
|
|
evidence.append(fact)
|
|
wrapper = subprocess.run(wrapper_argv, capture_output=True, timeout=DEADLINES[stage]+REAP_ALLOWANCE+2)
|
|
# Bind actual returned wire bytes before any parse, even for malformed wires.
|
|
fact.update(wrapper_rc=wrapper.returncode, wire_len=len(wrapper.stdout), wire_sha256=sha(wrapper.stdout),
|
|
wrapper_stderr_len=len(wrapper.stderr), wrapper_stderr_sha256=sha(wrapper.stderr))
|
|
if wrapper.returncode != 0:
|
|
raise ValueError('supervisor nonzero '+str(wrapper.returncode))
|
|
wire = json.loads(wrapper.stdout)
|
|
if not isinstance(wire, dict) or set(wire) != {'meta', 'stdout', 'stderr'}:
|
|
raise ValueError('wire fields')
|
|
stdout = base64.b64decode(wire['stdout'], validate=True)
|
|
stderr = base64.b64decode(wire['stderr'], validate=True)
|
|
fact['meta'] = wire['meta']
|
|
if isinstance(wire['meta'], dict) and wire['meta'].get('leader_rc') != 0:
|
|
fact['stderr_failure_tail'] = stderr[-512:].decode('utf-8', 'replace')
|
|
strict_metadata(wire['meta'], stage, nonce, stdout, stderr)
|
|
return stdout
|
|
|
|
|
|
def cases():
|
|
rng = random.Random(830241)
|
|
rows = [[0,1,0,6,6,100,0,1,1,0,1,0], [0,1,0,6,6,200,1,0,1,0,0,1],
|
|
[1,2,0,5,5,500,1,0,1,0,1], [1,3,0,6,3,900,0,1,0,1,0,1],
|
|
[1,1,3,2,2,1200,1,0], [1,3,0,4,4,1500,1,0,1,0]]
|
|
for fault in range(1,5):
|
|
rows.extend([[2,3,fault,4,4,10000,1,0,1,0], [2,3,0,4,4,10010,0,1,0,1]])
|
|
for edge in range(1,4):
|
|
for stop in (0,1,31,32):
|
|
rows.append([3,edge,0,32,stop,4294967280]+[i%2 for i in range(32)])
|
|
rows += [[-1,1,0,0,0,0],[15,1,0,0,0,0],[0,0,0,0,0,0],
|
|
[0,4,0,0,0,0],[0,1,0,-1,0,0],[0,1,0,33,0,0],
|
|
[0,1,0,0,1,0],[0,1,0,1,-1,0,0],[0,1,0,2,0,0,0,2]]
|
|
for index in range(180):
|
|
count = rng.choice([0,1,2,7,16,31,32])
|
|
rows.append([rng.randrange(15),rng.randrange(1,4),rng.choice([0,0,0,0,1,2,3,4]),
|
|
count,rng.randrange(count+1),rng.randrange(2**32)]+[rng.randrange(2) for _ in range(count)])
|
|
return 23153, rows
|
|
|
|
|
|
def expected(seed, rows):
|
|
levels = [(seed >> i) & 1 for i in range(16)]
|
|
output = []
|
|
for row, request in enumerate(rows, 1):
|
|
pin,edge,fault,count,stop,tick,*samples = request
|
|
valid = 0 <= pin < 15 and 1 <= edge <= 3 and 0 <= count <= 32 and 0 <= stop <= count and all(x in (0,1) for x in samples)
|
|
status,consumed,initial,final,events = -2,0,-1,-1,[]
|
|
if valid and fault:
|
|
status = -1
|
|
elif valid:
|
|
initial = levels[pin]
|
|
status = 0 if stop == count else 1
|
|
for i, level in enumerate(samples[:stop]):
|
|
previous = levels[pin]
|
|
levels[pin] = level
|
|
if previous != level and (edge == 3 or edge == 1 and level == 1 or edge == 2 and level == 0):
|
|
events.append([len(events)+1,(tick+i) % (2**32),level])
|
|
consumed,final = stop,levels[pin]
|
|
bitmask = sum(x << i for i,x in enumerate(levels))
|
|
fields = [row,status,status,consumed,initial,final,len(events)]
|
|
fields += [x for event in events for x in event]
|
|
output.append('R '+' '.join(map(str,fields))+' | '+' '.join(map(str,[1,1,1,0,bitmask,32768,32768,32768,32768])))
|
|
return output
|
|
|
|
|
|
def main():
|
|
evidence = []
|
|
failure = None
|
|
scratch = None
|
|
observed_count = 0
|
|
try:
|
|
context = json.loads(Path(__file__).with_name('context.json').read_text())
|
|
seed, rows = cases()
|
|
answers = expected(seed, rows)
|
|
data = (str(seed)+'\n'+''.join(' '.join(map(str,row))+'\n' for row in rows)).encode()
|
|
source = (Path(sys.argv[1])/'src/registration.c').read_bytes()
|
|
scratch = Path(tempfile.mkdtemp(prefix='dev-edge-registration-'))
|
|
# All public materials and inputs are prepared before the first child.
|
|
for name,text in context.items():
|
|
dest = scratch/name
|
|
dest.parent.mkdir(parents=True, exist_ok=True)
|
|
dest.write_text(text)
|
|
(scratch/'src/registration.c').write_bytes(source)
|
|
for directory in (scratch/'src',scratch/'include',scratch/'docs',scratch/'examples'):
|
|
os.chmod(directory, 0o777)
|
|
evidence.append(dict(kind='binding',scratch=str(scratch),candidate_sha256=sha(source),
|
|
context_sha256=sha(Path(__file__).with_name('context.json').read_bytes()),
|
|
input_len=len(data),input_sha256=sha(data),rows=len(rows)))
|
|
stage_run('compiler',['gcc','-std=c11','-O2','-Wall','-Wextra','-Werror','-Iinclude',
|
|
'src/backend.c','src/registration.c','src/demo.c','-o','edge-demo'],scratch,b'',evidence)
|
|
output = stage_run('candidate',[str(scratch/'edge-demo')],scratch,data,evidence)
|
|
actual = output.decode('ascii').splitlines()
|
|
observed_count = len(actual)
|
|
for index in range(max(len(actual),len(answers))):
|
|
got = actual[index] if index < len(actual) else '<missing>'
|
|
wanted = answers[index] if index < len(answers) else '<extra>'
|
|
if got != wanted:
|
|
raise ValueError('raw observation '+str(index+1)+' got '+got[:240]+' expected '+wanted[:240])
|
|
except BaseException as error:
|
|
failure = type(error).__name__+':'+str(error)
|
|
finally:
|
|
if scratch is not None:
|
|
try:
|
|
stage_run('cleanup',[sys.executable,'-I','-c',
|
|
'import shutil,sys\ntry: shutil.rmtree(sys.argv[1])\nexcept FileNotFoundError: pass\n',str(scratch)],None,b'',evidence)
|
|
except BaseException as error:
|
|
failure = (failure+'; ' if failure else '')+'cleanup:'+type(error).__name__+':'+str(error)
|
|
try:
|
|
stage_run('absence',[sys.executable,'-I','-c',
|
|
'import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: raise SystemExit(0)\nraise SystemExit(1)\n',str(scratch)],None,b'',evidence)
|
|
except BaseException as error:
|
|
failure = (failure+'; ' if failure else '')+'absence:'+type(error).__name__+':'+str(error)
|
|
# Compressed metadata survives bos_verify's 4000-character stderr tail. Inner
|
|
# stdout/stderr and wire bytes are represented only by actual length+SHA.
|
|
record = dict(stages=evidence,failure=failure,observed_rows=observed_count,
|
|
supervisor_sha256=sha(SUPERVISOR.encode()))
|
|
encoded = base64.b64encode(zlib.compress(json.dumps(record,separators=(',',':')).encode(),9)).decode()
|
|
print('EVIDENCE '+encoded,file=sys.stderr)
|
|
if failure is not None:
|
|
print('FAIL '+failure[:280]);return 1
|
|
print('PASS');return 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
raise SystemExit(main())
|