amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
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>
2026-10-27 01:55:56 +08:00

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())