def libnative_libfuncs_set_function_test():
machine = Machine()
mem = machine.get_mem()
cpu = machine.get_cpu()
sp = machine.get_ram_begin() - 4
alloc = MemoryAlloc.for_machine(machine)
# new lib
lib = Library.alloc(alloc, name="my.library", id_string="bla", neg_size=36)
lib_addr = lib.get_addr()
lib.new_lib()
lib.fill_funcs(op_jmp, 0xCAFEBABE)
assert lib.neg_size.val == 36
# patch function
lvo = -30
addr = lib.get_addr() + lvo
assert mem.r16(addr) == op_jmp
assert mem.r32(addr + 2) == 0xCAFEBABE
lf = LibFuncs(machine, alloc)
old_addr = lf.set_function(lib_addr, lvo, 0xDEADBEEF)
assert old_addr == 0xCAFEBABE
assert mem.r16(addr) == op_jmp
assert mem.r32(addr + 2) == 0xDEADBEEF
assert lib.check_sum()
# invalid function
old_addr = lf.set_function(lib_addr, -36, 0)
assert old_addr is None
# cleanup
lib.free()
assert alloc.is_all_free()
def libnative_libfuncs_open_library_test():
machine = Machine()
mem = machine.get_mem()
cpu = machine.get_cpu()
traps = machine.get_traps()
sp = machine.get_ram_begin() - 4
alloc = MemoryAlloc.for_machine(machine)
# new lib
lib = Library.alloc(alloc, name="my.library", id_string="bla", neg_size=36)
lib.new_lib()
# setup open func
def open_func(op, pc):
# return my seglist
cpu.w_reg(REG_D0, 0xCAFEBABE)
trap_id = traps.setup(open_func, auto_rts=True)
exp_addr = lib.get_addr() - 6
mem.w16(exp_addr, trap_id | 0xA000)
# add lib
lf = LibFuncs(machine, alloc)
lib_base = lf.open_library(lib.get_addr(), run_sp=sp)
assert lib_base == 0xCAFEBABE
# cleanup
lib.free()
assert alloc.is_all_free()
def libnative_libfuncs_close_library_test():
machine = Machine()
mem = machine.get_mem()
cpu = machine.get_cpu()
traps = machine.get_traps()
sp = machine.get_ram_begin() - 4
alloc = MemoryAlloc.for_machine(machine)
segloader = SegmentLoader(alloc)
# new lib
lib = Library.alloc(alloc, name="my.library", id_string="bla", neg_size=36)
lib.new_lib()
# setup seglist
seglist = SegList.alloc(alloc, [64])
segloader.register_seglist(seglist.get_baddr())
# setup expunge func
def close_func(op, pc):
# return my seglist
cpu.w_reg(REG_D0, seglist.get_baddr())
trap_id = traps.setup(close_func, auto_rts=True)
exp_addr = lib.get_addr() - 12
mem.w16(exp_addr, trap_id | 0xA000)
# add lib
lf = LibFuncs(machine, alloc)
sl = lf.close_library(lib.get_addr(), segloader, run_sp=sp)
assert seglist.get_baddr() == sl
# cleanup
lib.free()
assert alloc.is_all_free()
assert segloader.shutdown() == 0
def libnative_libfuncs_add_library_test():
machine = Machine()
mem = machine.get_mem()
alloc = MemoryAlloc.for_machine(machine)
# setup exec lib
exec_lib = ExecLibrary.alloc(alloc,
name="exec.library",
id_string="bla",
neg_size=36)
assert exec_lib.LibNode.neg_size.val == 36
assert exec_lib.LibNode.pos_size.val == ExecLibrary.get_size()
exec_lib.new_lib()
mem.w32(4, exec_lib.get_addr())
# new lib
lib = Library.alloc(alloc, name="my.library", id_string="bla", neg_size=36)
assert lib.neg_size.val == 36
lib.new_lib()
mem.w32(lib.get_addr() - 36, 0xDEADBEEF)
# check initial lib sum
assert lib.sum.val == 0
assert lib.calc_sum() == 0xDEADBEEF
# add lib
lf = LibFuncs(machine, alloc)
lf.add_library(lib.addr)
# check that lib was added
assert len(exec_lib.lib_list) == 1
libs = [a for a in exec_lib.lib_list]
assert list(map(lambda x: x.addr, libs)) == [lib.addr]
# check that libsum was calced
assert lib.sum.val == 0xDEADBEEF
assert lf.find_library("my.library") == lib.addr
# cleanup
lib.free()
exec_lib.free()
assert alloc.is_all_free()
def add_library(self, lib_base, exec_lib=None):
lib = Library(self.mem, lib_base)
lib.node.type.val = NodeType.NT_LIBRARY
self.sum_library(lib_base)
if exec_lib is None:
exec_addr = self.mem.r32(4)
exec_lib = ExecLibrary(self.mem, exec_addr)
exec_lib.lib_list.enqueue(lib.node)
def _check_version(self, name, addr, open_ver):
# check version
lib = Library(self.mem, addr)
lib_ver = lib.version.val
if lib_ver < open_ver:
log_libmgr.warning("lib '%s' has too low version: %d < %d", name,
lib_ver, open_ver)
return 0
else:
log_libmgr.info("lib '%s' version %d ok for open version %d", name,
lib_ver, open_ver)
return addr
def libnative_libfuncs_sum_library_test():
machine = Machine()
mem = machine.get_mem()
alloc = MemoryAlloc.for_machine(machine)
# new lib
lib = Library.alloc(alloc, name="my.library", id_string="bla", neg_size=36)
lib.new_lib()
mem.w32(lib.get_addr() - 36, 0xDEADBEEF)
# sum lib
lf = LibFuncs(machine, alloc)
lf.sum_library(lib.get_addr())
assert lib.sum.val == 0xDEADBEEF
# cleanup
lib.free()
assert alloc.is_all_free()
def libnative_makelib_test():
machine = Machine()
mem = machine.get_mem()
sp = machine.get_ram_begin() - 4
alloc = MemoryAlloc.for_machine(machine)
# build lib info in memory
vectors = 0x100
mem.w32(vectors, 0x400)
mem.w32(vectors + 4, 0x600)
mem.w32(vectors + 8, 0x800)
mem.w32(vectors + 12, 0xFFFFFFFF)
name_addr = 0x1F0
mem.w_cstr(name_addr, "bla.library")
init_tab = 0x200
ib = InitStructBuilder(mem, init_tab)
name_off = LibraryStruct.sdef.lib_Node.ln_Name.base_offset
ib.init_long(name_off, name_addr)
ib.end()
init_func = 0x300
mem.w16(init_func, op_rts)
pos_size = LibraryStruct.get_size()
# make library
ml = MakeLib(machine, alloc)
lib_base, mem_obj = ml.make_library(vectors,
init_tab,
init_func,
pos_size,
0,
run_sp=sp)
assert lib_base != 0
# check library
lib = Library(mem, lib_base)
assert lib.name.str == "bla.library"
assert lib.pos_size.val == 36
assert lib.neg_size.val == 20 # round_long(3*6)
assert mem.r32(lib_base - 4) == 0x400
assert mem.r32(lib_base - 10) == 0x600
assert mem.r32(lib_base - 16) == 0x800
# cleanup
alloc.free_memory(mem_obj)
assert alloc.is_all_free()
def make_library(
self,
vectors_addr,
init_struct_addr,
init_func_addr,
pos_size,
seglist_baddr,
label_name=None,
run_sp=None,
):
"""Exec's MakeLibrary
return lib_base, mem_obj or 0, None
"""
neg_size, offsets = self._calc_neg_size(vectors_addr)
neg_size = self._round_long(neg_size)
pos_size = self._round_long(pos_size)
size = neg_size + pos_size
# allocate lib mem
if label_name is None:
label_name = "MakeLibrary"
mobj = self.alloc.alloc_memory(size, label=label_name)
addr = mobj.addr
lib_base = addr + neg_size
# init funcs
mf = MakeFuncs(self.mem)
if offsets:
mf.make_functions(lib_base, vectors_addr + 2, vectors_addr)
else:
mf.make_functions(lib_base, vectors_addr)
# lib object and set neg/pos size
lib = Library(self.mem, addr, neg_size=neg_size, pos_size=pos_size)
# init struct?
if init_struct_addr != 0:
i = InitStruct(self.mem)
i.init_struct(init_struct_addr, lib_base, 0)
# init func?
if init_func_addr != 0:
lib_base = self.run_init(init_func_addr, lib_base, seglist_baddr,
label_name, run_sp)
return lib_base, mobj
def libtypes_library_open_cnt_test(mem_alloc):
mem, alloc = mem_alloc
# alloc lib
name = "my.library"
id_str = "my.library 1.2"
neg_size = 30
pos_size = LibraryStruct.get_size()
lib = Library.alloc(alloc, name=name, id_string=id_str, neg_size=neg_size)
# test open cnt
assert lib.open_cnt.val == 0
lib.inc_open_cnt()
assert lib.open_cnt.val == 1
lib.dec_open_cnt()
assert lib.open_cnt.val == 0
# done
lib.free()
assert alloc.is_all_free()
def libtypes_library_base_test(mem_alloc):
mem, alloc = mem_alloc
# alloc lib
name = "my.library"
id_str = "my.library 1.2"
neg_size = 12
pos_size = LibraryStruct.get_size()
lib = Library.alloc(alloc, name=name, id_string=id_str, neg_size=neg_size)
assert lib._mem_obj.size == neg_size + pos_size
assert pos_size == lib.pos_size.val
assert neg_size == lib.neg_size.val
assert lib.node.name.str == name
assert lib.id_string.str == id_str
# lib setup
flags = LibFlags.LIBF_SUMMING | LibFlags.LIBF_CHANGED
ltype = NodeType.NT_DEVICE
pri = -3
ver = 1
rev = 2
lib.new_lib(version=ver, revision=rev, pri=pri, flags=flags, type=ltype)
# check lib
node = lib.node
assert node.succ.ref is None
assert node.pred.ref is None
assert node.type.val == ltype
assert node.pri.val == pri
assert lib.flags.val == flags
assert lib.pad.val == 0
assert lib.neg_size.val == neg_size
assert lib.pos_size.val == pos_size
assert lib.version.val == ver
assert lib.revision.val == rev
assert lib.sum.val == 0
assert lib.open_cnt.val == 0
assert lib.node.name.str == name
assert lib.id_string.str == id_str
# fill funcs
lib.fill_funcs()
lib_base = lib.get_addr()
assert mem.r16(lib_base - 6) == op_rts
# done
lib.free()
assert alloc.is_all_free()
def libtypes_library_sum_test(mem_alloc):
mem, alloc = mem_alloc
# alloc lib
name = "my.library"
id_str = "my.library 1.2"
neg_size = 30
lib = Library.alloc(alloc, name=name, id_string=id_str, neg_size=neg_size)
# assume rounded neg size
assert lib.neg_size.val == 32
mem.w32(lib.addr - 32, 0xDEADBEEF)
mem.w32(lib.addr - 28, 0xCAFEBABE)
my_sum = (0xDEADBEEF + 0xCAFEBABE) & 0xFFFFFFFF
lib_sum = lib.calc_sum()
assert lib_sum == my_sum
lib.update_sum()
assert lib.sum.val == my_sum
assert lib.check_sum()
# done
lib.free()
assert alloc.is_all_free()
def set_function(self, lib_base, lvo, new_func_addr):
"""return old func addr or None if patch failed"""
lib = Library(self.mem, lib_base)
neg_size = lib.neg_size.val
if lvo < 0:
lvo = -lvo
# check lvo range
if lvo >= neg_size:
return None
# check that jmp is at lvo
addr = lib_base - lvo
jmp = self.mem.r16(addr)
if jmp != op_jmp:
return None
# set new function
old_func = self.mem.r32(addr + 2)
self.mem.w32(addr + 2, new_func_addr)
# sum lib
self.sum_library(lib_base)
return old_func
def _create_library(self, info, is_dev, fd):
if is_dev:
ltype = NodeType.NT_DEVICE
else:
ltype = NodeType.NT_LIBRARY
name = info.get_name()
id_str = info.get_id_string()
neg_size = info.get_neg_size()
pos_size = info.get_pos_size()
library = Library.alloc(
self.alloc,
name=name,
id_string=id_str,
neg_size=neg_size,
pos_size=pos_size,
fd=fd,
)
version = info.get_version()
revision = info.get_revision()
library.new_lib(version=version, revision=revision, type=ltype)
return library
def libtypes_library_label_test(mem_alloc):
mem, alloc = mem_alloc
name = "vamostest.library"
id_str = "vamostest.library 0.1"
fd = read_lib_fd("vamostest.library")
neg_size = fd.get_neg_size()
lib = Library.alloc(alloc,
name=name,
id_string=id_str,
neg_size=neg_size,
fd=fd)
# check for label
label = lib._mem_obj.label
if alloc.get_label_mgr():
assert label
assert isinstance(label, LabelLib)
assert label.fd == fd
else:
assert not label
# done
lib.free()
assert alloc.is_all_free()
def init_resident(self,
resident_addr,
seg_list_baddr,
label_name=None,
run_sp=None,
exec_lib=None):
"""Implement Exec's InitResident
Returns lib_base, mem_obj or lib_base, 0 or 0, None
"""
res = Resident(self.mem, resident_addr)
if not res.is_valid():
return 0, None
if label_name is None:
label_name = "%s_init" % res.name
auto_init = res.flags.has_bits(ResidentFlags.RTF_AUTOINIT)
if auto_init:
ai = res.init.ref
# create lib without calling init
ml = MakeLib(self.machine, self.alloc)
lib_base, mem_obj = ml.make_library(
ai.functions.aptr,
ai.init_struct.aptr,
0,
ai.pos_size.val,
seg_list_baddr,
label_name=label_name,
run_sp=run_sp,
)
# fill lib
lib = Library(self.mem, lib_base)
flags = LibFlags.LIBF_CHANGED | LibFlags.LIBF_SUMUSED
lib.new_lib(version=res.version, type=res.type.val, flags=flags)
lib.name.aptr = res.name.aptr
lib.id_string.aptr = res.id_string.aptr
# now call init
if ai.init_func.aptr != 0:
run_name = "InitResident:%s" % res.name.str
lib_base = ml.run_init(ai.init_func.aptr, lib_base,
seg_list_baddr, run_name, run_sp)
if lib_base == 0:
return 0, None
# add lib to exec list
rtype = res.type.val
if rtype == NodeType.NT_LIBRARY:
lf = LibFuncs(self.machine, self.alloc)
lf.add_library(lib_base, exec_lib)
elif rtype == NodeType.NT_DEVICE:
# TODO
raise NotImplementedError("InitResource(NT_DEVICE)")
elif rtype == NodeType.NT_RESOURCE:
# TODO
raise NotImplementedError("InitResident(NT_RESOURCE)")
else:
raise ValueError("InitResident: invalid type!")
else:
# no auto init, lib_base, or mem_obj
lib_base = 0
mem_obj = None
# call init func
init_func = res.init.aptr
if init_func != 0:
ml = MakeLib(self.machine, self.alloc)
lib_base = ml.run_init(init_func, lib_base, seg_list_baddr,
label_name, run_sp)
return lib_base, mem_obj
def libnative_initres_autoinit_test(buildlibnix):
machine = Machine()
mem = machine.get_mem()
cpu = machine.get_cpu()
traps = machine.get_traps()
alloc = MemoryAlloc.for_machine(machine)
init_addr = machine.get_ram_begin() - 4
sp = init_addr - 4
# load lib
seglist, addr, size, end = load_lib(alloc, buildlibnix)
# setup init func
def init_func(op, pc):
assert cpu.r_reg(REG_A0) == seglist.get_baddr()
trap_id = traps.setup(init_func, auto_rts=True)
mem.w16(init_addr, trap_id | 0xA000)
# fake vectors
vectors = 0x100
mem.w32(vectors, 0x400)
mem.w32(vectors + 4, 0x600)
mem.w32(vectors + 8, 0x800)
mem.w32(vectors + 12, 0xFFFFFFFF)
# build fake resident
res = Resident.alloc(alloc, name="bla.library", id_string="blub")
res.new_resident(flags=ResidentFlags.RTF_AUTOINIT,
version=42,
type=NodeType.NT_LIBRARY,
pri=-7)
auto_init = AutoInitStruct.alloc(alloc,
functions=vectors,
init_func=init_addr)
res.init.ref = auto_init
# setup exec lib
exec_lib = ExecLibrary.alloc(alloc,
name="exec.library",
id_string="bla",
neg_size=36)
exec_lib.new_lib()
mem.w32(4, exec_lib.get_addr())
# init resident
ir = InitRes(machine, alloc)
lib_base, mem_obj = ir.init_resident(res.get_addr(),
seglist.get_baddr(),
run_sp=sp,
exec_lib=exec_lib)
assert lib_base
assert mem_obj
# check lib
lib = Library(mem, lib_base)
assert lib.name.str == "bla.library"
assert lib.id_string.str == "blub"
assert lib.neg_size.val == 20 # fits the 3*6 vectors
# clean up
seglist.free()
res.free()
auto_init.free()
alloc.free_memory(mem_obj)
exec_lib.free()
traps.free(trap_id)
assert alloc.is_all_free()
def sum_library(self, lib_base):
lib = Library(self.mem, lib_base)
lib.flags.clr_bits(LibFlags.LIBF_CHANGED | LibFlags.LIBF_SUMUSED)
return lib.update_sum()
def free_lib(mem, alloc, lib_base):
lib = Library(mem, lib_base)
mem_obj = alloc.get_memory(lib_base - lib.neg_size.val)
assert mem_obj
alloc.free_memory(mem_obj)