340 lines
17 KiB
Python
340 lines
17 KiB
Python
import errno
|
||
import json
|
||
from pathlib import Path
|
||
import random
|
||
import subprocess
|
||
import sys
|
||
import tempfile
|
||
|
||
class Model:
|
||
def __init__(self, kind):
|
||
self.kind=kind; self.selected=0; self.total=0
|
||
self.client=[[0]*8 for _ in range(4)]
|
||
self.device=[[0]*8 for _ in range(4)]
|
||
self.storage=[[(i*17+b*29)&255 for i in range(256)] for b in range(4)]
|
||
self.faults=[[0,0] for _ in range(8)]
|
||
if kind in ('ioctl','sysfs'):
|
||
for c,d in zip(self.client,self.device): c[0]=d[0]=100 if kind=='ioctl' else -1
|
||
def call(self,op,a=0,b=0,data=None,n=0):
|
||
result=0; f=self.faults[op-1]
|
||
if f[1]: f[1]-=1; result=-f[0]
|
||
d=self.device[self.selected]; s=self.storage[self.selected]
|
||
if data is None: data=[]
|
||
if not result:
|
||
if self.kind=='gpio':
|
||
if op==1:
|
||
if d[0]: result=-errno.EBUSY
|
||
else: d[0]=1; d[1]=a
|
||
elif op==5: d[0]=0
|
||
elif not d[0]: result=-errno.ENODEV
|
||
elif op==2: d[2]=a
|
||
elif op==3:
|
||
if d[2]!=1 or n!=1 or data[0] not in (48,49): result=-errno.EINVAL
|
||
else: d[3]=data[0]-48
|
||
elif op==4: data=[48+d[3]]
|
||
elif self.kind=='i2c':
|
||
if op==1: d[0]=a; d[1]=b
|
||
elif op==2:
|
||
if b!=2: result=-errno.EPROTO
|
||
else: data=[s[a+i]^(d[0]&255) for i in range(n)]; d[2]+=1; d[4]=a
|
||
elif op==3: s[a:a+n]=data[:n]; d[3]+=1; d[4]=a
|
||
elif self.kind=='spi':
|
||
if op==1: d[2]=1
|
||
elif op==2:
|
||
if not d[2]: result=-errno.EACCES
|
||
elif n>16 or a//16!=(a+n-1)//16: result=-errno.EINVAL
|
||
else:
|
||
for i in range(n): s[a+i]&=data[i]
|
||
d[2]=0; d[3]+=1
|
||
elif op==3: data=[3,0,0,a]+s[a:a+n]; d[4]+=1
|
||
elif op==4:
|
||
if not d[2]: result=-errno.EACCES
|
||
else: s[a:a+32]=[255]*32; d[2]=0; d[5]+=1
|
||
elif op==5: d[0]=a; d[1]=b
|
||
elif self.kind=='ioctl':
|
||
if op==1: data=list(d[0].to_bytes(4,'little',signed=True))+list(d[1].to_bytes(4,'little',signed=True)); d[2]+=1
|
||
elif op==2: d[0]=a; d[1]=b; d[3]+=1
|
||
elif op==3: d[0]=100; d[1]=0; d[4]+=1
|
||
elif self.kind=='sysfs':
|
||
if op==1: d[0]=a; d[1]+=1
|
||
elif op==2: data=list(d[0].to_bytes(4,'little',signed=True)); d[2]+=1
|
||
self.trace.append('T %s %d %d %d' % ({'gpio':'SYSFS','i2c':'I2C','spi':'SPI','ioctl':'IOCTL','sysfs':'ATTR'}[self.kind],op,a,result))
|
||
self.total+=1
|
||
return result,data
|
||
def invoke(self,*args,**kwargs):
|
||
while True:
|
||
result,data=self.call(*args,**kwargs)
|
||
if result!=-errno.EINTR: return result,data
|
||
def apply(self,name,args):
|
||
c=self.client[self.selected]; data=[]; result=0
|
||
if name=='A' and len(args)==1 and 0<=args[0]<4: self.selected=args[0]
|
||
elif name=='F' and len(args)==3 and 0<=args[0]<8 and min(args[1:])>=0: self.faults[args[0]]=args[1:]
|
||
elif name=='Z':
|
||
if len(args)!=3 or not 0<=args[0]<8: result=-errno.EINVAL
|
||
else:
|
||
self.device[self.selected][args[0]]=args[1]
|
||
if args[2]>=0: self.storage[self.selected]=[(i*17+args[2])&255 for i in range(256)]
|
||
elif name in ('Q','P'):
|
||
if len(args)!=2: result=-errno.EINVAL
|
||
else:
|
||
start,arg=args; count=1 if name=='Q' else arg; width=arg if name=='Q' else 4
|
||
if width not in (1,2,4) or start<0 or count<0 or start>8 or count>8-start: result=-errno.EINVAL
|
||
else:
|
||
data=[byte for value in c[start:start+count] for byte in (value&0xffffffff).to_bytes(4,'little')[:width]]
|
||
else:
|
||
result,data=getattr(self,'apply_'+self.kind)(c,name,args)
|
||
return result,data
|
||
def apply_gpio(self,c,name,v):
|
||
r=0; out=[]
|
||
if name=='O' and len(v)==2:
|
||
p,d=v
|
||
if c[0]: r=-errno.EALREADY
|
||
elif p<0 or p>255 or d not in (0,1): r=-errno.EINVAL
|
||
else:
|
||
r,_=self.invoke(1,p)
|
||
if r in (0,-errno.EBUSY):
|
||
owned=int(r==0); r,_=self.invoke(2,d)
|
||
if r:
|
||
if owned: self.invoke(5,p)
|
||
else: c[:4]=[1,owned,p,d]
|
||
elif name=='D' and len(v)==1:
|
||
if not c[0]: r=-errno.ENODEV
|
||
elif v[0] not in (0,1): r=-errno.EINVAL
|
||
else:
|
||
r,_=self.invoke(2,v[0])
|
||
if not r: c[3]=v[0]
|
||
elif name=='W' and len(v)==1:
|
||
if not c[0]: r=-errno.ENODEV
|
||
elif c[3]!=1: r=-errno.EPERM
|
||
elif v[0] not in (0,1): r=-errno.EINVAL
|
||
else:
|
||
r,_=self.invoke(3,v[0],data=[48+v[0]],n=1)
|
||
if not r: c[4]+=1; c[6]=v[0]
|
||
elif name=='R' and not v:
|
||
if not c[0]: r=-errno.ENODEV
|
||
else:
|
||
r,out=self.invoke(4,n=1)
|
||
if not r: c[5]+=1; c[6]=out[0]-48
|
||
else: out=[]
|
||
elif name=='X' and not v:
|
||
if c[0]:
|
||
if c[1]: r,_=self.invoke(5,c[2])
|
||
if not r: c[0]=c[1]=0; c[7]+=1
|
||
else: r=-errno.EINVAL
|
||
return r,out
|
||
def apply_i2c(self,c,name,v):
|
||
r=0; out=[]
|
||
if name in ('O','C') and len(v)==2:
|
||
a,t=v
|
||
if name=='O' and c[0]: r=-errno.EALREADY
|
||
elif name=='C' and not c[0]: r=-errno.ENODEV
|
||
elif t not in (0,1) or not 0<=a<=(1023 if t else 127): r=-errno.EINVAL
|
||
else:
|
||
r,_=self.invoke(1,a,t)
|
||
if not r:
|
||
c[0]=1; c[1]=a; c[2]=t
|
||
if name=='C': c[7]+=1
|
||
elif name=='R' and len(v)==2:
|
||
a,n=v
|
||
if not c[0]: r=-errno.ENODEV
|
||
elif a<0 or not 1<=n<=32 or a+n>256: r=-errno.EINVAL
|
||
else:
|
||
r,out=self.invoke(2,a,2,n=n)
|
||
if not r: c[3]+=1; c[5]+=n
|
||
else: out=[]
|
||
elif name=='W':
|
||
if not c[0]: r=-errno.ENODEV
|
||
elif len(v)<2: r=-errno.EINVAL
|
||
else:
|
||
a,n=v[:2]
|
||
if a<0 or not 1<=n<=32 or a+n>256 or len(v)!=n+2 or any(not 0<=x<=255 for x in v[2:]): r=-errno.EINVAL
|
||
else:
|
||
r,_=self.invoke(3,a,data=v[2:],n=n)
|
||
if not r: c[4]+=1; c[6]+=n
|
||
elif name=='X' and not v: c[0]=0
|
||
else: r=-errno.EINVAL
|
||
return r,out
|
||
def apply_spi(self,c,name,v):
|
||
r=0; out=[]
|
||
if name=='O' and len(v)==2:
|
||
m,s=v
|
||
if not 0<=m<=3 or not 1<=s<=1000000: r=-errno.EINVAL
|
||
else:
|
||
r,_=self.invoke(5,m,s)
|
||
if not r: c[:3]=[1,m,s]
|
||
elif name=='X' and not v: c[0]=0
|
||
elif name in ('W','R','E'):
|
||
if not c[0]: r=-errno.ENODEV
|
||
elif name=='W':
|
||
if len(v)<2: return -errno.EINVAL,[]
|
||
a,n=v[:2]
|
||
if a<0 or not 1<=n<=32 or a+n>256 or len(v)!=n+2 or any(not 0<=x<=255 for x in v[2:]): r=-errno.EINVAL
|
||
else:
|
||
pos=0
|
||
while pos<n:
|
||
k=min(n-pos,16-(a+pos)%16)
|
||
r,_=self.invoke(1)
|
||
if r: break
|
||
r,_=self.invoke(2,a+pos,data=v[2+pos:2+pos+k],n=k)
|
||
if r: break
|
||
c[4]+=1; c[6]+=k; pos+=k
|
||
elif name=='R' and len(v)==2:
|
||
a,n=v
|
||
if a<0 or not 1<=n<=32 or a+n>256: r=-errno.EINVAL
|
||
else:
|
||
r,buf=self.invoke(3,a,n=n)
|
||
if not r: out=buf[4:]; c[3]+=1; c[7]+=n
|
||
elif name=='E' and len(v)==1:
|
||
a=v[0]
|
||
if a<0 or a>224 or a%32: r=-errno.EINVAL
|
||
else:
|
||
r,_=self.invoke(1)
|
||
if not r:
|
||
r,_=self.invoke(4,a)
|
||
if not r: c[5]+=1
|
||
else: r=-errno.EINVAL
|
||
else: r=-errno.EINVAL
|
||
return r,out
|
||
def apply_ioctl(self,c,name,v):
|
||
r=0; out=[]
|
||
if name!='I': return -errno.EINVAL,[]
|
||
if len(v)!=6: r=-errno.EINVAL
|
||
else:
|
||
m,n,d,s,a,b=v
|
||
if m!=80 or (n,d,s) not in ((1,2,8),(2,1,8),(3,0,0)): r=-errno.ENOTTY
|
||
elif n==1:
|
||
r,out=self.invoke(1)
|
||
if not r: c[2]+=1
|
||
else: out=[]
|
||
elif n==2:
|
||
if not 1<=a<=1000 or not 0<=b<=3: r=-errno.EINVAL
|
||
else:
|
||
r,_=self.invoke(2,a,b)
|
||
if not r: c[0]=a; c[1]=b; c[3]+=1; c[6]+=1
|
||
else:
|
||
r,_=self.invoke(3)
|
||
if not r: c[0]=100; c[1]=0; c[4]+=1; c[6]+=1
|
||
if r: c[5]+=1
|
||
return r,out
|
||
def apply_sysfs(self,c,name,v):
|
||
r=0; out=[]
|
||
if name=='W':
|
||
if not v: return -errno.EINVAL,[]
|
||
n=v[0]
|
||
if not 0<=n<=12 or len(v)!=n+1 or any(not 0<=x<=255 for x in v[1:]): return -errno.EINVAL,[]
|
||
raw=bytes(v[1:]); digits=raw[:-1] if raw.endswith(b'\n') else raw
|
||
if digits[:1] in (b'+',b'-'): number=digits[1:]
|
||
else: number=digits
|
||
if not number or any(x<48 or x>57 for x in number): return -errno.EINVAL,[]
|
||
a=int(digits)
|
||
if not -2147483648<=a<=2147483647: return -errno.ERANGE,[]
|
||
r,_=self.invoke(1,a)
|
||
if not r: c[0]=a; c[4]+=1
|
||
elif name=='R' and len(v)==1:
|
||
cap=v[0]
|
||
if not 1<=cap<=16: r=-errno.EINVAL
|
||
else:
|
||
if not c[2]:
|
||
r,buf=self.invoke(2)
|
||
if not r: c[3]=int.from_bytes(bytes(buf),'little',signed=True); c[2]=1
|
||
if not r:
|
||
buf=list((str(c[3])+'\n').encode()); out=buf[c[1]:c[1]+cap]
|
||
c[1]+=len(out); c[5]+=1; c[6]+=len(out)
|
||
elif name=='S' and not v: c[1:4]=[0,0,0]; c[7]+=1
|
||
else: r=-errno.EINVAL
|
||
return r,out
|
||
def run(self,commands):
|
||
output=[]
|
||
for step,(name,args) in enumerate(commands,1):
|
||
self.trace=[]; result,data=self.apply(name,args)
|
||
output.append('N %d'%step); output+=self.trace
|
||
output.append('R %d %d%s'%(result,len(data),''.join(' %d'%x for x in data)))
|
||
output.append('C %d%s'%(self.selected,''.join(' %d'%x for bank in self.client for x in bank)))
|
||
values=[self.selected,self.total]
|
||
for bank,buf in zip(self.device,self.storage): values+=bank+[sum(buf)&65535]
|
||
values+=[x for pair in self.faults for x in pair]
|
||
output.append('B '+' '.join(map(str,values)))
|
||
return output
|
||
|
||
def scenarios(kind,seed):
|
||
rng=random.Random(seed); commands=[]
|
||
def add(name,*args): commands.append((name,list(args)))
|
||
def text(value):
|
||
raw=value.encode() if isinstance(value,str) else value
|
||
add('W',len(raw),*raw)
|
||
if kind=='gpio':
|
||
add('R'); add('W',1); add('O',7,1); add('W',1); add('R'); add('X')
|
||
add('Z',0,1,-1); add('O',9,1); add('R'); add('X'); add('O',9,0); add('X')
|
||
add('Z',0,0,-1); add('F',1,errno.EIO,1); add('O',5,0); add('O',5,0); add('W',0); add('D',1); add('W',0)
|
||
for i in range(5):
|
||
add('F',i,errno.EINTR,2); add('X'); add('O',i,1); add('W',i%2); add('R'); add('X')
|
||
for _ in range(180):
|
||
name=rng.choice(['O','D','W','R','X','A','F'])
|
||
args={'O':[rng.randrange(-1,258),rng.randrange(3)],'D':[rng.randrange(3)],'W':[rng.randrange(-1,3)],'R':[],'X':[],'A':[rng.randrange(4)],'F':[rng.randrange(5),rng.choice([errno.EINTR,errno.EIO]),rng.randrange(3)]}[name]
|
||
add(name,*args)
|
||
elif kind=='i2c':
|
||
add('R',0,1); add('O',31,0); add('R',7,4); add('C',65,0); add('R',7,4)
|
||
add('F',0,errno.EIO,1); add('C',900,1); add('R',7,4); add('C',900,1); add('R',7,4)
|
||
for n in [1,2,31,32]:
|
||
add('W',256-n,n,*[rng.randrange(256) for _ in range(n)]); add('R',256-n,n)
|
||
for a,n in [(-1,1),(256,1),(255,2),(0,0),(0,33),(2147483647,32)]: add('R',a,n)
|
||
for _ in range(160):
|
||
name=rng.choice(['O','C','R','W','X','A','F']); n=rng.randrange(1,7); a=rng.randrange(250)
|
||
args={'O':[rng.randrange(1030),rng.randrange(2)],'C':[rng.randrange(1030),rng.randrange(2)],'R':[a,n],'W':[a,n]+[rng.randrange(256) for _ in range(n)],'X':[],'A':[rng.randrange(4)],'F':[rng.randrange(3),rng.choice([errno.EINTR,errno.EIO]),rng.randrange(3)]}[name]
|
||
add(name,*args)
|
||
elif kind=='spi':
|
||
add('R',0,1); add('O',0,1000000); add('R',10,8)
|
||
for a,n in [(0,1),(15,2),(16,32),(31,32),(224,32)]:
|
||
add('E',a//32*32); add('W',a,n,*[rng.randrange(256) for _ in range(n)]); add('R',a,n)
|
||
for a,n in [(-1,1),(256,1),(255,2),(0,0),(0,33),(2147483647,32)]: add('R',a,n)
|
||
for _ in range(140):
|
||
name=rng.choice(['O','R','W','E','X','A','F']); n=rng.randrange(1,33); a=rng.randrange(257-n)
|
||
args={'O':[rng.randrange(-1,5),rng.choice([0,1,500000,1000001])],'R':[a,n],'W':[a,n]+[rng.randrange(256) for _ in range(n)],'E':[rng.randrange(8)*32],'X':[],'A':[rng.randrange(4)],'F':[rng.randrange(5),rng.choice([errno.EINTR,errno.EIO]),rng.randrange(3)]}[name]
|
||
add(name,*args)
|
||
elif kind=='ioctl':
|
||
add('I',80,1,2,8,0,0); add('Z',1,257,-1); add('I',80,1,2,8,0,0); add('Z',1,-2147483648,-1); add('I',80,1,2,8,0,0); add('I',80,2,1,8,711,3); add('I',80,1,2,8,0,0)
|
||
for m,n,d,s in [(81,1,2,8),(80,0,2,8),(80,2,2,8),(80,1,2,4),(80,3,0,8)]: add('I',m,n,d,s,300,1)
|
||
add('F',1,errno.EIO,1); add('I',80,2,1,8,299,2); add('I',80,1,2,8,0,0)
|
||
for _ in range(180):
|
||
name=rng.choice(['I','I','I','A','F']); n=rng.randrange(1,4)
|
||
args={'I':[80 if rng.randrange(5) else 79,n,{1:2,2:1,3:0}[n],0 if n==3 else (8 if rng.randrange(4) else 9),rng.randrange(1003),rng.randrange(5)],'A':[rng.randrange(4)],'F':[rng.randrange(3),rng.choice([errno.EINTR,errno.EIO]),rng.randrange(3)]}[name]
|
||
add(name,*args)
|
||
else:
|
||
add('R',1); text('12345\n'); add('R',3); add('R',3); add('S'); add('R',2); text('-77'); add('R',8); add('S'); add('R',16)
|
||
for value in ['', '\n','+','-','abc','17x',' 3','3\n4','2147483648','2147483648x','-2147483649','-2147483648','2147483647','+0','-0','007\n']:
|
||
text(value); add('S'); add('R',16)
|
||
add('F',0,errno.EIO,1); text('888'); add('F',1,errno.EINTR,2); add('S'); add('R',2); add('R',2)
|
||
for _ in range(180):
|
||
name=rng.choice(['W','R','S','A','F'])
|
||
if name=='W': text(str(rng.randrange(-1000000,1000000))+rng.choice(['','\n','x']))
|
||
else:
|
||
args={'R':[rng.randrange(18)],'S':[],'A':[rng.randrange(4)],'F':[rng.randrange(2),rng.choice([errno.EINTR,errno.EIO]),rng.randrange(3)]}[name]
|
||
add(name,*args)
|
||
for slot in range(8):
|
||
for width in (1,2,4): add('Q',slot,width)
|
||
for start,count in [(0,8),(8,0),(-1,1),(8,1),(0,9),(0,-1)]: add('P',start,count)
|
||
add('Q',0,3)
|
||
add('?',19)
|
||
return commands
|
||
|
||
def main():
|
||
cfg=json.loads((Path(__file__).parent/'context.json').read_text())
|
||
commands=scenarios(cfg['kind'],cfg['seed']); expected=Model(cfg['kind']).run(commands)
|
||
scratch=Path(tempfile.mkdtemp(prefix='embedded3-device-'+cfg['kind']+'-',dir='/tmp'))
|
||
for name,text in cfg['context'].items(): (scratch/name).write_text(text)
|
||
for name in cfg['candidates']: (scratch/name).write_bytes((Path(sys.argv[1])/name).read_bytes())
|
||
build=subprocess.run(['make','observe'],cwd=scratch,capture_output=True,text=True,timeout=25)
|
||
if build.returncode:
|
||
print('build failed: '+build.stderr[-1500:].replace('\n',' ')); return 1
|
||
payload='\n'.join(' '.join(map(str,[name]+args)) for name,args in commands)+'\n'
|
||
result=subprocess.run([str(scratch/'observe')],cwd=scratch,input=payload,capture_output=True,text=True,timeout=20)
|
||
# shortcut: 不在候选运行后访问共享scratch;批次owner核对精确前缀和清单后清理,升级条件为安全临时目录交接合同。
|
||
sys.stderr.write(result.stderr[-3000:])
|
||
if result.returncode: print('candidate exit '+str(result.returncode)); return 1
|
||
actual=result.stdout.splitlines()
|
||
if actual!=expected:
|
||
index=next((i for i,(a,b) in enumerate(zip(actual,expected)) if a!=b),min(len(actual),len(expected)))
|
||
print('observation %d got %r expected %r'%(index,actual[index] if index<len(actual) else '<missing>',expected[index] if index<len(expected) else '<end>')); return 1
|
||
print('PASS'); return 0
|
||
if __name__=='__main__': raise SystemExit(main())
|