def put_msg(self, port_mgr, msg_addr):
msg = AccessStruct(self.ctx.mem,MessageDef,struct_addr=msg_addr)
dos_pkt_addr = msg.r_s("mn_Node.ln_Name")
dos_pkt = AccessStruct(self.ctx.mem,DosPacketDef,struct_addr=dos_pkt_addr)
reply_port_addr = dos_pkt.r_s("dp_Port")
pkt_type = dos_pkt.r_s("dp_Type")
log_dos.info("DosPacket: msg=%06x -> pkt=%06x: reply_port=%06x type=%06x", msg_addr, dos_pkt_addr, reply_port_addr, pkt_type)
# handle packet
if pkt_type == ord('R'): # read
fh_b_addr = dos_pkt.r_s("dp_Arg1")
buf_ptr = dos_pkt.r_s("dp_Arg2")
size = dos_pkt.r_s("dp_Arg3")
# get fh and read
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
data = self.file_mgr.read(fh, size)
self.ctx.mem.access.w_data(buf_ptr, data)
got = len(data)
log_dos.info("DosPacket: Read fh_b_addr=%06x buf=%06x len=%06x -> got=%06x fh=%s", fh_b_addr, buf_ptr, size, got, fh)
dos_pkt.w_s("dp_Res1", got)
elif pkt_type == ord('W'): # write
fh_b_addr = dos_pkt.r_s("dp_Arg1")
buf_ptr = dos_pkt.r_s("dp_Arg2")
size = dos_pkt.r_s("dp_Arg3")
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
data = self.ctx.mem.access.r_data(buf_ptr, size)
self.file_mgr.write(fh, data)
put = len(data)
log_dos.info("DosPacket: Write fh=%06x buf=%06x len=%06x -> put=%06x fh=%s", fh_b_addr, buf_ptr, size, put, fh)
dos_pkt.w_s("dp_Res1", put)
else:
raise UnsupportedFeatureError("Unsupported DosPacket: type=%d" % pkt_type)
# do reply
if not self.port_mgr.has_port(reply_port_addr):
self.port_mgr.add_port(reply_port_addr)
self.port_mgr.put_msg(reply_port_addr, msg_addr)
def StackSwap(self, ctx):
stsw_ptr = ctx.cpu.r_reg(REG_A0)
stsw = AccessStruct(ctx.mem,StackSwapDef,struct_addr=stsw_ptr)
# get new stack values
new_lower = stsw.r_s('stk_Lower')
new_upper = stsw.r_s('stk_Upper')
new_pointer = stsw.r_s('stk_Pointer')
# retrieve current (old) stack
old_lower = self.stk_lower
old_upper = self.stk_upper
old_pointer = ctx.cpu.r_reg(REG_A7) # addr of sys call return
# get adress of callee
callee = ctx.mem.access.r32(old_pointer)
# we report the old stack befor callee
old_pointer += 4
log_exec.info("StackSwap: old(lower=%06x,upper=%06x,ptr=%06x) new(lower=%06x,upper=%06x,ptr=%06x)" % (old_lower,old_upper,old_pointer,new_lower,new_upper,new_pointer))
stsw.w_s('stk_Lower', old_lower)
stsw.w_s('stk_Upper', old_upper)
stsw.w_s('stk_Pointer', old_pointer)
self.stk_lower = new_lower
self.stk_upper = new_upper
# put callee's address on new stack
new_pointer -= 4
ctx.mem.access.w32(new_pointer,callee)
# activate new stack
ctx.cpu.w_reg(REG_A7, new_pointer)
def StackSwap(self, ctx):
stsw_ptr = ctx.cpu.r_reg(REG_A0)
stsw = AccessStruct(ctx.mem, StackSwapDef, struct_addr=stsw_ptr)
# get new stack values
new_lower = stsw.r_s('stk_Lower')
new_upper = stsw.r_s('stk_Upper')
new_pointer = stsw.r_s('stk_Pointer')
# retrieve current (old) stack
old_lower = self.stk_lower
old_upper = self.stk_upper
old_pointer = ctx.cpu.r_reg(REG_A7) # addr of sys call return
# get adress of callee
callee = ctx.mem.access.r32(old_pointer)
# is a label attached to new addr
label = ctx.label_mgr.get_label(new_lower)
if label is not None:
label.name = label.name + "=Stack"
# we report the old stack befor callee
old_pointer += 4
log_exec.info(
"StackSwap: old(lower=%06x,upper=%06x,ptr=%06x) new(lower=%06x,upper=%06x,ptr=%06x)"
% (old_lower, old_upper, old_pointer, new_lower, new_upper,
new_pointer))
stsw.w_s('stk_Lower', old_lower)
stsw.w_s('stk_Upper', old_upper)
stsw.w_s('stk_Pointer', old_pointer)
self.stk_lower = new_lower
self.stk_upper = new_upper
# put callee's address on new stack
new_pointer -= 4
ctx.mem.access.w32(new_pointer, callee)
# activate new stack
ctx.cpu.w_reg(REG_A7, new_pointer)
def AddLibrary(self, ctx):
lib_ptr = ctx.cpu.r_reg(REG_A1)
lib = AccessStruct(ctx.mem, LibraryDef, lib_ptr)
# Set up lib_Node
lib.w_s("lib_Node.ln_Succ", lib_ptr)
lib.w_s("lib_Node.ln_Pred", lib_ptr)
lib.w_s("lib_Node.ln_Type", NT_LIBRARY)
return lib_ptr
def CloseDevice(self,ctx):
io_addr = ctx.cpu.r_reg(REG_A1)
if io_addr != 0:
io = AccessStruct(ctx.mem, IORequestDef, io_addr)
dev_addr = io.r_s("io_Device")
if dev_addr != 0:
dev = self.lib_mgr.close_dev(dev_addr,ctx)
io.w_s("io_Device",0)
if dev != None:
log_exec.info("CloseDevice: '%s' -> %06x" % (dev, dev.addr_base))
else:
raise VamosInternalError("CloseDevice: Unknown library to close: ptr=%06x" % dev_addr)
def CloseDevice(self,ctx):
io_addr = ctx.cpu.r_reg(REG_A1)
if io_addr != 0:
io = AccessStruct(ctx.mem, IORequestDef, io_addr)
dev_addr = io.r_s("io_Device")
if dev_addr != 0:
dev = self.lib_mgr.close_dev(dev_addr,ctx)
io.w_s("io_Device",0)
if dev != None:
log_exec.info("CloseDevice: '%s' -> %06x" % (dev, dev.addr_base))
else:
raise VamosInternalError("CloseDevice: Unknown library to close: ptr=%06x" % dev_addr)
def GetDeviceProc(self, ctx):
name_ptr = ctx.cpu.r_reg(REG_D1)
last_devproc = ctx.cpu.r_reg(REG_D2)
name = ctx.mem.access.r_cstr(name_ptr)
# get volume of path
abs_name = self.path_mgr.ami_abs_path(name)
volume = self.path_mgr.ami_volume_of_path(abs_name)
vol_lock = self.lock_mgr.create_lock(volume+":", False)
fs_port = self.file_mgr.get_fs_handler_port()
addr = self._alloc_mem("DevProc:%s" % name, DevProcDef.get_size())
log_dos.info("GetDeviceProc: name='%s' devproc=%06x -> volume=%s devproc=%06x", name, last_devproc, volume, addr)
devproc = AccessStruct(self.ctx.mem,DevProcDef,struct_addr=addr)
devproc.w_s('dvp_Port', fs_port)
devproc.w_s('dvp_Lock', vol_lock.b_addr)
self.io_err = NO_ERROR
return addr
def put_msg(self, port_mgr, msg_addr):
msg = AccessStruct(self.mem, MessageDef, struct_addr=msg_addr)
dos_pkt_addr = msg.r_s("mn_Node.ln_Name")
dos_pkt = AccessStruct(self.mem,
DosPacketDef,
struct_addr=dos_pkt_addr)
reply_port_addr = dos_pkt.r_s("dp_Port")
pkt_type = dos_pkt.r_s("dp_Type")
log_file.info(
"DosPacket: msg=%06x -> pkt=%06x: reply_port=%06x type=%06x",
msg_addr, dos_pkt_addr, reply_port_addr, pkt_type)
# handle packet
if pkt_type == ord('R'): # read
fh_b_addr = dos_pkt.r_s("dp_Arg1")
buf_ptr = dos_pkt.r_s("dp_Arg2")
size = dos_pkt.r_s("dp_Arg3")
# get fh and read
fh = self.get_by_b_addr(fh_b_addr)
data = fh.read(size)
self.mem.access.w_data(buf_ptr, data)
got = len(data)
log_file.info(
"DosPacket: Read fh_b_addr=%06x buf=%06x len=%06x -> got=%06x fh=%s",
fh_b_addr, buf_ptr, size, got, fh)
dos_pkt.w_s("dp_Res1", got)
elif pkt_type == ord('W'): # write
fh_b_addr = dos_pkt.r_s("dp_Arg1")
buf_ptr = dos_pkt.r_s("dp_Arg2")
size = dos_pkt.r_s("dp_Arg3")
fh = self.get_by_b_addr(fh_b_addr)
data = self.mem.access.r_data(buf_ptr, size)
fh.write(data)
put = len(data)
log_file.info(
"DosPacket: Write fh=%06x buf=%06x len=%06x -> put=%06x fh=%s",
fh_b_addr, buf_ptr, size, put, fh)
dos_pkt.w_s("dp_Res1", put)
else:
raise UnsupportedFeatureError("Unsupported DosPacket: type=%d" %
pkt_type)
# do reply
if not port_mgr.has_port(reply_port_addr):
port_mgr.register_port(reply_port_addr)
port_mgr.put_msg(reply_port_addr, msg_addr)
def GetDeviceProc(self, lib, ctx):
name_ptr = ctx.cpu.r_reg(REG_D1)
last_devproc = ctx.cpu.r_reg(REG_D2)
name = ctx.mem.access.r_cstr(name_ptr)
# get volume of path
abs_name = self.path_mgr.ami_abs_path(name)
volume = self.path_mgr.ami_volume_of_path(abs_name)
vol_lock = self.lock_mgr.create_lock(volume + ":", False)
fs_port = self.file_mgr.get_fs_handler_port()
addr = self._alloc_mem("DevProc:%s" % name, DevProcDef.get_size())
log_dos.info(
"GetDeviceProc: name='%s' devproc=%06x -> volume=%s devproc=%06x",
name, last_devproc, volume, addr)
devproc = AccessStruct(self.ctx.mem, DevProcDef, struct_addr=addr)
devproc.w_s('dvp_Port', fs_port)
devproc.w_s('dvp_Lock', vol_lock.b_addr)
self.io_err = NO_ERROR
return addr
def DateStamp(self, ctx):
ds_ptr = ctx.cpu.r_reg(REG_D1)
ds = AccessStruct(ctx.mem,DateStampDef,struct_addr=ds_ptr)
t = time.time()
at = sys_to_ami_time(t)
log_dos.info("DateStamp: ptr=%06x sys_time=%d time=%s", ds_ptr, t, at)
ds.w_s("ds_Days",at.tday)
ds.w_s("ds_Minute",at.tmin)
ds.w_s("ds_Tick",at.tick)
return ds_ptr
def DateStamp(self, lib, ctx):
ds_ptr = ctx.cpu.r_reg(REG_D1)
ds = AccessStruct(ctx.mem, DateStampDef, struct_addr=ds_ptr)
t = time.time()
at = sys_to_ami_time(t)
log_dos.info("DateStamp: ptr=%06x time=%s" % (ds_ptr, at))
ds.w_s("ds_Days", at.tday)
ds.w_s("ds_Minute", at.tmin)
ds.w_s("ds_Tick", at.tick)
return ds_ptr
def examine_file(self, fib_mem, name, sys_path):
# name
name_addr = fib_mem.s_get_addr('fib_FileName')
# clear 32 name bytes
fib_mem.clear_data(name_addr, 32, 0)
fib_mem.w_cstr(name_addr, name)
# comment
comment_addr = fib_mem.s_get_addr('fib_Comment')
fib_mem.w_cstr(comment_addr, "")
# create the "inode" information
key = self.keygen(sys_path)
fib_mem.w_s('fib_DiskKey',key)
log_lock.debug("examine key: %08x", key)
# type
if os.path.isdir(sys_path):
dirEntryType = 2
else:
dirEntryType = (-3) & 0xffffffff
fib_mem.w_s('fib_DirEntryType', dirEntryType )
fib_mem.w_s('fib_EntryType', dirEntryType )
# protection
prot = DosProtection(0)
try:
os_stat = os.stat(sys_path)
mode = os_stat.st_mode
if mode & stat.S_IXUSR == 0:
prot.clr(DosProtection.FIBF_EXECUTE)
if mode & stat.S_IRUSR == 0:
prot.clr(DosProtection.FIBF_READ)
if mode & stat.S_IWUSR == 0:
prot.clr(DosProtection.FIBF_WRITE)
log_lock.debug("examine lock: '%s' mode=%03o: prot=%s", name, mode, prot)
except OSError:
return ERROR_OBJECT_IN_USE
fib_mem.w_s('fib_Protection', prot.mask)
# size
if os.path.isfile(sys_path):
size = os.path.getsize(sys_path)
fib_mem.w_s('fib_Size', size)
blocks = int((size + 511) / 512)
fib_mem.w_s('fib_NumBlocks', blocks)
else:
fib_mem.w_s('fib_NumBlocks', 1)
# date (use mtime here)
date_addr = fib_mem.s_get_addr('fib_Date')
date = AccessStruct(fib_mem.mem, DateStampDef, date_addr)
t = os.path.getmtime(sys_path)
at = sys_to_ami_time(t)
date.w_s('ds_Days', at.tday)
date.w_s('ds_Minute', at.tmin)
date.w_s('ds_Tick', at.tick)
# fill in UID/GID
fib_mem.w_s('fib_OwnerUID', 0)
fib_mem.w_s('fib_OwnerGID', 0)
return NO_ERROR
def AddHead(self, ctx):
list_addr = ctx.cpu.r_reg(REG_A0)
node_addr = ctx.cpu.r_reg(REG_A1)
log_exec.info("AddHead(%06x, %06x)" % (list_addr, node_addr))
l = AccessStruct(ctx.mem, ListDef, list_addr)
n = AccessStruct(ctx.mem, NodeDef, node_addr)
n.w_s("ln_Pred", l.s_get_addr("lh_Head"))
h = l.r_s("lh_Head")
n.w_s("ln_Succ", h)
AccessStruct(ctx.mem, NodeDef, h).w_s("ln_Pred", node_addr)
l.w_s("lh_Head", node_addr)
def AddTail(self, ctx):
list_addr = ctx.cpu.r_reg(REG_A0)
node_addr = ctx.cpu.r_reg(REG_A1)
log_exec.info("AddTail(%06x, %06x)" % (list_addr, node_addr))
l = AccessStruct(ctx.mem, ListDef, list_addr)
n = AccessStruct(ctx.mem, NodeDef, node_addr)
n.w_s("ln_Succ", l.s_get_addr("lh_Tail"))
tp = l.r_s("lh_TailPred")
n.w_s("ln_Pred", tp)
AccessStruct(ctx.mem, NodeDef, tp).w_s("ln_Succ", node_addr)
l.w_s("lh_TailPred", node_addr)
def examine_file(self, fib_mem, name, sys_path):
# name
name_addr = fib_mem.s_get_addr('fib_FileName')
fib_mem.w_cstr(name_addr, name)
# create the "inode" information
key = self.keygen(sys_path)
fib_mem.w_s('fib_DiskKey',key)
# type
if os.path.isdir(sys_path):
dirEntryType = 2
else:
dirEntryType = (-3) & 0xffffffff
fib_mem.w_s('fib_DirEntryType', dirEntryType )
fib_mem.w_s('fib_EntryType', dirEntryType )
# protection
prot = DosProtection(0)
try:
os_stat = os.stat(sys_path)
mode = os_stat.st_mode
if mode & stat.S_IXUSR == 0:
prot.clr(DosProtection.FIBF_EXECUTE)
if mode & stat.S_IRUSR == 0:
prot.clr(DosProtection.FIBF_READ)
if mode & stat.S_IWUSR == 0:
prot.clr(DosProtection.FIBF_WRITE)
prot.clr(DosProtection.FIBF_DELETE)
if mode & stat.S_ISUID != 0:
prot.set(DosProtection.FIBF_PURE)
if mode & stat.S_ISGID != 0:
prot.set(DosProtection.FIBF_SCRIPT)
log_lock.debug("examine lock: '%s' mode=%03o: prot=%s", name, mode, prot)
except OSError:
return ERROR_OBJECT_IN_USE
fib_mem.w_s('fib_Protection', prot.mask)
# size
if os.path.isfile(sys_path):
size = os.path.getsize(sys_path)
fib_mem.w_s('fib_Size', size)
# date (use mtime here)
date_addr = fib_mem.s_get_addr('fib_Date')
date = AccessStruct(fib_mem.mem, DateStampDef, date_addr)
t = os.path.getmtime(sys_path)
at = sys_to_ami_time(t)
date.w_s('ds_Days', at.tday)
date.w_s('ds_Minute', at.tmin)
date.w_s('ds_Tick', at.tick)
return NO_ERROR
def examine_file(self, fib_mem, name, sys_path):
# name
name_addr = fib_mem.s_get_addr('fib_FileName')
fib_mem.w_cstr(name_addr, name)
# dummy key
fib_mem.w_s('fib_DiskKey',0xcafebabe)
# type
if os.path.isdir(sys_path):
dirEntryType = 0x2 # dir
else:
dirEntryType = 0xfffffffd # file
fib_mem.w_s('fib_DirEntryType', dirEntryType )
# protection
prot = DosProtection(0)
try:
os_stat = os.stat(sys_path)
mode = os_stat.st_mode
if mode & stat.S_IXUSR == 0:
prot.clr(DosProtection.FIBF_EXECUTE)
if mode & stat.S_IRUSR == 0:
prot.clr(DosProtection.FIBF_READ)
if mode & stat.S_IWUSR == 0:
prot.clr(DosProtection.FIBF_WRITE)
log_lock.debug("examine lock: '%s' mode=%03o: prot=%s", name, mode, prot)
except OSError:
return ERROR_OBJECT_IN_USE
fib_mem.w_s('fib_Protection', prot.mask)
# size
if os.path.isfile(sys_path):
size = os.path.getsize(sys_path)
fib_mem.w_s('fib_Size', size)
# date (use mtime here)
date_addr = fib_mem.s_get_addr('fib_Date')
date = AccessStruct(fib_mem.mem, DateStampDef, date_addr)
t = os.path.getmtime(sys_path)
at = sys_to_ami_time(t)
date.w_s('ds_Days', at.tday)
date.w_s('ds_Minute', at.tmin)
date.w_s('ds_Tick', at.tick)
return NO_ERROR
def write(self, ctx):
mh = AccessStruct(ctx.mem, MemHeaderDef, self.addr)
# only update first/free
mh.w_s('mh_First', self.first)
mh.w_s('mh_Free', self.free)
def InitSemaphore(self, ctx):
sem_addr = ctx.cpu.r_reg(REG_A0)
sem = AccessStruct(ctx.mem, SignalSemaphoreDef, sem_addr)
log_exec.info("InitSemaphore(%06x)", sem_addr)
wq_tail_ptr = sem.r_s("ss_WaitQueue.mlh_Tail")
wq_head_ptr = sem.r_s("ss_WaitQueue.mlh_Head")
sem.w_s("ss_WaitQueue.mlh_Head", wq_tail_ptr)
sem.w_s("ss_WaitQueue.mlh_Tail", 0)
sem.w_s("ss_WaitQueue.mlh_TailPred", wq_head_ptr)
sem.w_s("ss_Link.ln_Type", NT_SIGNALSEM)
sem.w_s("ss_NestCount", 0)
sem.w_s("ss_Owner", 0)
sem.w_s("ss_QueueCount", -1)
def InitSemaphore(self,addr):
semaphore = AccessStruct(self.mem,SignalSemaphoreDef,struct_addr=addr)
semaphore.w_s("ss_Owner",0)
semaphore.w_s("ss_NestCount",0)
semaphore.w_s("ss_QueueCount",0xffff)
semaphore.w_s("ss_Link.ln_Type",self.NT_SIGNALSEM)
semaphore.w_s("ss_WaitQueue.mlh_Head",semaphore.s_get_addr("ss_WaitQueue.mlh_Tail"))
semaphore.w_s("ss_WaitQueue.mlh_Tail",0)
semaphore.w_s("ss_WaitQueue.mlh_TailPred",semaphore.s_get_addr("ss_WaitQueue.mlh_Head"))
return self.register_semaphore(addr)
def _register_file(self, fh):
baddr = fh.alloc_fh(self.alloc, self.fs_handler_port)
self.files_by_b_addr[baddr] = fh
handle = AccessStruct(self.mem, FileHandleDef, struct_addr=baddr * 4)
handle.w_s("fh_End", 0xffffffff)
log_file.info("registered: %s" % fh)
def Insert(self, ctx):
listNode_addr = ctx.cpu.r_reg(REG_A2)
if listNode_addr == 0:
self.AddHead(ctx)
else:
node_addr = ctx.cpu.r_reg(REG_A1)
listNode = AccessStruct(ctx.mem, NodeDef, listNode_addr)
n = AccessStruct(ctx.mem, NodeDef, node_addr)
succ_addr = listNode.r_s("ln_Succ")
if succ_addr == 0:
tail_addr = listNode.r_s("ln_Pred")
n.w_s("ln_Succ",listNode_addr)
n.w_s("ln_Pred",tail_addr)
listNode.w_s("ln_Pred",node_addr)
AccessStruct(ctx.mem, NodeDef, tail_addr).w_s("ln_Succ",node_addr)
else:
s = AccessStruct(ctx.mem, NodeDef, succ_addr)
n.w_s("ln_Succ",succ_addr)
n.w_s("ln_Pred",listNode_addr)
listNode.w_s("ln_Succ",node_addr)
s.w_s("ln_Pred",node_addr)
def Info(self, ctx):
lock_b_addr = ctx.cpu.r_reg(REG_D1)
info_ptr = ctx.cpu.r_reg(REG_D2)
lock = self.lock_mgr.get_by_b_addr(lock_b_addr)
info = AccessStruct(ctx.mem, InfoDataDef, struct_addr=info_ptr)
vol = lock.find_volume_node(self.dos_list)
if vol != None:
info.w_s("id_NumSoftErrors", 0)
info.w_s("id_UnitNumber", 0) # not that we really care...
info.w_s("id_DiskState", 0) # disk is not write protected
info.w_s("id_NumBlocks", 0x7FFFFFFF) # a really really big disk....
info.w_s("id_NumBlocksUsed", 0x0FFFFFFF) # some...
info.w_s("id_BytesPerBlock", 512) # let's take regular FFS blocks
info.w_s("id_DiskType", 0x444F5303) # international FFS
info.w_s("id_VolumeNode", vol)
info.w_s("id_InUse", 0)
log_dos.info("Info: %s info=%06x -> true" % (lock, info_ptr))
return self.DOSTRUE
else:
log_dos.info("Info: %s info=%06x -> false" % (lock, info_ptr))
return self.DOSFALSE
def write(self, ctx):
mc = AccessStruct(ctx.mem, MemChunkDef, self.addr)
mc.w_s('mc_Next', self.next)
mc.w_s('mc_Bytes', self.bytes)
def InitSemaphore(self, addr):
semaphore = AccessStruct(self.mem,
SignalSemaphoreDef,
struct_addr=addr)
semaphore.w_s("ss_Owner", 0)
semaphore.w_s("ss_NestCount", 0)
semaphore.w_s("ss_QueueCount", 0xffff)
semaphore.w_s("ss_Link.ln_Type", self.NT_SIGNALSEM)
semaphore.w_s("ss_WaitQueue.mlh_Head",
semaphore.s_get_addr("ss_WaitQueue.mlh_Tail"))
semaphore.w_s("ss_WaitQueue.mlh_Tail", 0)
semaphore.w_s("ss_WaitQueue.mlh_TailPred",
semaphore.s_get_addr("ss_WaitQueue.mlh_Head"))
return self.register_semaphore(addr)
def write(self, ctx):
mc = AccessStruct(ctx.mem, MemChunkDef, self.addr)
mc.w_s('mc_Next', self.next)
mc.w_s('mc_Bytes', self.bytes)
def write(self, ctx):
mh = AccessStruct(ctx.mem, MemHeaderDef, self.addr)
# only update first/free
mh.w_s('mh_First', self.first)
mh.w_s('mh_Free', self.free)
