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 __init__(self, raw_mem, cpu, traps, cfg):
self.raw_mem = raw_mem
self.ram_size = raw_mem.get_ram_size() * 1024 # in bytes
self.cpu = cpu
self.cpu_type = cfg.cpu
self.traps = traps
self.cfg = cfg
#sys.settrace(Tracer().traceit)
# too much RAM requested?
# our "custom chips" start at $BFxxxx so we allow RAM only to be below
if self.ram_size >= 0xbf0000 and self.cfg.hw_access != "disable":
raise VamosConfigError(
"Too much RAM configured! Only up to $BF0000 allowed.")
# setup custom chips
if self.cfg.hw_access != "disable":
self.hw_access = HardwareAccess(raw_mem)
self._setup_hw_access()
# path manager
self.path_mgr = PathManager(cfg)
# create a label manager and error tracker
if self.cfg.label_mgr != "disable":
self.label_mgr = LabelManager()
else:
self.label_mgr = None
self.error_tracker = ErrorTracker(cpu, self.label_mgr)
if self.label_mgr != None:
self.label_mgr.error_tracker = self.error_tracker
# set a label for first two dwords
if self.label_mgr != None:
label = LabelRange("zero_page", 0, 8)
self.label_mgr.add_label(label)
# create memory access
self.mem = MainMemory(raw_mem, self.error_tracker)
self.mem.ctx = self
self._setup_memory(raw_mem)
# 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, cfg)
# no current process right now
self.process = None
self.proc_list = []
def __init__(self, raw_mem, cpu, traps, cfg):
self.raw_mem = raw_mem
self.ram_size = raw_mem.get_ram_size() * 1024 # in bytes
self.cpu = cpu
self.cpu_type = cfg.cpu
self.traps = traps
self.cfg = cfg
# too much RAM requested?
# our "custom chips" start at $BFxxxx so we allow RAM only to be below
if self.ram_size >= 0xbf0000 and self.cfg.hw_access != "disable":
raise VamosConfigError("Too much RAM configured! Only up to $BF0000 allowed.")
# setup custom chips
if self.cfg.hw_access != "disable":
self.hw_access = HardwareAccess(raw_mem)
self._setup_hw_access()
# path manager
self.path_mgr = PathManager( cfg )
# 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(raw_mem, self.error_tracker)
self.mem.ctx = self
self._setup_memory(raw_mem)
# 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, cfg)
# no current process right now
self.process = None
self.proc_list = []
class Vamos:
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 init(self, cfg):
self.init_managers()
self.register_base_libs(cfg)
self.init_trampoline()
self.create_old_dos_guard()
self.open_exec_lib()
return True
def cleanup(self):
self.close_exec_lib()
self.free_trampoline()
self.alloc.dump_orphans()
# ----- process handling -----
def _set_this_task(self, proc):
"""tell exec about this process and all others referencing process from here"""
self.process = proc
self.exec_lib.lib_class.set_this_task(self.exec_lib, proc)
def set_main_process(self, proc):
log_proc.info("set main process: %s", proc)
self.proc_list.append(proc)
self._set_this_task(proc)
def start_sub_process(self, proc):
log_proc.info("start sub process: %s", proc)
self.proc_list.append(proc)
self._set_this_task(proc)
# setup trampoline to enter sub process
tr_mem_size = 128
tr_mem = self.alloc.alloc_memory("SubProcJump", tr_mem_size)
tr = Trampoline(self, tr_mem)
tr.init()
tr.save_all_but_d0()
# new proc registers: d0=arg_len a0=arg_cptr
tr.set_dx_l(0, proc.arg_len)
tr.set_ax_l(0, proc.arg_base)
# to track old dos values
tr.set_ax_l(2, self.dos_guard_base)
tr.set_ax_l(5, self.dos_guard_base)
tr.set_ax_l(6, self.dos_guard_base)
# setup new stack
stack_save_addr = tr_mem.addr + tr_mem_size - 4
tr.write_ax_l(7, stack_save_addr)
new_stack = proc.stack_initial
tr.set_ax_l(7, new_stack)
# call code! (jmp - return value is on stack)
tr.jmp(proc.prog_start)
# restore stack (set a label to return from new stack - see below)
lab = tr.set_label()
tr.read_ax_l(7, stack_save_addr)
# restore regs
tr.restore_all_but_d0()
# trap to clean up sub process resources
tr.trap(lambda x : self.stop_sub_process())
tr.rts()
tr.done()
# get label addr -> set as return value of new stack
lab_addr = tr.get_label(lab)
log_proc.debug("new_stack=%06x trampoline_return=%06x", new_stack, lab_addr)
self.mem.access.w32(new_stack, lab_addr)
# push trampoline
self.tr_list.append(tr)
def stop_sub_process(self):
# get return value
ret_code = self.cpu.r_reg(REG_D0)
# pop process
proc = self.proc_list.pop()
log_proc.info("stop sub process: %s ret_code=%d", proc, ret_code)
proc.free()
# pop trampoline
tr = self.tr_list.pop()
self.alloc.free_memory(tr.mem)
# ----- init environment -----
def init_managers(self):
self.doslist_base = self.mem.reserve_special_range()
self.doslist_size = 0x010000
self.doslist_mgr = DosListManager(self.path_mgr, self.doslist_base, self.doslist_size)
self.label_mgr.add_label(self.doslist_mgr)
self.mem.set_special_range_read_funcs(self.doslist_base, r32=self.doslist_mgr.r32_doslist)
log_mem_init.info(self.doslist_mgr)
# fill dos list
volumes = self.path_mgr.get_all_volume_names()
for vol in volumes:
self.doslist_mgr.add_volume(vol)
self.lock_base = self.mem.reserve_special_range()
self.lock_size = 0x010000
self.lock_mgr = LockManager(self.path_mgr, self.doslist_mgr, self.lock_base, self.lock_size)
self.label_mgr.add_label(self.lock_mgr)
self.mem.set_special_range_read_funcs(self.lock_base, r32=self.lock_mgr.r32_lock)
log_mem_init.info(self.lock_mgr)
self.file_base = self.mem.reserve_special_range()
self.file_size = 0x010000
self.file_mgr = FileManager(self.path_mgr, self.file_base, self.file_size)
self.label_mgr.add_label(self.file_mgr)
self.mem.set_special_range_read_funcs(self.file_base, r32=self.file_mgr.r32_fh)
log_mem_init.info(self.file_mgr)
self.port_base = self.mem.reserve_special_range()
self.port_size = 0x010000
self.port_mgr = PortManager(self.port_base, self.port_size)
self.label_mgr.add_label(self.port_mgr)
log_mem_init.info(self.port_mgr)
def register_base_libs(self, cfg):
libs_cfg = cfg.libs
# register libraries
# exec
self.exec_lib_def = ExecLibrary(self.lib_mgr, self.alloc, version=libs_cfg['exec']['version'], profile=libs_cfg['exec']['profile'])
self.lib_mgr.register_int_lib(self.exec_lib_def)
# dos
self.dos_lib_def = DosLibrary(self.mem, self.alloc, version=libs_cfg['dos']['version'], profile=libs_cfg['dos']['profile'])
self.dos_lib_def.set_managers(self.path_mgr, self.lock_mgr, self.file_mgr, self.port_mgr, self.seg_loader)
self.lib_mgr.register_int_lib(self.dos_lib_def)
# icon
self.icon_lib_def = IconLibrary()
self.lib_mgr.register_int_lib(self.icon_lib_def)
def init_trampoline(self):
self.tr_mem_size = 256
self.tr_mem = self.alloc.alloc_memory("Trampoline", self.tr_mem_size)
self.tr = Trampoline(self, self.tr_mem)
def free_trampoline(self):
self.alloc.free_memory(self.tr_mem)
def open_exec_lib(self):
# open exec lib
self.exec_lib = self.lib_mgr.open_lib(ExecLibrary.name, 0, self)
log_mem_init.info(self.exec_lib)
def close_exec_lib(self):
self.lib_mgr.close_lib(self.exec_lib.lib_base, self)
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)
class Vamos:
def __init__(self, raw_mem, cpu, traps, cfg):
self.raw_mem = raw_mem
self.ram_size = raw_mem.get_ram_size() * 1024 # in bytes
self.cpu = cpu
self.cpu_type = cfg.cpu
self.traps = traps
self.cfg = cfg
# too much RAM requested?
# our "custom chips" start at $BFxxxx so we allow RAM only to be below
if self.ram_size >= 0xbf0000 and self.cfg.hw_access != "disable":
raise VamosConfigError(
"Too much RAM configured! Only up to $BF0000 allowed.")
# setup custom chips
if self.cfg.hw_access != "disable":
self.hw_access = HardwareAccess(raw_mem)
self._setup_hw_access()
# path manager
self.path_mgr = PathManager(cfg)
# 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(raw_mem, self.error_tracker)
self.mem.ctx = self
self._setup_memory(raw_mem)
# 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, cfg)
# no current process right now
self.process = None
self.proc_list = []
def init(self):
self.register_base_libs(self.cfg)
self.create_old_dos_guard()
self.open_base_libs()
return True
def cleanup(self):
self.close_base_libs()
self.alloc.dump_orphans()
# ----- system setup -----
def _setup_hw_access(self):
# direct hw access
cfg = self.cfg
if cfg.hw_access == "emu":
self.hw_access.set_mode(HardwareAccess.MODE_EMU)
elif cfg.hw_access == "ignore":
self.hw_access.set_mode(HardwareAccess.MODE_IGNORE)
elif cfg.hw_access == "abort":
self.hw_access.set_mode(HardwareAccess.MODE_ABORT)
elif cfg.hw_access == "disable":
pass
else:
raise VamosConfigError("Invalid HW Access mode: %s" %
cfg.hw_access)
def _setup_memory(self, mem):
cfg = self.cfg
# enable mem trace?
if cfg.memory_trace:
mem.set_trace_mode(1)
mem.set_trace_func(self.label_mgr.trace_mem)
if not log_mem.isEnabledFor(logging.DEBUG):
log_mem.setLevel(logging.DEBUG)
# enable internal memory trace?
if cfg.internal_memory_trace:
AccessMemory.label_mgr = self.label_mgr
if not log_mem_int.isEnabledFor(logging.INFO):
log_mem_int.setLevel(logging.INFO)
# set invalid access handler for memory
mem.set_invalid_func(self.error_tracker.report_invalid_memory)
# ----- process handling -----
def _set_this_task(self, proc):
"""tell exec about this process and all others referencing process from here"""
self.process = proc
self.exec_lib.set_this_task(proc)
def set_main_process(self, proc):
log_proc.info("set main process: %s", proc)
self.proc_list.append(proc)
self._set_this_task(proc)
def start_sub_process(self, proc):
log_proc.info("start sub process: %s", proc)
self.proc_list.append(proc)
self._set_this_task(proc)
# setup trampoline to enter sub process
tr = Trampoline(self, "SubProcJump")
# reserve a long for old stack
old_stack_off = tr.dc_l(0)
# code starts
tr.save_all_but_d0()
# new proc registers: d0=arg_len a0=arg_cptr
tr.set_dx_l(0, proc.arg_len)
tr.set_ax_l(0, proc.arg_base)
# d2=stack_size. this value is also in 4(sp) (see Process.init_stack), but
# various C programs rely on it being present (1.3-3.1 at least have it).
tr.set_dx_l(2, proc.stack_size)
# to track old dos values
tr.set_ax_l(2, self.dos_guard_base)
tr.set_ax_l(5, self.dos_guard_base)
tr.set_ax_l(6, self.dos_guard_base)
# save old stack and set new stack
tr.write_ax_l(7, old_stack_off,
True) # write to data offset (dc.l above)
new_stack = proc.stack_initial
tr.set_ax_l(7, new_stack)
# call code! (jmp - return value is on stack)
tr.jmp(proc.prog_start)
# restore stack (set a label to return from new stack - see below)
return_off = tr.get_code_offset()
tr.read_ax_l(7, old_stack_off,
True) # read from data offset (dc.l above)
# restore regs
tr.restore_all_but_d0()
# trap to clean up sub process resources
def trap_stop_sub_process():
self.stop_sub_process()
tr.final_rts(trap_stop_sub_process)
# realize trampoline in memory (data+code)
tr.done()
# get label addr -> set as return value of new stack
return_addr = tr.get_code_addr(return_off)
log_proc.debug("new_stack=%06x return_addr=%06x", new_stack,
return_addr)
# place return address for new process
self.mem.access.w32(new_stack, return_addr)
def stop_sub_process(self):
# get return value
ret_code = self.cpu.r_reg(REG_D0)
# pop process
proc = self.proc_list.pop()
log_proc.info("stop sub process: %s ret_code=%d", proc, ret_code)
proc.free()
# ----- overload a process for RunCommand -----
def run_command(self, start_pc, argsptr, arglen, stacksize):
newstack = self.alloc.alloc_memory("shell command stack", stacksize)
newstackbase = newstack.addr
newstacktop = newstackbase + stacksize
oldstackbase = self.process.this_task.access.r_s("pr_Task.tc_SPLower")
oldstacktop = self.process.this_task.access.r_s("pr_Task.tc_SPUpper")
old_stackptr = self.cpu.r_reg(REG_A7) # addr of sys call return
# put stack size on top of stack
self.mem.access.w32(newstacktop - 4, stacksize)
# activate new stack
new_stackptr = newstacktop - 4
self.process.this_task.access.w_s("pr_Task.tc_SPLower", newstackbase)
self.process.this_task.access.w_s("pr_Task.tc_SPUpper", newstacktop)
# NOTE: the Manx fexec and BPCL mess is not (yet) setup here.
# setup trampoline to enter sub process
tr = Trampoline(self, "RunCommand")
# reserve a long for old stack
old_stack_off = tr.dc_l(0)
# code starts
tr.save_all_but_d0()
# new proc registers: d0=arg_len a0=arg_cptr
tr.set_dx_l(0, arglen)
tr.set_ax_l(0, argsptr)
# d2=stack_size. this value is also in 4(sp) (see Process.init_stack), but
# various C programs rely on it being present (1.3-3.1 at least have it).
tr.set_dx_l(2, stacksize)
# to track old dos values
tr.set_ax_l(2, self.dos_guard_base)
tr.set_ax_l(5, self.dos_guard_base)
tr.set_ax_l(6, self.dos_guard_base)
# save old stack and set new stack
tr.write_ax_l(7, old_stack_off,
True) # write to data offset (dc.l above)
tr.set_ax_l(7, new_stackptr)
# call code! (jmp - return value is on stack)
tr.jmp(start_pc)
# restore stack (set a label to return from new stack - see below)
return_off = tr.get_code_offset()
tr.read_ax_l(7, old_stack_off,
True) # read from data offset (dc.l above)
# restore regs
tr.restore_all_but_d0()
# keep the old input file handle
input_fh = self.process.get_input()
# trap to clean up sub process resources
def trap_stop_run_command():
ret_code = self.cpu.r_reg(REG_D0)
log_proc.info("return from RunCommand: ret_code=%d", ret_code)
self.cpu.w_reg(REG_A7, old_stackptr)
self.process.this_task.access.w_s("pr_Task.tc_SPLower",
oldstackbase)
self.process.this_task.access.w_s("pr_Task.tc_SPUpper",
oldstacktop)
self.alloc.free_memory(newstack)
input_fh.setbuf("")
# The return code remains in d0 as is
tr.final_rts(trap_stop_run_command)
# realize trampoline in memory (data+code)
tr.done()
# get label addr -> set as return value of new stack
return_addr = tr.get_code_addr(return_off)
log_proc.debug("new_stack=%06x return_addr=%06x", new_stackptr,
return_addr)
# place return address for new process
self.mem.access.w32(new_stackptr, return_addr)
def run_shell(self, start_pc, packet, stacksize, trap_stop_handler):
newstack = self.alloc.alloc_memory("shell command stack", stacksize)
newstackbase = newstack.addr
newstacktop = newstackbase + stacksize
oldstackbase = self.process.this_task.access.r_s("pr_Task.tc_SPLower")
oldstacktop = self.process.this_task.access.r_s("pr_Task.tc_SPUpper")
old_stackptr = self.cpu.r_reg(REG_A7) # addr of sys call return
# put stack size on top of stack
self.mem.access.w32(newstacktop - 4, stacksize)
# activate new stack
new_stackptr = newstacktop - 4
self.process.this_task.access.w_s("pr_Task.tc_SPLower", newstackbase)
self.process.this_task.access.w_s("pr_Task.tc_SPUpper", newstacktop)
# NOTE: the Manx fexec and BPCL mess is not (yet) setup here.
# setup trampoline to enter sub process
tr = Trampoline(self, "RunCommand")
# reserve a long for old stack
old_stack_off = tr.dc_l(0)
# code starts
tr.save_all_but_d0()
# new proc registers: d1=packet
tr.set_dx_l(1, packet >> 2)
# d2=stack_size. this value is also in 4(sp) (see Process.init_stack), but
# various C programs rely on it being present (1.3-3.1 at least have it).
tr.set_dx_l(2, stacksize)
# to track old dos values
tr.set_ax_l(2, self.dos_guard_base)
tr.set_ax_l(5, self.dos_guard_base)
tr.set_ax_l(6, self.dos_guard_base)
# save old stack and set new stack
tr.write_ax_l(7, old_stack_off,
True) # write to data offset (dc.l above)
tr.set_ax_l(7, new_stackptr)
# call code! (jmp - return value is on stack)
tr.jmp(start_pc)
# restore stack (set a label to return from new stack - see below)
return_off = tr.get_code_offset()
tr.read_ax_l(7, old_stack_off,
True) # read from data offset (dc.l above)
# restore regs
tr.restore_all_but_d0()
def trap_stop_function():
ret_code = self.cpu.r_reg(REG_D0)
log_proc.info("return from SystemTagList: ret_code=%d", ret_code)
self.cpu.w_reg(REG_A7, old_stackptr)
self.process.this_task.access.w_s("pr_Task.tc_SPLower",
oldstackbase)
self.process.this_task.access.w_s("pr_Task.tc_SPUpper",
oldstacktop)
self.alloc.free_memory(newstack)
trap_stop_handler(ret_code)
tr.final_rts(trap_stop_function)
# realize trampoline in memory (data+code)
tr.done()
# get label addr -> set as return value of new stack
return_addr = tr.get_code_addr(return_off)
log_proc.debug("new_stack=%06x return_addr=%06x", new_stackptr,
return_addr)
# place return address for new process
self.mem.access.w32(new_stackptr, return_addr)
# ----- init environment -----
def register_base_libs(self, cfg):
# register libraries
# exec
exec_cfg = cfg.get_lib_config('exec.library')
self.exec_lib_def = ExecLibrary(self.lib_mgr, self.alloc, exec_cfg)
self.lib_mgr.register_vamos_lib(self.exec_lib_def)
# dos
dos_cfg = cfg.get_lib_config('dos.library')
self.dos_lib_def = DosLibrary(self.mem, self.alloc, dos_cfg)
self.lib_mgr.register_vamos_lib(self.dos_lib_def)
# intuition
int_cfg = cfg.get_lib_config('intuition.library')
self.int_lib_def = IntuitionLibrary(int_cfg)
self.lib_mgr.register_vamos_lib(self.int_lib_def)
# utility
utility_cfg = cfg.get_lib_config('utility.library')
self.utility_lib_def = UtilityLibrary(utility_cfg)
self.lib_mgr.register_vamos_lib(self.utility_lib_def)
def open_base_libs(self):
# open exec lib
self.exec_lib = self.lib_mgr.open_lib(ExecLibrary.name, 0, self)
log_mem_init.info(self.exec_lib)
# open dos lib
self.dos_lib = self.lib_mgr.open_lib(DosLibrary.name, 0, self)
log_mem_init.info(self.dos_lib)
def close_base_libs(self):
# close dos
self.lib_mgr.close_lib(self.dos_lib.addr_base, self)
# close exec
self.lib_mgr.close_lib(self.exec_lib.addr_base, self)
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 guard", self.dos_guard_base,
self.dos_guard_size)
self.label_mgr.add_label(label)
log_mem_init.info(label)
class Vamos:
def __init__(self, raw_mem, cpu, traps, cfg):
self.raw_mem = raw_mem
self.ram_size = raw_mem.get_ram_size() * 1024 # in bytes
self.cpu = cpu
self.cpu_type = cfg.cpu
self.traps = traps
self.cfg = cfg
# too much RAM requested?
# our "custom chips" start at $BFxxxx so we allow RAM only to be below
if self.ram_size >= 0xbf0000:
raise VamosConfigError("Too much RAM configured! Only up to $BF0000 allowed.")
# setup custom chips
self.hw_access = HardwareAccess(raw_mem)
self._setup_hw_access()
# path manager
self.path_mgr = PathManager( cfg )
# 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(raw_mem, self.error_tracker)
self.mem.ctx = self
self._setup_memory(raw_mem)
# 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, cfg)
# no current process right now
self.process = None
self.proc_list = []
def init(self):
self.register_base_libs(self.cfg)
self.create_old_dos_guard()
self.open_base_libs()
return True
def cleanup(self):
self.close_base_libs()
self.alloc.dump_orphans()
# ----- system setup -----
def _setup_hw_access(self):
# direct hw access
cfg = self.cfg
if cfg.hw_access == "emu":
self.hw_access.set_mode(HardwareAccess.MODE_EMU)
elif cfg.hw_access == "ignore":
self.hw_access.set_mode(HardwareAccess.MODE_IGNORE)
elif cfg.hw_access == "abort":
self.hw_access.set_mode(HardwareAccess.MODE_ABORT)
else:
raise VamosConfigError("Invalid HW Access mode: %s" % cfg.hw_access)
def _setup_memory(self, mem):
cfg = self.cfg
# enable mem trace?
if cfg.memory_trace:
mem.set_trace_mode(1)
mem.set_trace_func(self.label_mgr.trace_mem)
if not log_mem.isEnabledFor(logging.DEBUG):
log_mem.setLevel(logging.DEBUG)
# enable internal memory trace?
if cfg.internal_memory_trace:
AccessMemory.label_mgr = self.label_mgr
if not log_mem_int.isEnabledFor(logging.INFO):
log_mem_int.setLevel(logging.INFO)
# set invalid access handler for memory
mem.set_invalid_func(self.error_tracker.report_invalid_memory)
# ----- process handling -----
def _set_this_task(self, proc):
"""tell exec about this process and all others referencing process from here"""
self.process = proc
self.exec_lib.set_this_task(proc)
def set_main_process(self, proc):
log_proc.info("set main process: %s", proc)
self.proc_list.append(proc)
self._set_this_task(proc)
def start_sub_process(self, proc):
log_proc.info("start sub process: %s", proc)
self.proc_list.append(proc)
self._set_this_task(proc)
# setup trampoline to enter sub process
tr = Trampoline(self, "SubProcJump")
# reserve a long for old stack
old_stack_off = tr.dc_l(0)
# code starts
tr.save_all_but_d0()
# new proc registers: d0=arg_len a0=arg_cptr
tr.set_dx_l(0, proc.arg_len)
tr.set_ax_l(0, proc.arg_base)
# d2=stack_size. this value is also in 4(sp) (see Process.init_stack), but
# various C programs rely on it being present (1.3-3.1 at least have it).
tr.set_dx_l(2, proc.stack_size)
# to track old dos values
tr.set_ax_l(2, self.dos_guard_base)
tr.set_ax_l(5, self.dos_guard_base)
tr.set_ax_l(6, self.dos_guard_base)
# save old stack and set new stack
tr.write_ax_l(7, old_stack_off, True) # write to data offset (dc.l above)
new_stack = proc.stack_initial
tr.set_ax_l(7, new_stack)
# call code! (jmp - return value is on stack)
tr.jmp(proc.prog_start)
# restore stack (set a label to return from new stack - see below)
return_off = tr.get_code_offset()
tr.read_ax_l(7, old_stack_off, True) # read from data offset (dc.l above)
# restore regs
tr.restore_all_but_d0()
# trap to clean up sub process resources
def trap_stop_sub_process():
self.stop_sub_process()
tr.final_rts(trap_stop_sub_process)
# realize trampoline in memory (data+code)
tr.done()
# get label addr -> set as return value of new stack
return_addr = tr.get_code_addr(return_off)
log_proc.debug("new_stack=%06x return_addr=%06x", new_stack, return_addr)
# place return address for new process
self.mem.access.w32(new_stack, return_addr)
def stop_sub_process(self):
# get return value
ret_code = self.cpu.r_reg(REG_D0)
# pop process
proc = self.proc_list.pop()
log_proc.info("stop sub process: %s ret_code=%d", proc, ret_code)
proc.free()
# ----- init environment -----
def register_base_libs(self, cfg):
# register libraries
# exec
exec_cfg = cfg.get_lib_config('exec.library')
self.exec_lib_def = ExecLibrary(self.lib_mgr, self.alloc, exec_cfg)
self.lib_mgr.register_vamos_lib(self.exec_lib_def)
# dos
dos_cfg = cfg.get_lib_config('dos.library')
self.dos_lib_def = DosLibrary(self.mem, self.alloc, dos_cfg)
self.lib_mgr.register_vamos_lib(self.dos_lib_def)
# intuition
int_cfg = cfg.get_lib_config('intuition.library')
self.int_lib_def = IntuitionLibrary(int_cfg)
self.lib_mgr.register_vamos_lib(self.int_lib_def)
# utility
utility_cfg = cfg.get_lib_config('utility.library')
self.utility_lib_def = UtilityLibrary(utility_cfg)
self.lib_mgr.register_vamos_lib(self.utility_lib_def)
def open_base_libs(self):
# open exec lib
self.exec_lib = self.lib_mgr.open_lib(ExecLibrary.name, 0, self)
log_mem_init.info(self.exec_lib)
# open dos lib
self.dos_lib = self.lib_mgr.open_lib(DosLibrary.name, 0, self)
log_mem_init.info(self.dos_lib)
def close_base_libs(self):
# close dos
self.lib_mgr.close_lib(self.dos_lib.addr_base, self)
# close exec
self.lib_mgr.close_lib(self.exec_lib.addr_base, self)
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)
class Vamos:
def __init__(self, raw_mem, cpu, cfg):
self.raw_mem = raw_mem
self.ram_size = raw_mem.ram_size
self.cpu = cpu
self.cpu_type = cfg.cpu
self.path_mgr = PathManager( cfg )
# 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, cfg)
# no current process right now
self.process = None
self.proc_list = []
def init(self, cfg):
self.init_managers()
self.register_base_libs(cfg)
self.create_old_dos_guard()
self.open_exec_lib()
return True
def cleanup(self):
self.close_exec_lib()
self.alloc.dump_orphans()
# ----- process handling -----
def _set_this_task(self, proc):
"""tell exec about this process and all others referencing process from here"""
self.process = proc
self.exec_lib.set_this_task(proc)
def set_main_process(self, proc):
log_proc.info("set main process: %s", proc)
self.proc_list.append(proc)
self._set_this_task(proc)
def start_sub_process(self, proc):
log_proc.info("start sub process: %s", proc)
self.proc_list.append(proc)
self._set_this_task(proc)
# setup trampoline to enter sub process
tr = Trampoline(self, "SubProcJump")
# reserve a long for old stack
old_stack_off = tr.dc_l(0)
# code starts
tr.save_all_but_d0()
# new proc registers: d0=arg_len a0=arg_cptr
tr.set_dx_l(0, proc.arg_len)
tr.set_ax_l(0, proc.arg_base)
# d2=stack_size. this value is also in 4(sp) (see Process.init_stack), but
# various C programs rely on it being present (1.3-3.1 at least have it).
tr.set_dx_l(2, proc.stack_size)
# to track old dos values
tr.set_ax_l(2, self.dos_guard_base)
tr.set_ax_l(5, self.dos_guard_base)
tr.set_ax_l(6, self.dos_guard_base)
# save old stack and set new stack
tr.write_ax_l(7, old_stack_off, True) # write to data offset (dc.l above)
new_stack = proc.stack_initial
tr.set_ax_l(7, new_stack)
# call code! (jmp - return value is on stack)
tr.jmp(proc.prog_start)
# restore stack (set a label to return from new stack - see below)
return_off = tr.get_code_offset()
tr.read_ax_l(7, old_stack_off, True) # read from data offset (dc.l above)
# restore regs
tr.restore_all_but_d0()
# trap to clean up sub process resources
def trap_stop_sub_process():
self.stop_sub_process()
tr.final_rts(trap_stop_sub_process)
# realize trampoline in memory (data+code)
tr.done()
# get label addr -> set as return value of new stack
return_addr = tr.get_code_addr(return_off)
log_proc.debug("new_stack=%06x return_addr=%06x", new_stack, return_addr)
# place return address for new process
self.mem.access.w32(new_stack, return_addr)
def stop_sub_process(self):
# get return value
ret_code = self.cpu.r_reg(REG_D0)
# pop process
proc = self.proc_list.pop()
log_proc.info("stop sub process: %s ret_code=%d", proc, ret_code)
proc.free()
# ----- init environment -----
def init_managers(self):
self.doslist_base = self.mem.reserve_special_range()
self.doslist_size = 0x010000
self.doslist_mgr = DosListManager(self.path_mgr, self.doslist_base, self.doslist_size)
self.label_mgr.add_label(self.doslist_mgr)
self.mem.set_special_range_read_funcs(self.doslist_base, r32=self.doslist_mgr.r32_doslist)
log_mem_init.info(self.doslist_mgr)
# fill dos list
volumes = self.path_mgr.get_all_volume_names()
for vol in volumes:
self.doslist_mgr.add_volume(vol)
self.lock_base = self.mem.reserve_special_range()
self.lock_size = 0x010000
self.lock_mgr = LockManager(self.path_mgr, self.doslist_mgr, self.lock_base, self.lock_size)
self.label_mgr.add_label(self.lock_mgr)
self.mem.set_special_range_read_funcs(self.lock_base, r32=self.lock_mgr.r32_lock)
log_mem_init.info(self.lock_mgr)
self.file_base = self.mem.reserve_special_range()
self.file_size = 0x010000
self.file_mgr = FileManager(self.path_mgr, self.file_base, self.file_size)
self.label_mgr.add_label(self.file_mgr)
self.mem.set_special_range_read_funcs(self.file_base, r32=self.file_mgr.r32_fh)
log_mem_init.info(self.file_mgr)
self.port_base = self.mem.reserve_special_range()
self.port_size = 0x010000
self.port_mgr = PortManager(self.port_base, self.port_size)
self.label_mgr.add_label(self.port_mgr)
log_mem_init.info(self.port_mgr)
def register_base_libs(self, cfg):
# register libraries
# exec
exec_cfg = cfg.get_lib_config('exec.library')
self.exec_lib_def = ExecLibrary(self.lib_mgr, self.alloc, exec_cfg)
self.lib_mgr.register_vamos_lib(self.exec_lib_def)
# dos
dos_cfg = cfg.get_lib_config('dos.library')
self.dos_lib_def = DosLibrary(self.mem, self.alloc, dos_cfg)
self.dos_lib_def.set_managers(self.path_mgr, self.lock_mgr, self.file_mgr, self.port_mgr, self.seg_loader)
self.lib_mgr.register_vamos_lib(self.dos_lib_def)
def open_exec_lib(self):
# open exec lib
self.exec_lib = self.lib_mgr.open_lib(ExecLibrary.name, 0, self)
self.exec_lib_def.set_cpu(self.cpu_type)
log_mem_init.info(self.exec_lib)
def close_exec_lib(self):
self.lib_mgr.close_lib(self.exec_lib.addr_base, self)
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)
class Vamos:
def __init__(self, raw_mem, cpu, traps, cfg):
self.raw_mem = raw_mem
self.ram_size = raw_mem.get_ram_size() * 1024 # in bytes
self.cpu = cpu
self.cpu_type = cfg.cpu
self.traps = traps
self.cfg = cfg
# too much RAM requested?
# our "custom chips" start at $BFxxxx so we allow RAM only to be below
if self.ram_size >= 0xbf0000:
raise VamosConfigError(
"Too much RAM configured! Only up to $BF0000 allowed.")
# setup custom chips
self.hw_access = HardwareAccess(raw_mem)
# path manager
self.path_mgr = PathManager(cfg)
# 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, cfg)
# no current process right now
self.process = None
self.proc_list = []
def init(self, cfg):
self.register_base_libs(cfg)
self.create_old_dos_guard()
self.open_base_libs()
return True
def cleanup(self):
self.close_base_libs()
self.alloc.dump_orphans()
# ----- process handling -----
def _set_this_task(self, proc):
"""tell exec about this process and all others referencing process from here"""
self.process = proc
self.exec_lib.set_this_task(proc)
def set_main_process(self, proc):
log_proc.info("set main process: %s", proc)
self.proc_list.append(proc)
self._set_this_task(proc)
def start_sub_process(self, proc):
log_proc.info("start sub process: %s", proc)
self.proc_list.append(proc)
self._set_this_task(proc)
# setup trampoline to enter sub process
tr = Trampoline(self, "SubProcJump")
# reserve a long for old stack
old_stack_off = tr.dc_l(0)
# code starts
tr.save_all_but_d0()
# new proc registers: d0=arg_len a0=arg_cptr
tr.set_dx_l(0, proc.arg_len)
tr.set_ax_l(0, proc.arg_base)
# d2=stack_size. this value is also in 4(sp) (see Process.init_stack), but
# various C programs rely on it being present (1.3-3.1 at least have it).
tr.set_dx_l(2, proc.stack_size)
# to track old dos values
tr.set_ax_l(2, self.dos_guard_base)
tr.set_ax_l(5, self.dos_guard_base)
tr.set_ax_l(6, self.dos_guard_base)
# save old stack and set new stack
tr.write_ax_l(7, old_stack_off,
True) # write to data offset (dc.l above)
new_stack = proc.stack_initial
tr.set_ax_l(7, new_stack)
# call code! (jmp - return value is on stack)
tr.jmp(proc.prog_start)
# restore stack (set a label to return from new stack - see below)
return_off = tr.get_code_offset()
tr.read_ax_l(7, old_stack_off,
True) # read from data offset (dc.l above)
# restore regs
tr.restore_all_but_d0()
# trap to clean up sub process resources
def trap_stop_sub_process():
self.stop_sub_process()
tr.final_rts(trap_stop_sub_process)
# realize trampoline in memory (data+code)
tr.done()
# get label addr -> set as return value of new stack
return_addr = tr.get_code_addr(return_off)
log_proc.debug("new_stack=%06x return_addr=%06x", new_stack,
return_addr)
# place return address for new process
self.mem.access.w32(new_stack, return_addr)
def stop_sub_process(self):
# get return value
ret_code = self.cpu.r_reg(REG_D0)
# pop process
proc = self.proc_list.pop()
log_proc.info("stop sub process: %s ret_code=%d", proc, ret_code)
proc.free()
# ----- init environment -----
def register_base_libs(self, cfg):
# register libraries
# exec
exec_cfg = cfg.get_lib_config('exec.library')
self.exec_lib_def = ExecLibrary(self.lib_mgr, self.alloc, exec_cfg)
self.lib_mgr.register_vamos_lib(self.exec_lib_def)
# dos
dos_cfg = cfg.get_lib_config('dos.library')
self.dos_lib_def = DosLibrary(self.mem, self.alloc, dos_cfg)
self.lib_mgr.register_vamos_lib(self.dos_lib_def)
# intuition
int_cfg = cfg.get_lib_config('intuition.library')
self.int_lib_def = IntuitionLibrary(int_cfg)
self.lib_mgr.register_vamos_lib(self.int_lib_def)
# utility
utility_cfg = cfg.get_lib_config('utility.library')
self.utility_lib_def = UtilityLibrary(utility_cfg)
self.lib_mgr.register_vamos_lib(self.utility_lib_def)
def open_base_libs(self):
# open exec lib
self.exec_lib = self.lib_mgr.open_lib(ExecLibrary.name, 0, self)
log_mem_init.info(self.exec_lib)
# open dos lib
self.dos_lib = self.lib_mgr.open_lib(DosLibrary.name, 0, self)
log_mem_init.info(self.dos_lib)
def close_base_libs(self):
# close dos
self.lib_mgr.close_lib(self.dos_lib.addr_base, self)
# close exec
self.lib_mgr.close_lib(self.exec_lib.addr_base, self)
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)
