def mem_access_rw_sub_field_task_test(): mem = MockMemory() a = AccessStruct(mem, TaskStruct, 0x42) a.w_s("tc_Node.ln_Succ", 42) a.w_s("tc_Node.ln_Pred", 21) assert a.r_s("tc_Node.ln_Succ") == 42 assert a.r_s("tc_Node.ln_Pred") == 21
def mem_access_rw_sub_field_task_test(): mem = MockMemory() a = AccessStruct(mem, TaskStruct, 0x42) a.w_s('tc_Node.ln_Succ', 42) a.w_s('tc_Node.ln_Pred', 21) assert a.r_s('tc_Node.ln_Succ') == 42 assert a.r_s('tc_Node.ln_Pred') == 21
def mem_access_invalid_node_test(): mem = MockMemory() a = AccessStruct(mem, NodeStruct, 0x42) with pytest.raises(KeyError): a.w_s('bla', 12) with pytest.raises(KeyError): a.r_s('blub')
def mem_access_invalid_node_test(): mem = MockMemory() a = AccessStruct(mem, NodeStruct, 0x42) with pytest.raises(KeyError): a.w_s("bla", 12) with pytest.raises(KeyError): a.r_s("blub")
def StackSwap(self, ctx): stsw_ptr = ctx.cpu.r_reg(REG_A0) stsw = AccessStruct(ctx.mem, StackSwapStruct, 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.r32(old_pointer) # is a label attached to new addr if ctx.label_mgr: 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.w32(new_pointer, callee) # activate new stack ctx.cpu.w_reg(REG_A7, new_pointer)
def put_msg(self, port_mgr, msg_addr): msg = AccessStruct(self.mem,MessageStruct,struct_addr=msg_addr) dos_pkt_addr = msg.r_s("mn_Node.ln_Name") dos_pkt = AccessStruct(self.mem,DosPacketStruct,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.w_block(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.r_block(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 mem_access_bptr_test(): mem = MockMemory() a = AccessStruct(mem, MyBCPLStruct, 0x42) # write/read addr a.w_s("bs_TestBptr", 44) assert a.r_s("bs_TestBptr") == 44 # check auto converted baddr assert mem.r32(0x42) == 11
def mem_access_rw_field_node_test(): mem = MockMemory() a = AccessStruct(mem, NodeStruct, 0x42) a.w_s("ln_Succ", 42) a.w_s("ln_Pred", 21) a.w_s("ln_Pri", -27) assert a.r_s("ln_Succ") == 42 assert a.r_s("ln_Pred") == 21 assert a.r_s("ln_Pri") == -27
def mem_access_rw_field_node_test(): mem = MockMemory() a = AccessStruct(mem, NodeStruct, 0x42) a.w_s('ln_Succ', 42) a.w_s('ln_Pred', 21) a.w_s('ln_Pri', -27) assert a.r_s('ln_Succ') == 42 assert a.r_s('ln_Pred') == 21 assert a.r_s('ln_Pri') == -27
def CloseDevice(self, ctx): io_addr = ctx.cpu.r_reg(REG_A1) if io_addr != 0: io = AccessStruct(ctx.mem, IORequestStruct, io_addr) dev_addr = io.r_s("io_Device") if dev_addr != 0: log_exec.info("CloseDevice: %06x", dev_addr) self.lib_mgr.close_lib(dev_addr) io.w_s("io_Device", 0)
def OpenDevice(self, ctx): name_ptr = ctx.cpu.r_reg(REG_A0) unit = ctx.cpu.r_reg(REG_D0) io_addr = ctx.cpu.r_reg(REG_A1) io = AccessStruct(ctx.mem, IORequestStruct, io_addr) flags = ctx.cpu.r_reg(REG_D1) name = ctx.mem.r_cstr(name_ptr) addr = self.lib_mgr.open_lib(name) io.w_s("io_Device", addr) if addr == 0: log_exec.info("OpenDevice: '%s' unit %d flags %d -> NULL", name, unit, flags) return -1 else: log_exec.info("OpenDevice: '%s' unit %d flags %d -> %06x", name, unit, flags, addr) return 0
def console_put_msg(self, port_mgr, msg_addr): msg = AccessStruct(self.mem, MessageStruct, struct_addr=msg_addr) dos_pkt_addr = msg.r_s("mn_Node.ln_Name") dos_pkt = AccessStruct(self.mem, DosPacketStruct, 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( "Console DosPacket: msg=%06x -> pkt=%06x: reply_port=%06x type=%06x", msg_addr, dos_pkt_addr, reply_port_addr, pkt_type, ) # fake result dos_pkt.w_s("dp_Res1", 0) # 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 examine_file(self, fib_mem, name, sys_path): # name name_addr = fib_mem.s_get_addr('fib_FileName') # clear 32 name bytes mem = fib_mem.mem mem.clear_block(name_addr, 32, 0) mem.w_cstr(name_addr, name) # comment comment_addr = fib_mem.s_get_addr('fib_Comment') 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 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, DateStampStruct, 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 examine_file(self, fib_mem, name, sys_path): # name name_addr = fib_mem.s_get_addr('fib_FileName') # clear 32 name bytes mem = fib_mem.mem mem.clear_block(name_addr, 32, 0) mem.w_cstr(name_addr, name) # comment comment_addr = fib_mem.s_get_addr('fib_Comment') 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 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, DateStampStruct, 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, ListStruct, list_addr) n = AccessStruct(ctx.mem, NodeStruct, 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, NodeStruct, h).w_s("ln_Pred", node_addr) l.w_s("lh_Head", node_addr)
def InitSemaphore(self,addr): semaphore = AccessStruct(self.mem,SignalSemaphoreStruct,struct_addr=addr) semaphore.w_s("ss_Owner",0) semaphore.w_s("ss_NestCount",0) semaphore.w_s("ss_QueueCount",-1) 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_clock_data(dt, mem, data_ptr): """convert Python datetime struct to Amiga ClockData stored at pointer""" data = AccessStruct(mem, ClockDataStruct, struct_addr=data_ptr) # fill in date struct data.w_s('sec', dt.second) data.w_s('min', dt.minute) data.w_s('hour', dt.hour) data.w_s('mday', dt.day) data.w_s('month', dt.month) data.w_s('year', dt.year) data.w_s('wday', dt.weekday())
def write(self, ctx): mh = AccessStruct(ctx.mem, MemHeaderStruct, self.addr) # only update first/free mh.w_s("mh_First", self.first) mh.w_s("mh_Free", self.free)
def write(self, ctx): mc = AccessStruct(ctx.mem, MemChunkStruct, self.addr) mc.w_s("mc_Next", self.next) mc.w_s("mc_Bytes", self.bytes)
def write_clock_data(dt, mem, data_ptr): """convert Python datetime struct to Amiga ClockData stored at pointer""" data = AccessStruct(mem, ClockDataStruct, struct_addr=data_ptr) # fill in date struct data.w_s("sec", dt.second) data.w_s("min", dt.minute) data.w_s("hour", dt.hour) data.w_s("mday", dt.day) data.w_s("month", dt.month) data.w_s("year", dt.year) data.w_s("wday", dt.weekday())
def InitSemaphore(self,addr): semaphore = AccessStruct(self.mem,SignalSemaphoreStruct,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 _examine_file(self, fib_mem, name, sys_path, key): # name name_addr = fib_mem.s_get_addr("fib_FileName") # clear 32 name bytes mem = fib_mem.mem mem.clear_block(name_addr, 32, 0) mem.w_cstr(name_addr, name) # comment comment_addr = fib_mem.s_get_addr("fib_Comment") mem.w_cstr(comment_addr, "") # create the "inode" information 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 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) # limit to 32bit if size > 0xFFFFFFFF: size = 0xFFFFFFFF fib_mem.w_s("fib_Size", size) blocks = (size + 511) // 512 fib_mem.w_s("fib_NumBlocks", blocks) log_lock.debug("examine lock: '%s' size=%d, blocks=%d", sys_path, size, blocks) else: fib_mem.w_s("fib_NumBlocks", 1) log_lock.debug("examine lock: '%s' no file", sys_path) # date (use mtime here) date_addr = fib_mem.s_get_addr("fib_Date") date = AccessStruct(fib_mem.mem, DateStampStruct, 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