def __init__(self, path_mgr, doslist_mgr, base_addr, size): self.path_mgr = path_mgr self.doslist_mgr = doslist_mgr self.base_addr = base_addr self.cur_addr = base_addr log_lock.info("init manager: base=%06x" % self.base_addr) self.locks_by_b_addr = {} LabelRange.__init__(self, "locks", base_addr, size) self.lock_def = FileLockDef self.lock_size = FileLockDef.get_size()
def __init__(self, name, addr, struct, size=0, offset=0): str_size = struct.get_size() if size < (str_size + offset): size = str_size + offset LabelRange.__init__(self, name, addr, size) self.struct = struct self.offset = offset self.struct_begin = addr + offset self.struct_end = self.struct_begin + str_size self.struct_size = str_size
def __init__(self, path_mgr, base_addr, size): self.path_mgr = path_mgr self.base_addr = base_addr self.cur_addr = base_addr log_doslist.info("init manager: base=%06x" % self.base_addr) self.entries_by_b_addr = {} self.entries_by_name = {} LabelRange.__init__(self, "doslist", base_addr, size) self.entry_device_def = DosListDeviceDef self.entry_volume_def = DosListVolumeDef self.entry_assign_def = DosListAssignDef self.entry_size = DosListDeviceDef.get_size()
def trace_mem(self, mode, width, addr, val): delta = addr - self.struct_begin if delta >= 0 and delta < self.struct_size: try: name,off,val_type_name = self.struct.get_name_for_offset(delta, width) type_name = self.struct.get_type_name() addon = "%s+%d = %s(%s)+%d" % (type_name, delta, name, val_type_name, off) self.trace_mem_int(mode, width, addr, val, text="Struct", addon=addon, level=logging.INFO) return True except BaseException: return False else: LabelRange.trace_mem(self, mode, width, addr, val) return True
def create_old_dos_guard(self): # create a guard memory for tracking invalid old dos access self.dos_guard_base = self.mem.reserve_special_range() self.dos_guard_size = 0x010000 label = LabelRange("old_dos",self.dos_guard_base, self.dos_guard_size) self.label_mgr.add_label(label) log_mem_init.info(label)
def __init__(self, raw_mem, cpu, path_mgr): self.raw_mem = raw_mem self.ram_size = raw_mem.ram_size self.cpu = cpu self.path_mgr = path_mgr # create a label manager and error tracker self.label_mgr = LabelManager() self.error_tracker = ErrorTracker(cpu, self.label_mgr) self.label_mgr.error_tracker = self.error_tracker # set a label for first two dwords label = LabelRange("zero_page",0,8) self.label_mgr.add_label(label) # create memory access self.mem = MainMemory(self.raw_mem, self.error_tracker) self.mem.ctx = self # create memory allocator self.mem_begin = 0x1000 self.alloc = MemoryAlloc(self.mem, 0, self.ram_size, self.mem_begin, self.label_mgr) # create segment loader self.seg_loader = SegmentLoader( self.mem, self.alloc, self.label_mgr, self.path_mgr ) # lib manager self.lib_mgr = LibManager( self.label_mgr ) # no current process right now self.process = None self.proc_list = [] self.tr_list = []
def alloc_cstr(self, name, cstr): size = len(cstr) + 1 addr = self.alloc_mem(size) label = LabelRange(name, addr, size) self.label_mgr.add_label(label) self.mem.access.w_cstr(addr, cstr) mem = Memory(addr,size,label,self.mem.access) log_mem_alloc.info("alloc c_str: %s",mem) self.mem_objs[addr] = mem return mem
def alloc_bstr(self, name, bstr): size = len(bstr) + 2 # front: count, end: extra zero for safety addr = self.alloc_mem(size) label = LabelRange(name, addr, size) self.label_mgr.add_label(label) self.mem.access.w_bstr(addr, bstr) mem = Memory(addr,size,label,self.mem.access) log_mem_alloc.info("alloc b_str: %s",mem) self.mem_objs[addr] = mem return mem
def alloc_memory(self, name, size, add_label=True): addr = self.alloc_mem(size) if add_label: label = LabelRange(name, addr, size) self.label_mgr.add_label(label) else: label = None mem = Memory(addr,size,label,self.mem.access) log_mem_alloc.info("alloc memory: %s",mem) self.mem_objs[addr] = mem return mem
def __init__(self, path_mgr, base_addr, size): self.path_mgr = path_mgr self.base_addr = base_addr self.cur_addr = base_addr log_file.info("init manager: base=%06x" % self.base_addr) self.files_by_b_addr = {} LabelRange.__init__(self, "files", base_addr, size) self.fh_def = FileHandleDef self.fh_size = FileHandleDef.get_size() self.fh_size = (self.fh_size + 3) & ~3 # setup std input/output self.std_input = AmiFile(sys.stdin, "<STDIN>", "", need_close=False) self.std_output = AmiFile(sys.stdout, "<STDOUT>", "", need_close=False) self._register_file(self.std_input) self._register_file(self.std_output) # get current umask self.umask = os.umask(0) os.umask(self.umask)
def __init__(self, path_mgr, base_addr, size): self.path_mgr = path_mgr self.base_addr = base_addr self.cur_addr = base_addr log_file.info("init manager: base=%06x" % self.base_addr) self.files_by_b_addr = {} LabelRange.__init__(self, "files", base_addr, size) self.fh_def = FileHandleDef self.fh_size = FileHandleDef.get_size() self.fh_size = (self.fh_size + 3) & ~3 # setup std input/output self.std_input = AmiFile(sys.stdin, '<STDIN>', '', need_close=False) self.std_output = AmiFile(sys.stdout, '<STDOUT>', '', need_close=False) self._register_file(self.std_input) self._register_file(self.std_output) # get current umask self.umask = os.umask(0) os.umask(self.umask)
def trace_mem(self, mode, width, addr, val): delta = addr - self.struct_begin if delta >= 0 and delta < self.struct_size: try: name, off, val_type_name = self.struct.get_name_for_offset( delta, width) type_name = self.struct.get_type_name() addon = "%s+%d = %s(%s)+%d" % (type_name, delta, name, val_type_name, off) self.trace_mem_int(mode, width, addr, val, text="Struct", addon=addon, level=logging.INFO) return True except BaseException: return False else: LabelRange.trace_mem(self, mode, width, addr, val) return True
def __init__(self, name, addr, size, segment): LabelRange.__init__(self, name, addr, size) self.segment = segment
def _load_seg(self, ami_bin_file, sys_bin_file): base_name = os.path.basename(sys_bin_file) hunk_file = HunkReader() # does file exist? if not os.path.isfile(sys_bin_file): self.error = "Can't find '%s'" % sys_bin_file return None # read hunk file fobj = file(sys_bin_file, "rb") result = hunk_file.read_file_obj(sys_bin_file, fobj, None) if result != Hunk.RESULT_OK: self.error = "Error loading '%s'" % sys_bin_file return None # build segments ok = hunk_file.build_segments() if not ok: self.error = "Error building segments for '%s'" % sys_bin_file return None # make sure its a loadseg() if hunk_file.type != Hunk.TYPE_LOADSEG: self.error = "File not loadSeg()able: '%s'" % sys_bin_file return None # create relocator relocator = HunkRelocate(hunk_file) # allocate segment memory sizes = relocator.get_sizes() names = relocator.get_type_names() seg_list = SegList(ami_bin_file, sys_bin_file) addrs = [] for i in xrange(len(sizes)): size = sizes[i] seg_size = size + 4 # add segment pointer seg_addr = self.alloc.alloc_mem(seg_size) # create label label = None name = "%s_%d:%s" % (base_name, i, names[i].replace("HUNK_", "").lower()) if self.alloc.label_mgr != None: label = LabelRange(name, seg_addr, seg_size) self.alloc.label_mgr.add_label(label) seg = Segment(name, seg_addr, seg_size, label) seg_list.add(seg) addrs.append(seg.addr + 4) # begin of segment data/code # relocate to addresses and return data datas = relocator.relocate(addrs) # write to allocated memory last_addr = None for i in xrange(len(sizes)): addr = addrs[i] self.mem.access.w_data(addr, datas[i]) # write segment pointers if last_addr != None: b_addr = addr >> 2 # BCPL segment pointers self.mem.access.w32(last_addr - 4, b_addr) last_addr = addr return seg_list
def __init__(self, addr, size): LabelRange.__init__(self, "ports", addr, size) self.ports = {} self.base_addr = addr self.size = size self.cur_addr = addr