use super::*;
#[test]
fn native_operation_uses_canonical_allocator_without_slice_handoff() {
let pef = synthetic_pef_with_import(b"NewHandle");
let mut native = load_pef_application(&pef).unwrap();
native.cpu.gpr[3] = 32;
run_test_import(
&mut native,
PpcImportDispatcherTarget::NewHandle { clear: false },
);
let handle = native.cpu.gpr[3];
assert_ne!(handle, 0);
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle();
let expected_cursor = native.heap_cursor() + 16;
{
let mut manager = memory_manager.borrow_mut();
manager.set_state_for_handle(handle, 0xa0);
let mut canonical = manager.native_allocation(handle).unwrap();
canonical.size = 24;
canonical.capacity = 40;
manager.set_native_allocation(canonical);
manager.mutate_native_allocator(|allocator| {
allocator.heap.heap_cursor = expected_cursor;
allocator.ptrs.push(ProcessPtrRecord {
ptr: PPC_HEAP_BASE + 4,
size: 8,
});
allocator.free_ptr_blocks.push(ProcessPtrRecord {
ptr: PPC_HEAP_BASE + 12,
size: 4,
});
allocator.free_handle_blocks.push(ProcessHandleRecord {
handle: PPC_HEAP_BASE + 16,
ptr: PPC_HEAP_BASE + 20,
size: 4,
capacity: 8,
});
});
}
native.with_process_memory_manager(
|_native, memory_manager| {
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.heap_cursor),
Some(expected_cursor)
);
let allocator = memory_manager.native_allocator().unwrap();
assert_eq!(allocator.ptrs.last().map(|record| record.size), Some(8));
assert_eq!(
allocator.free_ptr_blocks.last().map(|record| record.size),
Some(4)
);
assert_eq!(
allocator
.free_handle_blocks
.last()
.map(|record| record.capacity),
Some(8)
);
memory_manager.mutate_native_allocator(|allocator| {
allocator.heap.heap_cursor += 8;
});
let allocation = memory_manager
.native_handle_records()
.iter()
.find(|record| record.handle == handle)
.expect("canonical allocation materialized for native handle");
assert_eq!((allocation.size, allocation.capacity), (24, 40));
let mut state = memory_manager.native_handle_state(handle);
assert!(state.locked);
assert!(state.no_purge);
assert!(state.resource);
state.locked = false;
state.high_locked = false;
state.no_purge = false;
state.resource = false;
memory_manager.set_native_handle_state(state);
},
);
let manager = memory_manager.borrow();
assert_eq!(manager.state_for_handle(handle), Some(0x40));
assert_eq!(
manager
.native_allocator()
.map(|allocator| allocator.heap.heap_cursor),
Some(expected_cursor + 8)
);
assert_eq!(
manager.native_allocation(handle),
native
.handles()
.iter()
.copied()
.find(|record| record.handle == handle)
);
}
#[test]
fn attached_native_memory_manager_survives_panic_without_runner_handoff() {
let pef = synthetic_pef_with_import(b"NewPtr");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle().clone();
let panic_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = 24;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
panic!("simulated panic after a native Memory Manager import");
});
}));
assert!(panic_result.is_err());
let ptr = native.cpu.gpr[3];
assert_ne!(ptr, 0);
assert!(native.process_memory_manager.ptr_eq(&memory_manager));
assert!(memory_manager
.borrow()
.native_allocator()
.unwrap()
.ptrs
.iter()
.any(|record| record.ptr == ptr && record.size == 24));
}
#[test]
fn detached_native_handle_state_remains_independent() {
let handle = PPC_HEAP_BASE + 0x20;
let record = ProcessHandleRecord {
handle,
ptr: PPC_HEAP_BASE + 0x40,
size: 16,
capacity: 16,
};
let stale_state = PpcHandleStateRecord {
handle,
locked: false,
high_locked: false,
no_purge: false,
resource: false,
};
let mut memory_manager = ProcessMemoryManager::default();
memory_manager.register_native_handle_records([(
record,
ppc_process_handle_state_bits(&[stale_state], handle),
)]);
let detached = memory_manager.detached_clone();
memory_manager.lock_process_handle(handle, true);
let state = memory_manager.native_handle_state(handle);
assert!(state.locked);
assert!(state.high_locked);
assert!(!state.no_purge);
assert!(!state.resource);
assert_eq!(detached.state_for_handle(handle), Some(0x40));
assert!(!detached.native_handle_state(handle).high_locked);
}
#[test]
fn resource_disposal_is_immediately_process_owned() {
let pef = synthetic_pef_with_import(b"NewHandle");
let mut native = load_pef_application(&pef).unwrap();
native.cpu.gpr[3] = 24;
run_test_import(
&mut native,
PpcImportDispatcherTarget::NewHandle { clear: false },
);
let handle = native.cpu.gpr[3];
let ptr = native.memory.read_u32_be(handle).unwrap();
let shared_manager = native.process_memory_manager.0.clone();
let mut memory_manager = shared_manager.borrow_mut();
let detached = memory_manager.detached_clone();
let allocator = memory_manager.native_allocator_snapshot().unwrap();
let mut heap_cursor = allocator.heap.heap_cursor;
let heap_limit = allocator.heap.heap_limit;
let mut last_mem_error = allocator.heap.last_mem_error;
let mut handles = memory_manager.native_handle_records().to_vec();
let mut resources = [PpcVfsResourceRecord {
ref_num: 1,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"TEST"),
res_id: 128,
name: b"owned".to_vec(),
data: vec![0; 24],
raw_data: None,
raw_attrs: None,
attrs: 0,
handle,
}];
let mut last_resource_error = PPC_RES_NOT_FOUND_ERR;
native.cpu.gpr[3] = handle;
ppc_release_resource(
&mut native.cpu,
&mut memory_manager,
&mut native.memory,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
&mut resources,
&mut last_resource_error,
);
assert_eq!(last_resource_error, PPC_NO_ERR);
assert_eq!(resources[0].handle, 0);
assert_eq!(native.memory.read_u32_be(handle), Some(0));
assert_eq!(memory_manager.native_allocation(handle), None);
assert_eq!(memory_manager.recover_handle(ptr), None);
assert!(memory_manager
.native_allocator()
.unwrap()
.free_handle_blocks
.iter()
.any(|record| record.handle == handle));
assert!(handles.iter().all(|record| record.handle != handle));
assert_eq!(
detached.native_allocation(handle).map(|record| record.ptr),
Some(ptr)
);
assert_eq!(detached.recover_handle(ptr), Some(handle));
}
#[test]
fn standalone_and_attached_memory_imports_share_process_manager_semantics() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut standalone = load_pef_application(&pef).unwrap();
let mut attached = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
attached.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle().clone();
standalone.cpu.gpr[3] = 24;
attached.cpu.gpr[3] = 24;
run_test_import(
&mut standalone,
PpcImportDispatcherTarget::NewPtr { clear: true },
);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::NewPtr { clear: true },
&memory_manager,
);
let ptr = standalone.cpu.gpr[3];
assert_eq!(attached.cpu.gpr[3], ptr);
assert_eq!(standalone.ptrs(), attached.ptrs());
assert_eq!(standalone.heap_cursor(), attached.heap_cursor());
assert_eq!(
ppc_memory_read_bytes(&mut standalone.memory, ptr, 24),
ppc_memory_read_bytes(&mut attached.memory, ptr, 24),
);
standalone.cpu.gpr[3] = ptr;
attached.cpu.gpr[3] = ptr;
run_test_import(&mut standalone, PpcImportDispatcherTarget::GetPtrSize);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::GetPtrSize,
&memory_manager,
);
assert_eq!(standalone.cpu.gpr[3], 24);
assert_eq!(attached.cpu.gpr[3], 24);
standalone.cpu.gpr[3] = 13;
attached.cpu.gpr[3] = 13;
run_test_import(
&mut standalone,
PpcImportDispatcherTarget::NewHandle { clear: true },
);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::NewHandle { clear: true },
&memory_manager,
);
let handle = standalone.cpu.gpr[3];
assert_eq!(attached.cpu.gpr[3], handle);
assert_eq!(standalone.handles(), attached.handles());
assert_eq!(standalone.heap_cursor(), attached.heap_cursor());
standalone.cpu.gpr[3] = handle;
attached.cpu.gpr[3] = handle;
run_test_import(&mut standalone, PpcImportDispatcherTarget::HLock);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::HLock,
&memory_manager,
);
assert_eq!(standalone.handle_states(), attached.handle_states());
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x80));
standalone.cpu.gpr[3] = handle;
standalone.cpu.gpr[4] = 48;
attached.cpu.gpr[3] = handle;
attached.cpu.gpr[4] = 48;
run_test_import(&mut standalone, PpcImportDispatcherTarget::SetHandleSize);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(standalone.handles(), attached.handles());
assert_eq!(standalone.heap_cursor(), attached.heap_cursor());
assert_eq!(standalone.last_mem_error(), attached.last_mem_error());
standalone.cpu.gpr[3] = handle;
attached.cpu.gpr[3] = handle;
run_test_import(&mut standalone, PpcImportDispatcherTarget::DisposeHandle);
run_test_import_with_process_memory_manager(
&mut attached,
PpcImportDispatcherTarget::DisposeHandle,
&memory_manager,
);
assert_eq!(standalone.handles(), attached.handles());
assert_eq!(
standalone.free_handle_blocks(),
attached.free_handle_blocks()
);
assert_eq!(standalone.memory.read_u32_be(handle), Some(0));
assert_eq!(attached.memory.read_u32_be(handle), Some(0));
}
#[test]
fn standalone_native_runs_retain_the_process_memory_manager() {
let pef = synthetic_pef_with_import(b"NewHandleClear");
let mut native = load_pef_application(&pef).unwrap();
native.cpu.gpr[3] = 24;
run_test_import(
&mut native,
PpcImportDispatcherTarget::NewHandle { clear: true },
);
let handle = native.cpu.gpr[3];
let retained = native.process_memory_manager.0.clone();
assert_eq!(retained.borrow().state_for_handle(handle), Some(0));
retained.borrow_mut().set_state_for_handle(handle, 0xa0);
native.cpu.gpr[3] = handle;
run_test_import(&mut native, PpcImportDispatcherTarget::HGetState);
assert_eq!(native.cpu.gpr[3], 0xa0);
assert!(native.process_memory_manager.0.ptr_eq(&retained));
}
#[test]
fn ppc_handle_state_imports_preserve_process_owned_classic_handles() {
let pef = synthetic_pef_with_import(b"HLock");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let shared = native.memory.shared_view();
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
classic_bus.attach_guest_address_space(shared);
context.attach_classic_memory_bus(&mut classic_bus);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 19)
.unwrap();
classic_bus.write_byte(ptr, 0x5a);
native.memory.add_region(ptr & !0x0fff, vec![0; 0x1000]);
native.memory.write_u32_be(handle, ptr).unwrap();
native.memory.write_u8(ptr, 0x5a).unwrap();
let memory_manager = context.memory_manager_handle();
classic.set_handle_state_bits(handle, 0x40);
let detached = memory_manager.detached_clone();
native.with_process_memory_manager(
|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HGetState;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(native.cpu.gpr[3], 0x40);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetHandleSize;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(native.cpu.gpr[3], 19);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HLock;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HGetState;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(native.cpu.gpr[3], 0xc0);
},
);
assert_eq!(classic.handle_state_bits(handle), Some(0xc0));
assert_eq!(detached.borrow().state_for_handle(handle), Some(0x40));
}
#[test]
fn ppc_empty_handle_releases_a_process_owned_classic_block_atomically() {
let pef = synthetic_pef_with_import(b"EmptyHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x2000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 24)
.unwrap();
classic_bus.write_bytes(ptr, b"classic process handle");
let memory_manager = context.memory_manager_handle().clone();
memory_manager.borrow_mut().set_state_for_handle(handle, 0xc0);
let mut detached = native.clone();
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_PUR_ERR)
);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(ptr));
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(24));
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0xc0));
memory_manager.set_state_for_handle(handle, 0x40);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(0));
assert_eq!(memory_manager.classic_allocation_size(handle), Some(4));
assert_eq!(memory_manager.classic_allocation_size(ptr), None);
assert_eq!(memory_manager.recover_handle(ptr), None);
assert_eq!(memory_manager.state_for_handle(handle), Some(0x40));
});
assert_eq!(classic_bus.read_long(handle), 0);
assert_eq!(classic_bus.get_alloc_size(handle), Some(4));
assert_eq!(classic_bus.get_alloc_size(ptr), None);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(detached_manager.classic_allocation_size(handle), Some(4));
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(24));
assert_eq!(detached_manager.recover_handle(ptr), Some(handle));
assert_eq!(detached_manager.state_for_handle(handle), Some(0xc0));
}
#[test]
fn ppc_dispose_handle_releases_classic_storage_and_preserves_stale_slot_rules() {
let pef = synthetic_pef_with_import(b"DisposeHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x2000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
classic_bus.write_bytes(ptr, b"disposed classic");
let memory_manager = context.memory_manager_handle().clone();
memory_manager.borrow_mut().set_state_for_handle(handle, 0x80);
let mut detached = native.clone();
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(ptr));
assert_eq!(memory_manager.classic_allocation_size(handle), None);
assert_eq!(memory_manager.classic_allocation_size(ptr), None);
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), None);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RecoverHandle;
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], handle);
});
assert_eq!(classic_bus.read_long(handle), ptr);
let reused = context
.memory_manager_mut()
.new_empty_classic_handle(&mut classic_bus)
.unwrap();
assert_eq!(reused, handle);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(memory_manager.recover_handle(ptr), None);
});
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(detached_manager.classic_allocation_size(handle), Some(4));
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(detached_manager.recover_handle(ptr), Some(handle));
assert_eq!(detached_manager.state_for_handle(handle), Some(0x80));
}
#[test]
fn ppc_handle_release_does_not_bypass_classic_resource_manager_ownership() {
let pef = synthetic_pef_with_import(b"DisposeHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x2000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let ptr = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
classic_bus.write_bytes(ptr, b"classic resource");
let handle =
classic.get_or_create_resource_handle(&mut classic_bus, *b"TEST", 128, ptr);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_process_handle_purgeable(handle, false);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x20));
native.with_process_memory_manager(|native, memory_manager| {
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeHandle;
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(ptr));
assert_eq!(memory_manager.classic_allocation_size(handle), Some(4));
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0x20));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::EmptyHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NIL_HANDLE_ERR)
);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(ptr));
assert_eq!(memory_manager.classic_allocation_size(handle), Some(4));
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0x20));
});
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.read_bytes(ptr, 16), b"classic resource");
let mut classic_cpu = crate::trap::test_helpers::MockCpu::new();
classic_cpu.write_reg(Register::A7, TEST_SP);
classic_bus.write_long(TEST_SP, handle);
assert!(classic
.dispatch_toolbox(true, 0x1ad, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_cpu.read_reg(Register::A7), TEST_SP + 4);
assert_eq!(classic_bus.read_word(0x0a60), 0);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0));
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(memory_manager.classic_allocation_size(handle), None);
assert_eq!(memory_manager.classic_allocation_size(ptr), None);
assert_eq!(memory_manager.state_for_handle(handle), None);
});
}
#[test]
fn ppc_dispose_handle_does_not_claim_an_external_pef_master_pointer() {
let pef = synthetic_pef_with_loader_and_data(
synthetic_loader(b"InterfaceLib", b"DisposeHandle"),
&[0; 0x80],
);
let mut native = load_pef_application(&pef).unwrap();
let handle = PPC_DATA_BASE + 0x40;
let before = ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80).unwrap();
native.with_process_memory_manager(|native, memory_manager| {
let ptr = memory_manager.new_native_ptr(&mut native.memory, 32, true);
assert_ne!(ptr, 0);
PpcMemory::write_u32_be(&mut native.memory, handle, ptr).unwrap();
let heap_cursor = memory_manager.native_heap_state().unwrap().heap_cursor;
memory_manager.publish_external_native_resource_handle(handle, ptr, heap_cursor);
let expected =
ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80).unwrap();
native.cpu.gpr[3] = handle;
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80),
Some(expected.clone())
);
assert!(memory_manager
.native_allocator()
.unwrap()
.ptrs
.iter()
.any(|record| record.ptr == ptr && record.size == 32));
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0x60));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::EmptyHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NIL_HANDLE_ERR)
);
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80),
Some(expected)
);
assert_eq!(memory_manager.recover_handle(ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0x60));
});
let after = ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80).unwrap();
assert_ne!(after, before);
assert_eq!(&after[..0x40], &before[..0x40]);
assert_eq!(&after[0x44..], &before[0x44..]);
}
#[test]
fn ppc_pointer_imports_observe_process_owned_classic_allocations() {
let pef = synthetic_pef_with_import(b"GetPtrSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let ptr = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 37);
assert_ne!(ptr, 0);
classic_bus.fill_bytes(ptr, 37, 0x5a);
assert_eq!(
context
.memory_manager_mut()
.set_process_ptr_size(&mut classic_bus, ptr, 36),
0
);
assert_eq!(classic_bus.read_byte(ptr + 36), 0);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = ptr;
let probe = native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(native.cpu.gpr[3], 36);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposePtr;
native.cpu.gpr[3] = ptr;
let probe = native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(memory_manager.classic_allocation_size(ptr), None);
});
assert_eq!(classic_bus.get_alloc_size(ptr), None);
}
#[test]
fn ppc_set_handle_size_resizes_process_owned_classic_handle_across_isa() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let original = (0x10..=0x1f).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &original);
let neighbor = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
classic_bus.fill_bytes(neighbor, 16, 0xa5);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_state_for_handle(handle, 0x40);
let mut detached = native.clone();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 8;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], handle);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(8));
assert_eq!(
classic_bus.read_bytes(ptr, 16),
[original[..8].to_vec(), vec![0; 8]].concat()
);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x40));
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 12;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(12));
assert_eq!(
classic_bus.read_bytes(ptr, 12),
[original[..8].to_vec(), vec![0; 4]].concat()
);
classic_bus.write_bytes(ptr + 8, &[0x81, 0x82, 0x83, 0x84]);
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 48;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
let moved_ptr = classic_bus.read_long(handle);
assert_ne!(moved_ptr, ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), None);
assert_eq!(classic_bus.get_alloc_size(moved_ptr), Some(48));
assert_eq!(
classic_bus.read_bytes(moved_ptr, 12),
[original[..8].to_vec(), vec![0x81, 0x82, 0x83, 0x84]].concat()
);
assert_eq!(classic_bus.read_bytes(neighbor, 16), vec![0xa5; 16]);
assert_eq!(
PpcMemory::read_u32_be(&mut native.memory, handle),
Some(moved_ptr)
);
assert_eq!(
memory_manager.borrow().classic_allocation_size(moved_ptr),
Some(48)
);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), None);
assert_eq!(
memory_manager.borrow().handle_for_ptr(moved_ptr),
Some(handle)
);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x40));
assert_eq!(
classic_bus.read_bytes(moved_ptr, 12),
ppc_memory_read_bytes(&mut native.memory, moved_ptr, 12).unwrap()
);
native.cpu.gpr[3] = ptr;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::RecoverHandle,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], 0);
native.cpu.gpr[3] = moved_ptr;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::RecoverHandle,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], handle);
native.cpu.gpr[3] = handle;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::GetHandleSize,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], 48);
assert_eq!(
classic_bus.read_bytes(moved_ptr, 12),
ppc_memory_read_bytes(&mut native.memory, moved_ptr, 12).unwrap()
);
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(detached_manager.classic_allocation_size(handle), Some(4));
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(detached_manager.classic_allocation_size(moved_ptr), None);
assert_eq!(detached_manager.handle_for_ptr(ptr), Some(handle));
assert_eq!(detached_manager.handle_for_ptr(moved_ptr), None);
assert_eq!(detached_manager.state_for_handle(handle), Some(0x40));
assert_eq!(
ppc_memory_read_bytes(&mut detached.memory, ptr, 16),
Some(original)
);
}
#[test]
fn ppc_set_handle_size_keeps_zero_size_empty_classic_handle_empty() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let handle = context
.memory_manager_mut()
.new_empty_classic_handle(&mut classic_bus)
.unwrap();
let memory_manager = context.memory_manager_handle().clone();
let cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 0;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(classic_bus.read_long(handle), 0);
assert_eq!(classic_bus.get_alloc_size(handle), Some(4));
assert_eq!(context.classic_heap_bump_ptr(), cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(0), None);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
}
#[test]
fn ppc_set_handle_size_preserves_classic_state_on_atomic_failure() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 3 * 1024 * 1024, 0x4000);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let payload = (0xa0..=0xaf).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &payload);
let neighbor = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
classic_bus.fill_bytes(neighbor, 16, 0x5a);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_state_for_handle(handle, 0x40);
let mut detached = native.clone();
let handle_bytes = classic_bus.read_bytes(handle, 4);
let cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 0x0010_0000;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_FULL_ERR)
);
assert_eq!(classic_bus.read_bytes(handle, 4), handle_bytes);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(handle), Some(4));
assert_eq!(classic_bus.get_alloc_size(ptr), Some(16));
assert_eq!(classic_bus.read_bytes(ptr, 16), payload);
assert_eq!(classic_bus.read_bytes(neighbor, 16), vec![0x5a; 16]);
assert_eq!(context.classic_heap_bump_ptr(), cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().handle_for_ptr(neighbor), None);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x40));
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(
ppc_memory_read_bytes(&mut detached.memory, ptr, 16),
Some((0xa0..=0xaf).collect::<Vec<_>>())
);
}
#[test]
fn ppc_set_handle_size_rejects_a_guest_mutated_classic_master_pointer() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let payload = (0xb0..=0xbf).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &payload);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_state_for_handle(handle, 0x40);
let mut detached = native.clone();
let invalid_ptr = 0xdead_beefu32;
classic_bus.write_long(handle, invalid_ptr);
let cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 48;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_WZ_ERR)
);
assert_eq!(classic_bus.read_long(handle), invalid_ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(16));
assert_eq!(classic_bus.read_bytes(ptr, 16), payload);
assert_eq!(context.classic_heap_bump_ptr(), cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x40));
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(detached_manager.handle_for_ptr(ptr), Some(handle));
}
#[test]
fn ppc_set_handle_size_rejects_another_classic_handles_data_block() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let (other_handle, other_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 24)
.unwrap();
let original = (0x20..=0x2f).collect::<Vec<_>>();
let other = (0x80..=0x97).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &original);
classic_bus.write_bytes(other_ptr, &other);
classic_bus.write_long(handle, other_ptr);
let memory_manager = context.memory_manager_handle().clone();
let cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 48;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_WZ_ERR)
);
assert_eq!(classic_bus.read_long(handle), other_ptr);
assert_eq!(classic_bus.read_long(other_handle), other_ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(16));
assert_eq!(classic_bus.get_alloc_size(other_ptr), Some(24));
assert_eq!(classic_bus.read_bytes(ptr, 16), original);
assert_eq!(classic_bus.read_bytes(other_ptr, 24), other);
assert_eq!(context.classic_heap_bump_ptr(), cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(
memory_manager.borrow().handle_for_ptr(other_ptr),
Some(other_handle)
);
}
#[test]
fn ppc_set_handle_size_rejects_locked_classic_relocation_without_mutation() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let payload = (0xc0..=0xcf).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &payload);
let neighbor = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
classic_bus.fill_bytes(neighbor, 16, 0x6b);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_state_for_handle(handle, 0x80);
let mut detached = native.clone();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 8;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(8));
assert_eq!(
classic_bus.read_bytes(ptr, 16),
[payload[..8].to_vec(), vec![0; 8]].concat()
);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x80));
let before_handle = classic_bus.read_bytes(handle, 4);
let before_data = classic_bus.read_bytes(ptr, 16);
let before_cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 48;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_FULL_ERR)
);
assert_eq!(classic_bus.read_bytes(handle, 4), before_handle);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(8));
assert_eq!(classic_bus.read_bytes(ptr, 16), before_data);
assert_eq!(classic_bus.read_bytes(neighbor, 16), vec![0x6b; 16]);
assert_eq!(context.classic_heap_bump_ptr(), before_cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x80));
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(detached_manager.state_for_handle(handle), Some(0x80));
}
#[test]
fn ppc_set_handle_size_does_not_bypass_classic_resource_ownership() {
let pef = synthetic_pef_with_import(b"SetHandleSize");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let ptr = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
let payload = (0xd0..=0xdf).collect::<Vec<_>>();
classic_bus.write_bytes(ptr, &payload);
let handle = classic.get_or_create_resource_handle(&mut classic_bus, *b"TEST", 128, ptr);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_process_handle_purgeable(handle, false);
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x20));
let mut detached = native.clone();
let before_handle = classic_bus.read_bytes(handle, 4);
let before_cursor = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 48;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NIL_HANDLE_ERR)
);
assert_eq!(classic_bus.read_bytes(handle, 4), before_handle);
assert_eq!(classic_bus.read_long(handle), ptr);
assert_eq!(classic_bus.get_alloc_size(handle), Some(4));
assert_eq!(classic_bus.get_alloc_size(ptr), Some(16));
assert_eq!(classic_bus.read_bytes(ptr, 16), payload);
assert_eq!(context.classic_heap_bump_ptr(), before_cursor);
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x20));
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(detached_manager.classic_allocation_size(ptr), Some(16));
assert_eq!(detached_manager.state_for_handle(handle), Some(0x20));
}
#[test]
fn ppc_set_handle_size_does_not_claim_an_external_pef_master_pointer() {
let pef = synthetic_pef_with_loader_and_data(
synthetic_loader(b"InterfaceLib", b"SetHandleSize"),
&[0; 0x80],
);
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
classic_bus.attach_guest_address_space(native.memory.shared_view());
let handle = PPC_DATA_BASE + 0x40;
let memory_manager = context.memory_manager_handle().clone();
let ptr = native.with_process_memory_manager(|native, memory_manager| {
let ptr = memory_manager.new_native_ptr(&mut native.memory, 32, true);
assert_ne!(ptr, 0);
native
.memory
.write_bytes(ptr, b"external PEF payload")
.unwrap();
PpcMemory::write_u32_be(&mut native.memory, handle, ptr).unwrap();
let heap_cursor = memory_manager.native_heap_state().unwrap().heap_cursor;
memory_manager.publish_external_native_resource_handle(handle, ptr, heap_cursor);
ptr
});
let mut detached = native.clone();
let before_handle = PpcMemory::read_u32_be(&mut native.memory, handle);
let expected_pef = ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80).unwrap();
let detached_pef =
ppc_memory_read_bytes(&mut detached.memory, PPC_DATA_BASE, 0x80).unwrap();
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 64;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::SetHandleSize,
&memory_manager,
);
assert_eq!(
memory_manager
.borrow()
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NIL_HANDLE_ERR)
);
assert_eq!(
PpcMemory::read_u32_be(&mut native.memory, handle),
before_handle
);
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, PPC_DATA_BASE, 0x80),
Some(expected_pef)
);
assert_eq!(memory_manager.borrow().native_allocation(handle), None);
assert!(memory_manager
.borrow()
.native_ptr_records()
.iter()
.any(|record| record.ptr == ptr && record.size == 32));
assert_eq!(memory_manager.borrow().handle_for_ptr(ptr), Some(handle));
assert_eq!(memory_manager.borrow().state_for_handle(handle), Some(0x60));
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, ptr, b"external PEF payload".len() as u32),
Some(b"external PEF payload".to_vec())
);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
assert_eq!(
ppc_memory_read_bytes(&mut detached.memory, PPC_DATA_BASE, 0x80),
Some(detached_pef)
);
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(detached_manager.native_allocation(handle), None);
assert!(detached_manager
.native_ptr_records()
.iter()
.any(|record| record.ptr == ptr && record.size == 32));
assert_eq!(
ppc_memory_read_bytes(
&mut detached.memory,
ptr,
b"external PEF payload".len() as u32,
),
Some(b"external PEF payload".to_vec())
);
}
#[test]
fn ppc_set_ptr_size_mutates_a_classic_pointer_without_moving_it() {
let pef = synthetic_pef_with_import(b"SetPtrSize");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x1000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let original = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 64);
classic_bus.fill_bytes(original, 64, 0x6a);
context
.memory_manager_mut()
.dispose_process_ptr(&mut classic_bus, original);
let ptr = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
assert_eq!(ptr, original);
classic_bus.fill_bytes(ptr, 16, 0x5a);
let neighbor = context
.memory_manager_mut()
.new_classic_ptr(&mut classic_bus, 16);
classic_bus.fill_bytes(neighbor, 16, 0xa5);
let cursor = context.classic_heap_bump_ptr();
let mut detached = native.clone();
context
.memory_manager_mut()
.set_native_mem_error(PPC_PARAM_ERR);
assert_eq!(
context
.memory_manager_mut()
.set_process_ptr_size(&mut classic_bus, ptr, 12),
PPC_NO_ERR
);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::MemError;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
});
assert_eq!(
context
.memory_manager_mut()
.set_process_ptr_size(&mut classic_bus, ptr, 65),
PPC_MEM_FULL_ERR
);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::MemError;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_MEM_FULL_ERR));
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetPtrSize;
});
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = ptr;
native.cpu.gpr[4] = 8;
let probe = native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(native.cpu.gpr[3], ptr);
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(8));
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::MemError;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetPtrSize;
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = ptr;
native.cpu.gpr[4] = 48;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ptr);
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(48));
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
let bytes_before_failure = ppc_memory_read_bytes(&mut native.memory, ptr, 64).unwrap();
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = ptr;
native.cpu.gpr[4] = 65;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ptr);
assert_eq!(memory_manager.classic_allocation_size(ptr), Some(48));
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_MEM_FULL_ERR)
);
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, ptr, 64),
Some(bytes_before_failure)
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::MemError;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_MEM_FULL_ERR));
});
assert_eq!(context.classic_heap_bump_ptr(), cursor);
assert_eq!(classic_bus.get_alloc_size(ptr), Some(48));
assert_eq!(classic_bus.read_bytes(ptr, 8), vec![0x5a; 8]);
assert_eq!(classic_bus.read_bytes(ptr + 8, 8), vec![0; 8]);
assert_eq!(classic_bus.read_bytes(neighbor, 16), vec![0xa5; 16]);
assert_eq!(
detached
.process_memory_manager
.0
.borrow()
.classic_allocation_size(ptr),
Some(16)
);
assert_eq!(
ppc_memory_read_bytes(&mut detached.memory, ptr, 16),
Some(vec![0x5a; 16])
);
}
#[test]
fn attaching_and_cloning_native_adapters_preserves_process_ownership() {
let pef = synthetic_pef_with_import(b"NewHandleClear");
let mut native = load_pef_application(&pef).unwrap();
let standalone_memory_manager = native.process_memory_manager.0.clone();
native.cpu.gpr[3] = 24;
run_test_import(
&mut native,
PpcImportDispatcherTarget::NewHandle { clear: true },
);
let handle = native.cpu.gpr[3];
let mut detached = native.clone();
assert!(!detached
.process_memory_manager
.0
.ptr_eq(&native.process_memory_manager.0));
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let process_memory_manager = context.memory_manager_handle().clone();
assert!(native
.process_memory_manager
.ptr_eq(&process_memory_manager));
assert!(!standalone_memory_manager.borrow().has_native_allocator());
assert!(standalone_memory_manager
.borrow()
.native_handle_records()
.is_empty());
let attached_heap = process_memory_manager.borrow().native_heap_state().unwrap();
let expected_free = ppc_heap_free_capacity(
&mut native.memory,
attached_heap.heap_cursor,
attached_heap.heap_limit,
)
.0;
assert_eq!(
native.memory.read_u32_be(PPC_APPLICATION_ZONE + 12),
Some(expected_free)
);
assert_eq!(
native.memory.read_u32_be(PPC_SYSTEM_ZONE + 12),
Some(expected_free)
);
let detached_heap_cursor = detached.heap_cursor();
let detached_handle_record = detached.handles()[0];
let attached_heap_cursor = native.heap_cursor() + 0x80;
let attached_heap_limit = native.heap_limit() - 0x1000;
process_memory_manager
.borrow_mut()
.set_native_handle_state(PpcHandleStateRecord {
handle,
locked: true,
high_locked: true,
no_purge: true,
resource: true,
});
process_memory_manager
.borrow_mut()
.mutate_native_allocator(|allocator| {
allocator.heap.heap_cursor = attached_heap_cursor;
allocator.heap.heap_limit = attached_heap_limit;
allocator.heap.last_mem_error = PPC_PARAM_ERR;
allocator.heap.heap_maximized = true;
allocator.heap.master_pointer_blocks_requested = 7;
allocator.ptrs.push(ProcessPtrRecord {
ptr: PPC_HEAP_BASE + 0x100,
size: 16,
});
allocator.free_ptr_blocks.push(ProcessPtrRecord {
ptr: PPC_HEAP_BASE + 0x200,
size: 32,
});
allocator.free_handle_blocks.push(ProcessHandleRecord {
handle: PPC_HEAP_BASE + 0x300,
ptr: PPC_HEAP_BASE + 0x400,
size: 24,
capacity: 48,
});
});
let mut attached_handle_record = process_memory_manager
.borrow()
.native_allocation(handle)
.unwrap();
attached_handle_record.size = 20;
process_memory_manager
.borrow_mut()
.set_native_allocation(attached_handle_record);
assert!(native.heap_maximized());
assert_eq!(native.heap_cursor(), attached_heap_cursor);
assert_eq!(native.heap_limit(), attached_heap_limit);
assert_eq!(native.last_mem_error(), PPC_PARAM_ERR);
assert_eq!(native.master_pointer_blocks_requested(), 7);
assert!(!detached.heap_maximized());
assert_eq!(detached.heap_cursor(), detached_heap_cursor);
assert_eq!(detached.heap_limit(), detached.stack_base);
assert_eq!(detached.last_mem_error(), PPC_NO_ERR);
assert_eq!(detached.master_pointer_blocks_requested(), 0);
assert_eq!(native.ptrs().last().map(|record| record.size), Some(16));
assert_eq!(
native.free_ptr_blocks().last().map(|record| record.size),
Some(32)
);
assert!(detached.ptrs().is_empty());
assert!(detached.free_ptr_blocks().is_empty());
assert_eq!(
native
.free_handle_blocks()
.last()
.map(|record| record.capacity),
Some(48)
);
assert!(detached.free_handle_blocks().is_empty());
assert!(native.handle_states()[0].high_locked);
assert!(!detached.handle_states()[0].high_locked);
assert_eq!(native.handles()[0], attached_handle_record);
assert_eq!(detached.handles()[0], detached_handle_record);
native.cpu.gpr[3] = handle;
run_test_import(&mut native, PpcImportDispatcherTarget::HGetState);
assert_eq!(native.cpu.gpr[3], 0xa0);
assert_eq!(
detached
.process_memory_manager
.0
.borrow()
.state_for_handle(handle),
Some(0)
);
detached.cpu.gpr[3] = handle;
run_test_import(&mut detached, PpcImportDispatcherTarget::HGetState);
assert_eq!(detached.cpu.gpr[3], 0);
}
#[test]
fn attaching_a_pristine_native_adapter_retains_the_populated_process_allocator() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut owner = load_pef_application(&pef).unwrap();
owner.cpu.gpr[3] = 24;
run_test_import(
&mut owner,
PpcImportDispatcherTarget::NewPtr { clear: true },
);
let ptr = owner.cpu.gpr[3];
let mut context = ProcessContext::default();
owner.attach_unconverted_process_services(&mut context);
let canonical = context.memory_manager_handle().clone();
let canonical_allocator = canonical.borrow().native_allocator_snapshot();
let mut observer = load_pef_application(&pef).unwrap();
let standalone = observer.process_memory_manager.0.clone();
observer.attach_unconverted_process_services(&mut context);
assert!(observer.process_memory_manager.ptr_eq(&canonical));
assert_eq!(canonical.borrow().native_allocator_snapshot(), canonical_allocator);
assert_eq!(canonical.borrow_mut().native_ptr_size(ptr), 24);
assert!(!standalone.borrow().has_native_allocator());
let heap = canonical.borrow().native_heap_state().unwrap();
let expected_free =
ppc_heap_free_capacity(&mut observer.memory, heap.heap_cursor, heap.heap_limit).0;
assert_eq!(
observer.memory.read_u32_be(PPC_APPLICATION_ZONE + 12),
Some(expected_free)
);
assert_eq!(
observer.memory.read_u32_be(PPC_SYSTEM_ZONE + 12),
Some(expected_free)
);
}
#[test]
fn attaching_two_populated_native_adapters_is_atomic() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut owner = load_pef_application(&pef).unwrap();
owner.cpu.gpr[3] = 24;
run_test_import(
&mut owner,
PpcImportDispatcherTarget::NewPtr { clear: true },
);
let mut context = ProcessContext::default();
owner.attach_unconverted_process_services(&mut context);
let canonical = context.memory_manager_handle().clone();
let mut rejected = load_pef_application(&pef).unwrap();
rejected.cpu.gpr[3] = 48;
run_test_import(
&mut rejected,
PpcImportDispatcherTarget::NewPtr { clear: true },
);
let standalone = rejected.process_memory_manager.0.clone();
let canonical_allocator = canonical.borrow().native_allocator_snapshot();
let standalone_allocator = standalone.borrow().native_allocator_snapshot();
let application_zone = rejected.memory.read_u32_be(PPC_APPLICATION_ZONE + 12);
let system_zone = rejected.memory.read_u32_be(PPC_SYSTEM_ZONE + 12);
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
rejected.attach_unconverted_process_services(&mut context);
}));
assert!(result.is_err());
assert!(!rejected.process_memory_manager.ptr_eq(&canonical));
assert_eq!(canonical.borrow().native_allocator_snapshot(), canonical_allocator);
assert_eq!(standalone.borrow().native_allocator_snapshot(), standalone_allocator);
assert_eq!(
rejected.memory.read_u32_be(PPC_APPLICATION_ZONE + 12),
application_zone
);
assert_eq!(
rejected.memory.read_u32_be(PPC_SYSTEM_ZONE + 12),
system_zone
);
}
#[test]
fn ppc_ptr_imports_mutate_the_process_memory_manager_immediately() {
let pef = synthetic_pef_with_import(b"NewPtrClear");
let mut native = load_pef_application(&pef).unwrap();
native.cpu.gpr[3] = 24;
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(
|native, memory_manager| {
let prior_ptr = memory_manager.new_native_ptr(&mut native.memory, 24, false);
assert_eq!(prior_ptr, PPC_HEAP_BASE);
let probe =
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(probe.handled_import_count, 1);
let ptr = native.cpu.gpr[3];
assert_eq!(ptr, PPC_HEAP_BASE + ppc_allocation_size(24).unwrap());
assert_eq!(
memory_manager
.native_allocator()
.and_then(|allocator| allocator.ptrs.last())
.copied(),
Some(ProcessPtrRecord { ptr, size: 24 })
);
assert_eq!(
memory_manager
.native_allocator()
.and_then(|allocator| allocator.ptrs.first())
.copied(),
Some(ProcessPtrRecord {
ptr: prior_ptr,
size: 24,
})
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetPtrSize;
native.cpu.gpr[3] = ptr;
native.cpu.gpr[4] = 40;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(
memory_manager
.native_allocator()
.and_then(|allocator| allocator.ptrs.last())
.copied(),
Some(ProcessPtrRecord { ptr, size: 40 })
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetPtrSize;
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 40);
assert_eq!(
memory_manager
.native_allocator()
.map(|allocator| allocator.heap.last_mem_error),
Some(PPC_NO_ERR)
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposePtr;
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
let allocator = memory_manager.native_allocator().unwrap();
assert_eq!(
allocator.ptrs,
vec![ProcessPtrRecord {
ptr: prior_ptr,
size: 24,
}]
);
assert_eq!(
allocator.free_ptr_blocks,
vec![ProcessPtrRecord { ptr, size: 40 }]
);
},
);
}
#[test]
fn ppc_handle_imports_mutate_the_process_memory_manager_immediately() {
let pef = synthetic_pef_with_import(b"NewHandleClear");
let mut native = load_pef_application(&pef).unwrap();
native.cpu.gpr[3] = 24;
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_dispatcher = TrapDispatcher::new();
classic_dispatcher.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(
|native, memory_manager| {
native.run_with_process_memory_manager(64, false, false, memory_manager);
let handle = native.cpu.gpr[3];
let original = memory_manager.native_allocation(handle).unwrap();
let detached_memory_manager = memory_manager.detached_clone();
assert_eq!(original.size, 24);
assert_eq!(classic_dispatcher.handle_state_bits(handle), Some(0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RecoverHandle;
native.cpu.gpr[3] = original.ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], handle);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HLock;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(memory_manager.handle_state(handle), 0x80);
assert_eq!(classic_dispatcher.handle_state_bits(handle), Some(0x80));
assert_eq!(detached_memory_manager.state_for_handle(handle), Some(0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HLockHi;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert!(memory_manager.native_handle_state(handle).high_locked);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HNoPurge;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(memory_manager.handle_state(handle), 0x80);
assert_eq!(classic_dispatcher.handle_state_bits(handle), Some(0x80));
memory_manager.set_state_for_handle(handle, 0xa0);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HGetState;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0xa0);
assert!(
(0..32).all(|offset| native.memory.read_u8(original.ptr + offset) == Some(0))
);
native
.memory
.write_bytes(original.ptr, b"process-owned")
.unwrap();
let blocking_ptr = memory_manager.new_native_ptr(&mut native.memory, 16, false);
assert_ne!(blocking_ptr, 0);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetHandleSize;
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = 64;
native.run_with_process_memory_manager(64, false, false, memory_manager);
let grown = memory_manager.native_allocation(handle).unwrap();
assert_ne!(grown.ptr, original.ptr);
assert_eq!((grown.size, grown.capacity), (64, 64));
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, grown.ptr, 13),
Some(b"process-owned".to_vec())
);
assert_eq!(native.memory.read_u32_be(handle), Some(grown.ptr));
assert_eq!(
memory_manager
.native_handle_records()
.iter()
.find(|record| record.handle == handle)
.copied(),
Some(grown)
);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RecoverHandle;
native.cpu.gpr[3] = original.ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = grown.ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], handle);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetHandleSize;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 64);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::EmptyHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(-112)
);
assert_eq!(native.memory.read_u32_be(handle), Some(grown.ptr));
assert_eq!(memory_manager.native_allocation(handle), Some(grown));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HUnlock;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(memory_manager.state_for_handle(handle), Some(0x20));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::EmptyHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(
memory_manager
.native_heap_state()
.map(|heap| heap.last_mem_error),
Some(PPC_NO_ERR)
);
assert_eq!(native.memory.read_u32_be(handle), Some(0));
assert_eq!(
memory_manager.native_allocation(handle),
Some(ProcessHandleRecord {
handle,
ptr: 0,
size: 0,
capacity: 0,
})
);
assert_eq!(memory_manager.recover_handle(grown.ptr), None);
assert!(memory_manager
.native_allocator()
.unwrap()
.free_ptr_blocks
.iter()
.any(|record| record.ptr == grown.ptr && record.size == grown.capacity));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(memory_manager.native_allocation(handle), None);
assert_eq!(native.memory.read_u32_be(handle), Some(0));
assert!(!memory_manager
.native_handle_records()
.iter()
.any(|record| record.handle == handle));
assert!(memory_manager
.native_allocator()
.unwrap()
.free_handle_blocks
.iter()
.any(|record| record.handle == handle && record.ptr == 0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RecoverHandle;
native.cpu.gpr[3] = grown.ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target =
PpcImportDispatcherTarget::NewHandle { clear: true };
native.cpu.gpr[3] = 32;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], handle);
let reused = memory_manager.native_allocation(handle).unwrap();
assert_ne!(reused.ptr, 0);
assert_eq!((reused.size, reused.capacity), (32, 32));
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, reused.ptr, 32),
Some(vec![0; 32])
);
assert!(!memory_manager
.native_allocator()
.unwrap()
.free_handle_blocks
.iter()
.any(|record| record.handle == handle));
},
);
}
#[test]
fn ppc_resource_imports_mutate_process_handle_state_across_isa() {
let pef = synthetic_pef_with_import(b"NewHandleClear");
let mut native = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let name_ptr = scratch;
native.memory.add_region(scratch, vec![0; 0x40]);
write_ppc_pstring(&mut native.memory, name_ptr, b"Shared");
native.set_current_resource_refnum(PPC_FIRST_FILE_REF_NUM);
native.cpu.gpr[3] = 16;
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic = TrapDispatcher::new();
classic.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(|native, memory_manager| {
native.run_with_process_memory_manager(64, false, false, memory_manager);
let handle = native.cpu.gpr[3];
assert_ne!(handle, 0);
memory_manager.set_state_for_handle(handle, 0xc0);
let detached = memory_manager.detached_clone();
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::AddResource;
native.cpu.gpr[3] = handle;
native.cpu.gpr[4] = u32::from_be_bytes(*b"TEST");
native.cpu.gpr[5] = 128;
native.cpu.gpr[6] = 0xdead_beef;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.test_resource_error(), PPC_ADD_RES_FAILED);
assert_eq!(memory_manager.handle_state(handle), 0xc0);
assert_eq!(classic.handle_state_bits(handle), Some(0xc0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[6] = name_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.test_resource_error(), PPC_NO_ERR);
assert_eq!(memory_manager.handle_state(handle), 0xe0);
assert_eq!(classic.handle_state_bits(handle), Some(0xe0));
assert_eq!(detached.state_for_handle(handle), Some(0xc0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target =
PpcImportDispatcherTarget::NewHandle { clear: true };
native.cpu.gpr[3] = 8;
native.run_with_process_memory_manager(64, false, false, memory_manager);
let replacement = native.cpu.gpr[3];
memory_manager.set_state_for_handle(replacement, 0x80);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::AddResource;
native.cpu.gpr[3] = replacement;
native.cpu.gpr[4] = u32::from_be_bytes(*b"TEST");
native.cpu.gpr[5] = 128;
native.cpu.gpr[6] = name_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.test_resource_error(), PPC_NO_ERR);
assert_eq!(memory_manager.handle_state(handle), 0xc0);
assert_eq!(classic.handle_state_bits(handle), Some(0xc0));
assert_eq!(memory_manager.handle_state(replacement), 0xa0);
assert_eq!(classic.handle_state_bits(replacement), Some(0xa0));
assert_eq!(detached.state_for_handle(replacement), None);
native.set_current_resource_refnum(PPC_FIRST_FILE_REF_NUM + 1);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RemoveResource;
native.cpu.gpr[3] = replacement;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.test_resource_error(), PPC_RMV_RES_FAILED);
assert_eq!(memory_manager.handle_state(replacement), 0xa0);
assert_eq!(classic.handle_state_bits(replacement), Some(0xa0));
native.set_current_resource_refnum(PPC_FIRST_FILE_REF_NUM);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.test_resource_error(), PPC_NO_ERR);
assert_eq!(memory_manager.handle_state(handle), 0xc0);
assert_eq!(classic.handle_state_bits(handle), Some(0xc0));
assert_eq!(memory_manager.handle_state(replacement), 0x80);
assert_eq!(classic.handle_state_bits(replacement), Some(0x80));
assert_eq!(detached.state_for_handle(handle), Some(0xc0));
assert!(native.process_file_system.vfs_resources.is_empty());
});
}
#[test]
fn ppc_recover_handle_validates_reused_classic_master_pointer_slots() {
let pef = synthetic_pef_with_import(b"RecoverHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x4000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let (old_handle, old_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let mut detached = native.clone();
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = old_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], old_handle);
});
context
.memory_manager_mut()
.dispose_classic_handle(&mut classic_bus, old_handle, true);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = old_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], old_handle);
});
let (new_handle, new_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 32)
.unwrap();
assert_eq!(new_handle, old_handle);
assert_ne!(new_ptr, old_ptr);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = old_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(memory_manager.recover_handle(old_ptr), None);
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.cpu.gpr[3] = new_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], new_handle);
});
assert_eq!(
detached
.process_memory_manager
.0
.borrow()
.recover_handle(old_ptr),
Some(old_handle)
);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, old_handle),
Some(old_ptr)
);
}
#[test]
fn ppc_recover_handle_rejects_a_guest_mutated_classic_master_pointer_slot() {
let pef = synthetic_pef_with_import(b"RecoverHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x4000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let (handle, ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let mut detached = native.clone();
classic_bus.write_long(handle, ptr + 4);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(memory_manager.recover_handle(ptr), None);
});
assert_eq!(
detached
.process_memory_manager
.0
.borrow()
.recover_handle(ptr),
Some(handle)
);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
}
#[test]
fn ppc_recover_handle_rejects_a_reused_nil_classic_master_pointer_slot() {
let pef = synthetic_pef_with_import(b"RecoverHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus = MacMemoryBus::new(8 * 1024 * 1024);
context.attach_classic_memory_bus(&mut classic_bus);
let classic_heap = classic_bus
.shared_ram_region(0x0020_0000, 0x4000)
.expect("classic adapter owns its heap range");
context.attach_memory(0x0020_0000, classic_heap, &mut native.memory);
let (old_handle, old_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
context
.memory_manager_mut()
.dispose_classic_handle(&mut classic_bus, old_handle, true);
let empty_handle = context
.memory_manager_mut()
.new_empty_classic_handle(&mut classic_bus)
.unwrap();
assert_eq!(empty_handle, old_handle);
assert_eq!(classic_bus.read_long(empty_handle), 0);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = old_ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(memory_manager.recover_handle(old_ptr), None);
});
}
#[test]
fn ppc_recover_handle_rejects_a_guest_mutated_native_master_pointer_slot() {
let pef = synthetic_pef_with_import(b"RecoverHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let (handle, ptr) = native.with_process_memory_manager(|native, memory_manager| {
let handle = memory_manager.new_native_handle(&mut native.memory, 24, true);
let ptr = PpcMemory::read_u32_be(&mut native.memory, handle).unwrap();
(handle, ptr)
});
let mut detached = native.clone();
PpcMemory::write_u32_be(&mut native.memory, handle, 0).unwrap();
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
assert_eq!(memory_manager.recover_handle(ptr), None);
});
assert_eq!(
detached
.process_memory_manager
.0
.borrow()
.recover_handle(ptr),
Some(handle)
);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle),
Some(ptr)
);
}
#[test]
fn ppc_recover_handle_rejects_a_directly_disposed_native_handle() {
let pef = synthetic_pef_with_import(b"NewHandle");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(|native, memory_manager| {
native.cpu.gpr[3] = 24;
native.run_with_process_memory_manager(64, false, false, memory_manager);
let handle = native.cpu.gpr[3];
let record = memory_manager.native_allocation(handle).unwrap();
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::DisposeHandle;
native.cpu.gpr[3] = handle;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(PpcMemory::read_u32_be(&mut native.memory, handle), Some(0));
assert_eq!(memory_manager.native_allocation(handle), None);
assert_eq!(memory_manager.recover_handle(record.ptr), None);
assert!(memory_manager
.native_allocator()
.unwrap()
.free_handle_blocks
.contains(&record));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::RecoverHandle;
native.cpu.gpr[3] = record.ptr;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
});
}
#[test]
fn resource_fork_materialization_preserves_live_edits_and_other_paths() {
let fork = serialize_resource_fork(&[
ResourceForkEntry {
res_type: *b"TEST",
id: 1,
name: vec![],
data: b"raw".to_vec(),
attrs: 0,
},
ResourceForkEntry {
res_type: *b"TEST",
id: 2,
name: vec![],
data: b"second".to_vec(),
attrs: 0,
},
ResourceForkEntry {
res_type: *b"DATA",
id: 1,
name: vec![],
data: b"data".to_vec(),
attrs: 0,
},
])
.unwrap();
let files = [PpcVfsResourceFileRecord {
path: "App".into(),
creator: 0,
file_type: 0,
finder_flags: 0,
resource_len: fork.len() as u32,
raw_data: Some(fork.into()),
map_attrs: 0,
dirty: false,
}];
let edited = PpcVfsResourceRecord {
ref_num: 7,
path: "APP".into(),
res_type: u32::from_be_bytes(*b"TEST"),
res_id: 1,
name: b"edited name".to_vec(),
data: b"edited".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 2,
handle: 0x1234,
};
let mut other = edited.clone();
other.path = "Other".into();
other.res_id = 2;
let mut resources = vec![edited, other];
ppc_materialize_resource_records_for_path(&files, &mut resources, "app");
ppc_materialize_resource_records_for_path(&files, &mut resources, "APP");
assert_eq!(resources.len(), 4);
assert_eq!(resources[0].data, b"edited");
assert_eq!(resources[0].name, b"edited name");
assert_eq!(
(
resources[0].ref_num,
resources[0].attrs,
resources[0].handle
),
(7, 2, 0x1234)
);
assert_eq!(resources[1].path, "Other");
assert_eq!(
(resources[2].res_type, resources[2].res_id),
(u32::from_be_bytes(*b"DATA"), 1)
);
assert_eq!(
(resources[3].res_type, resources[3].res_id),
(u32::from_be_bytes(*b"TEST"), 2)
);
assert_eq!(resources[3].data, b"second");
}
#[test]
fn ppc_resource_materialization_mutates_process_manager_immediately() {
let pef = synthetic_pef_with_import(b"GetResource");
let mut native = load_pef_application(&pef).unwrap();
let external_handle = PPC_DATA_BASE + 0x2140;
native.memory.add_region(external_handle, vec![0; 4]);
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_dispatcher = TrapDispatcher::new();
classic_dispatcher.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(
|native, memory_manager| {
let allocator = memory_manager.native_allocator_snapshot().unwrap();
let mut heap_cursor = allocator.heap.heap_cursor;
let heap_limit = allocator.heap.heap_limit;
let mut last_mem_error = allocator.heap.last_mem_error;
let mut handles = memory_manager.native_handle_records().to_vec();
let mut resources = vec![PpcVfsResourceRecord {
ref_num: 0,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"pref"),
res_id: 42,
name: b"Prefs".to_vec(),
data: b"process resource".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
}];
let mut last_resource_error = PPC_NO_ERR;
let canonical_ptr =
memory_manager.new_native_ptr(&mut native.memory, 32, true);
assert_ne!(canonical_ptr, 0);
let cursor_after_canonical_allocation = memory_manager
.native_heap_state()
.unwrap()
.heap_cursor;
let handle = ppc_materialize_vfs_resource_handle(
memory_manager,
&mut native.memory,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
&mut resources,
0,
false,
&mut last_resource_error,
);
assert_ne!(handle, 0);
assert!(handle >= cursor_after_canonical_allocation);
assert_eq!(memory_manager.native_allocation(handle).unwrap().ptr, 0);
assert_eq!(memory_manager.state_for_handle(handle), Some(0x60));
assert_eq!(classic_dispatcher.handle_state_bits(handle), Some(0x60));
let detached = memory_manager.detached_clone();
let loaded = ppc_materialize_vfs_resource_handle(
memory_manager,
&mut native.memory,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
&mut resources,
0,
true,
&mut last_resource_error,
);
assert_eq!(loaded, handle);
let record = memory_manager.native_allocation(handle).unwrap();
let shared = native.memory.shared_view();
let mut classic_bus = MacMemoryBus::new(0x2000);
classic_bus.attach_guest_address_space(shared);
assert_eq!(
classic_bus.read_bytes(record.ptr, record.size as usize),
b"process resource"
);
assert_eq!(memory_manager.recover_handle(record.ptr), Some(handle));
assert_eq!(memory_manager.state_for_handle(handle), Some(0x60));
assert_eq!(detached.native_allocation(handle).unwrap().ptr, 0);
assert_eq!(detached.recover_handle(record.ptr), None);
assert_eq!(last_mem_error, PPC_NO_ERR);
assert_eq!(last_resource_error, PPC_NO_ERR);
let mut external_resources = vec![PpcVfsResourceRecord {
ref_num: 0,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"STR "),
res_id: 128,
name: b"External".to_vec(),
data: b"PEF master pointer".to_vec(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: external_handle,
}];
let materialized = ppc_materialize_vfs_resource_handle(
memory_manager,
&mut native.memory,
&mut heap_cursor,
heap_limit,
&mut last_mem_error,
&mut handles,
&mut external_resources,
0,
true,
&mut last_resource_error,
);
assert_eq!(materialized, external_handle);
assert_eq!(memory_manager.native_allocation(external_handle), None);
let external_ptr = native.memory.read_u32_be(external_handle).unwrap();
assert_ne!(external_ptr, 0);
assert_eq!(
memory_manager.recover_handle(external_ptr),
Some(external_handle)
);
assert_eq!(memory_manager.state_for_handle(external_handle), Some(0x60));
assert_eq!(
classic_dispatcher.handle_state_bits(external_handle),
Some(0x60)
);
assert_eq!(
classic_bus.read_bytes(external_ptr, b"PEF master pointer".len()),
b"PEF master pointer"
);
assert_eq!(detached.recover_handle(external_ptr), None);
},
);
}
#[test]
fn ppc_handle_copy_imports_mutate_process_memory_immediately() {
let pef = synthetic_pef_with_import(b"PtrToHand");
let mut native = load_pef_application(&pef).unwrap();
let scratch = PPC_DATA_BASE + 0x2100;
let source = scratch;
let output = scratch + 0x20;
let handle_variable = scratch + 0x24;
native.memory.add_region(scratch, vec![0; 0x100]);
native.memory.write_bytes(source, b"native").unwrap();
let mut classic_bus = crate::memory::MacMemoryBus::new(0x2000);
let shared = native.memory.shared_view();
classic_bus.attach_guest_address_space(shared);
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
native.with_process_memory_manager(
|native, memory_manager| {
native.cpu.gpr[3] = source;
native.cpu.gpr[4] = output;
native.cpu.gpr[5] = 6;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
let destination = native.memory.read_u32_be(output).unwrap();
let original = memory_manager.native_allocation(destination).unwrap();
assert_eq!(classic_bus.read_bytes(original.ptr, 6), b"native");
assert_eq!(memory_manager.state_for_handle(destination), Some(0));
native
.memory
.write_u32_be(handle_variable, destination)
.unwrap();
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HandToHand;
native.cpu.gpr[3] = handle_variable;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
let source_copy = native.memory.read_u32_be(handle_variable).unwrap();
assert_ne!(source_copy, destination);
let copy = memory_manager.native_allocation(source_copy).unwrap();
assert_eq!(classic_bus.read_bytes(copy.ptr, 6), b"native");
assert_eq!(memory_manager.state_for_handle(source_copy), Some(0));
native.cpu.pc = native.entry_pc;
native.cpu.lr = PPC_HALT_PC;
native.imports[0].dispatcher_target = PpcImportDispatcherTarget::HandAndHand;
native.cpu.gpr[3] = source_copy;
native.cpu.gpr[4] = destination;
native.run_with_process_memory_manager(64, false, false, memory_manager);
assert_eq!(native.cpu.gpr[3], 0);
let appended = memory_manager.native_allocation(destination).unwrap();
assert_eq!(appended.size, 12);
assert_eq!(classic_bus.read_long(destination), appended.ptr);
assert_eq!(classic_bus.read_bytes(appended.ptr, 12), b"nativenative");
assert_eq!(
memory_manager
.native_handle_records()
.iter()
.find(|record| record.handle == destination)
.copied(),
Some(appended)
);
assert_eq!(
memory_manager
.native_allocator()
.map(|allocator| allocator.heap.last_mem_error),
Some(PPC_NO_ERR)
);
},
);
}
#[test]
fn ppc_hand_to_hand_copies_a_process_owned_classic_handle_across_isa() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
let mut classic = TrapDispatcher::new();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
classic.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
classic_bus.attach_guest_address_space(native.memory.shared_view());
let payload = b"classic HandToHand source";
let (source_handle, source_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, payload.len() as u32)
.unwrap();
classic_bus.write_bytes(source_ptr, payload);
let memory_manager = context.memory_manager_handle().clone();
memory_manager
.borrow_mut()
.set_state_for_handle(source_handle, 0xe0);
let handle_variable = PPC_DATA_BASE + 0x2100;
native.memory.add_region(handle_variable, vec![0; 4]);
native
.memory
.write_u32_be(handle_variable, source_handle)
.unwrap();
let mut detached = native.clone();
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let copy_handle = native.memory.read_u32_be(handle_variable).unwrap();
assert_ne!(copy_handle, source_handle);
let copy_ptr = classic_bus.read_long(copy_handle);
assert_ne!(copy_ptr, 0);
assert_eq!(classic_bus.get_alloc_size(copy_handle), Some(4));
assert_eq!(
classic_bus.get_alloc_size(copy_ptr),
Some(payload.len() as u32)
);
assert_eq!(classic_bus.read_bytes(copy_ptr, payload.len()), payload);
assert_eq!(classic_bus.read_long(source_handle), source_ptr);
assert_eq!(classic_bus.read_bytes(source_ptr, payload.len()), payload);
assert_eq!(memory_manager.borrow().native_allocation(copy_handle), None);
assert_eq!(memory_manager.borrow().handle_for_ptr(copy_ptr), Some(copy_handle));
assert_eq!(memory_manager.borrow().handle_for_ptr(source_ptr), Some(source_handle));
assert_eq!(memory_manager.borrow().state_for_handle(copy_handle), Some(0));
assert_eq!(classic.handle_state_bits(copy_handle), Some(0));
assert_eq!(memory_manager.borrow().state_for_handle(source_handle), Some(0xe0));
let mut classic_cpu = crate::trap::test_helpers::MockCpu::new();
classic_cpu.write_reg(Register::A0, copy_ptr);
classic
.dispatch_memory(false, 0x28, &mut classic_cpu, &mut classic_bus)
.expect("68K RecoverHandle should be handled")
.expect("68K RecoverHandle should succeed");
assert_eq!(classic_cpu.read_reg(Register::A0), copy_handle);
assert_eq!(classic_cpu.read_reg(Register::D0), 0);
assert_eq!(classic.handle_for_ptr(copy_ptr), Some(copy_handle));
let detached_manager = detached.process_memory_manager.0.borrow();
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, source_handle),
Some(source_ptr)
);
assert_eq!(
PpcMemory::read_u32_be(&mut detached.memory, handle_variable),
Some(source_handle)
);
assert_eq!(detached_manager.classic_allocation_size(source_handle), Some(4));
assert_eq!(
detached_manager.classic_allocation_size(source_ptr),
Some(payload.len() as u32)
);
assert_eq!(detached_manager.classic_allocation_size(copy_handle), None);
assert_eq!(detached_manager.classic_allocation_size(copy_ptr), None);
assert_eq!(detached_manager.native_allocation(copy_handle), None);
assert_eq!(detached_manager.handle_for_ptr(source_ptr), Some(source_handle));
assert_eq!(detached_manager.handle_for_ptr(copy_ptr), None);
assert_eq!(detached_manager.state_for_handle(source_handle), Some(0xe0));
}
#[test]
fn ppc_hand_to_hand_rejects_a_foreign_classic_data_block_atomically() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let (source_handle, source_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 16)
.unwrap();
let (other_handle, other_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, 24)
.unwrap();
let source_bytes = (0x20..=0x2f).collect::<Vec<_>>();
let other_bytes = (0x80..=0x97).collect::<Vec<_>>();
classic_bus.write_bytes(source_ptr, &source_bytes);
classic_bus.write_bytes(other_ptr, &other_bytes);
classic_bus.write_long(source_handle, other_ptr);
let handle_variable = PPC_DATA_BASE + 0x2100;
native.memory.add_region(handle_variable, vec![0; 4]);
native
.memory
.write_u32_be(handle_variable, source_handle)
.unwrap();
let memory_manager = context.memory_manager_handle().clone();
let allocator_before = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator is attached");
let handles_before = memory_manager.borrow().native_handle_records().to_vec();
let classic_cursor_before = context.classic_heap_bump_ptr();
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_MEM_WZ_ERR));
assert_eq!(native.memory.read_u32_be(handle_variable), Some(source_handle));
assert_eq!(classic_bus.read_long(source_handle), other_ptr);
assert_eq!(classic_bus.read_long(other_handle), other_ptr);
assert_eq!(classic_bus.get_alloc_size(source_ptr), Some(16));
assert_eq!(classic_bus.get_alloc_size(other_ptr), Some(24));
assert_eq!(classic_bus.read_bytes(source_ptr, 16), source_bytes);
assert_eq!(classic_bus.read_bytes(other_ptr, 24), other_bytes);
assert_eq!(context.classic_heap_bump_ptr(), classic_cursor_before);
assert_eq!(memory_manager.borrow().handle_for_ptr(source_ptr), Some(source_handle));
assert_eq!(memory_manager.borrow().handle_for_ptr(other_ptr), Some(other_handle));
assert_eq!(memory_manager.borrow().native_handle_records(), handles_before);
let allocator_after = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator remains attached");
assert_eq!(allocator_after.heap.heap_cursor, allocator_before.heap.heap_cursor);
assert_eq!(allocator_after.ptrs, allocator_before.ptrs);
assert_eq!(allocator_after.free_ptr_blocks, allocator_before.free_ptr_blocks);
assert_eq!(
allocator_after.free_handle_blocks,
allocator_before.free_handle_blocks
);
assert_eq!(allocator_after.heap.last_mem_error, PPC_MEM_WZ_ERR);
}
#[test]
fn ppc_hand_to_hand_rejects_a_disposed_classic_source_atomically() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let mut classic_bus =
attach_test_classic_heap(&mut native, &mut context, 8 * 1024 * 1024, 0x4000);
let payload = b"disposed classic source";
let (source_handle, source_ptr) = context
.memory_manager_mut()
.new_classic_handle(&mut classic_bus, payload.len() as u32)
.unwrap();
classic_bus.write_bytes(source_ptr, payload);
let memory_manager = context.memory_manager_handle().clone();
assert!(memory_manager
.borrow_mut()
.dispose_process_handle_from_native_import(&mut native.memory, source_handle));
let stale_master = classic_bus.read_long(source_handle);
let stale_bytes = classic_bus.read_bytes(source_ptr, payload.len());
let handle_variable = PPC_DATA_BASE + 0x2100;
native.memory.add_region(handle_variable, vec![0; 4]);
native
.memory
.write_u32_be(handle_variable, source_handle)
.unwrap();
let classic_cursor_before = context.classic_heap_bump_ptr();
let allocator_before = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator is attached");
let handles_before = memory_manager.borrow().native_handle_records().to_vec();
let reverse_before = memory_manager.borrow().handle_for_ptr(source_ptr);
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NIL_HANDLE_ERR));
assert_eq!(native.memory.read_u32_be(handle_variable), Some(source_handle));
assert_eq!(classic_bus.read_long(source_handle), stale_master);
assert_eq!(classic_bus.read_bytes(source_ptr, payload.len()), stale_bytes);
assert_eq!(context.classic_heap_bump_ptr(), classic_cursor_before);
assert_eq!(memory_manager.borrow().classic_allocation_size(source_handle), None);
assert_eq!(memory_manager.borrow().classic_allocation_size(source_ptr), None);
assert_eq!(memory_manager.borrow().handle_for_ptr(source_ptr), reverse_before);
assert_eq!(memory_manager.borrow().state_for_handle(source_handle), None);
assert_eq!(memory_manager.borrow().native_handle_records(), handles_before);
let allocator_after = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator remains attached");
assert_eq!(allocator_after.heap.heap_cursor, allocator_before.heap.heap_cursor);
assert_eq!(allocator_after.ptrs, allocator_before.ptrs);
assert_eq!(allocator_after.free_ptr_blocks, allocator_before.free_ptr_blocks);
assert_eq!(
allocator_after.free_handle_blocks,
allocator_before.free_handle_blocks
);
assert_eq!(allocator_after.heap.last_mem_error, PPC_NIL_HANDLE_ERR);
}
#[test]
fn ppc_hand_to_hand_rejects_a_readonly_handle_variable_before_allocating() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle().clone();
let source_handle = memory_manager
.borrow_mut()
.copy_bytes_to_new_native_handle(&mut native.memory, b"source");
assert_ne!(source_handle, 0);
let handle_variable = PPC_DATA_BASE + 0x2100;
native
.memory
.add_readonly_region(handle_variable, source_handle.to_be_bytes().to_vec());
let allocator_before = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator is attached");
let handles_before = memory_manager.borrow().native_handle_records().to_vec();
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(native.memory.read_u32_be(handle_variable), Some(source_handle));
assert_eq!(memory_manager.borrow().native_handle_records(), handles_before);
let allocator_after = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator remains attached");
assert_eq!(allocator_after.heap.heap_cursor, allocator_before.heap.heap_cursor);
assert_eq!(allocator_after.ptrs, allocator_before.ptrs);
assert_eq!(allocator_after.free_ptr_blocks, allocator_before.free_ptr_blocks);
assert_eq!(
allocator_after.free_handle_blocks,
allocator_before.free_handle_blocks
);
assert_eq!(allocator_after.heap.last_mem_error, PPC_PARAM_ERR);
}
#[test]
fn ppc_hand_to_hand_preserves_the_toolbox_color_table_fallback() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
ppc_seed_main_color_table(&mut native.memory).unwrap();
let expected = ppc_memory_read_bytes(
&mut native.memory,
PPC_MAIN_CTABLE,
PPC_MAIN_CTABLE_SIZE,
)
.unwrap();
let handle_variable = PPC_DATA_BASE + 0x2100;
native.memory.add_region(handle_variable, vec![0; 4]);
native
.memory
.write_u32_be(handle_variable, PPC_MAIN_CTABLE_HANDLE)
.unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle().clone();
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let copy_handle = native.memory.read_u32_be(handle_variable).unwrap();
assert_ne!(copy_handle, PPC_MAIN_CTABLE_HANDLE);
let copy = memory_manager
.borrow()
.native_allocation(copy_handle)
.expect("Toolbox-owned data should retain the native fallback");
assert_eq!(copy.size, PPC_MAIN_CTABLE_SIZE);
assert_eq!(
ppc_memory_read_bytes(&mut native.memory, copy.ptr, copy.size),
Some(expected)
);
assert_eq!(memory_manager.borrow().state_for_handle(copy_handle), Some(0));
}
#[test]
fn ppc_hand_to_hand_color_table_heap_failure_is_atomic() {
let pef = synthetic_pef_with_import(b"HandToHand");
let mut native = load_pef_application(&pef).unwrap();
ppc_seed_main_color_table(&mut native.memory).unwrap();
let handle_variable = PPC_DATA_BASE + 0x2100;
native.memory.add_region(handle_variable, vec![0; 4]);
native
.memory
.write_u32_be(handle_variable, PPC_MAIN_CTABLE_HANDLE)
.unwrap();
let mut context = ProcessContext::default();
native.attach_unconverted_process_services(&mut context);
let memory_manager = context.memory_manager_handle().clone();
let allocator_before = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator is attached");
memory_manager
.borrow_mut()
.set_native_heap_limit(allocator_before.heap.heap_cursor + PPC_HEAP_ALIGNMENT);
native.cpu.gpr[3] = handle_variable;
run_test_import_with_process_memory_manager(
&mut native,
PpcImportDispatcherTarget::HandToHand,
&memory_manager,
);
assert_eq!(native.cpu.gpr[3], ppc_i16_result(PPC_MEM_FULL_ERR));
assert_eq!(
native.memory.read_u32_be(handle_variable),
Some(PPC_MAIN_CTABLE_HANDLE)
);
assert!(memory_manager.borrow().native_handle_records().is_empty());
let allocator_after = memory_manager
.borrow()
.native_allocator_snapshot()
.expect("native allocator remains attached");
assert_eq!(allocator_after.heap.heap_cursor, allocator_before.heap.heap_cursor);
assert_eq!(allocator_after.ptrs, allocator_before.ptrs);
assert_eq!(allocator_after.free_ptr_blocks, allocator_before.free_ptr_blocks);
assert_eq!(
allocator_after.free_handle_blocks,
allocator_before.free_handle_blocks
);
assert_eq!(allocator_after.heap.last_mem_error, PPC_MEM_FULL_ERR);
}