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