[#53750] tests: sysbus: Test accessing locked mapped memory from CPU
diff --git a/tests/unit-tests/sysbus.robot b/tests/unit-tests/sysbus.robot
index f5bdc74..fcf8869 100644
--- a/tests/unit-tests/sysbus.robot
+++ b/tests/unit-tests/sysbus.robot
@@ -15,17 +15,62 @@
... ${SPACE*4}size: 0x500 ${\n}
... """
+${max_32bit_addr} 0xFFFFFFFF
+
*** Keywords ***
+Create Machine With CPU And Two MappedMemory Peripherals
+ Execute Command using sysbus
+ Execute Command mach create
+
+ # ARMv7A is used only because it can be created without any additional peripherals.
+ # Locking can be used with all CPUs.
+ Execute Command machine LoadPlatformDescriptionFromString "cpu: CPU.ARMv7A @ sysbus { cpuType: \\"cortex-a9\\"}"
+ Execute Command machine LoadPlatformDescriptionFromString "mem1: Memory.MappedMemory @ sysbus 0x10000 { size: 0x10000 }"
+ Execute Command machine LoadPlatformDescriptionFromString "mem2: Memory.MappedMemory @ sysbus 0x80000 { size: 0x10000 }"
+
+Get ${peripheral} Size, Address And Range
+ ${size}= Execute Command ${peripheral} Size
+ ${size}= Strip String ${size}
+ ${ranges}= Execute Command sysbus GetRegistrationPoints ${peripheral}
+
+ # Let's make sure there's only one range.
+ ${count}= Evaluate """${ranges}""".count('<')
+ Should Be Equal As Integers 1 ${count}
+
+ ${range} ${address}= Evaluate
+ ... [ re.search('<(0x[0-9A-F]*), .*>', """${ranges}""").group(i) for i in range(2) ]
+ ... modules=re
+
+ [Return] ${size} ${address} ${range}
+
+${lock_or_unlock:(Lock|Unlock)} Address Range From ${start} To ${end}
+ ${range}= Evaluate f"<{ hex(${start}) }, { hex(${end}) }>"
+ ${lock_or_unlock} Address Range ${range}
+
+${lock_or_unlock:(Lock|Unlock)} Address Range ${range}
+ ${set_lock}= Evaluate '${lock_or_unlock}' == 'Lock'
+ Execute Command sysbus SetAddressRangeLocked ${range} ${set_lock}
+
+Range From ${start} To ${end} Should Be Accessible
+ ${range}= Evaluate f"<{ hex(${start}) }, { hex(${end}) }>"
+ ${locked_str}= Execute Command sysbus IsAddressRangeLocked ${range}
+ Should Start With ${locked_str} False
+
+No Blocked Access Should Be In Log
+ Should Not Be In Log Tried to (read|write) .* which is inside a locked address range treatAsRegex=True
+
+Blocked ${access_size}B Read From ${address} Should Be In Log
+ ${eval_addr}= Evaluate '0x' + hex(${address}).upper()[2:]
+ Wait For Log Entry Tried to read ${access_size} bytes at ${eval_addr} which is inside a locked address range, returning 0
+
Read From Sysbus And Check If Blocked
[Arguments] ${address} ${expected_value}=0x0 ${should_be_blocked}=True ${access_type}=Byte ${access_size}=1 ${cpu_context}=
- ${blocked_read_log}= Set Variable Tried to read ${access_size} bytes at ${address} which is inside a locked address range, returning 0
-
- ${read_value}= Execute Command sysbus Read${access_type} ${address} ${cpu_context}
+ ${read_value}= Execute Command sysbus Read${access_type} ${address} ${cpu_context}
IF ${should_be_blocked}
- Wait For Log Entry ${blocked_read_log}
+ Blocked ${access_size}B Read From ${address} Should Be In Log
ELSE
- Should Not Be In Log ${blocked_read_log}
+ No Blocked Access Should Be In Log
END
Should Be Equal As Integers ${read_value} ${expected_value} base=16
@@ -45,15 +90,18 @@
[Arguments] ${address} ${expected_value} ${cpu_context}=
Read From Sysbus And Check If Blocked ${address} ${expected_value} should_be_blocked=False access_type=QuadWord access_size=8 cpu_context=${cpu_context}
+Blocked ${access_size}B Write${access_type} Of ${value} To ${address} Should Be In Log
+ ${eval_addr}= Evaluate '0x' + hex(${address}).upper()[2:]
+ Wait For Log Entry Tried to write ${access_size} bytes (${value}) at ${eval_addr} which is inside a locked address range, write ignored
+
Write To Sysbus And Check If Blocked
[Arguments] ${address} ${value} ${should_be_blocked}=True ${access_type}=Byte ${access_size}=1 ${cpu_context}=
- Execute Command sysbus Write${access_type} ${address} ${value} ${cpu_context}
- ${blocked_write_log}= Set Variable Tried to write ${access_size} bytes (${value}) at ${address} which is inside a locked address range, write ignored
+ Execute Command sysbus Write${access_type} ${address} ${value} ${cpu_context}
IF ${should_be_blocked}
- Wait For Log Entry ${blocked_write_log}
+ Blocked ${access_size}B Write Of ${value} To ${address} Should Be In Log
ELSE
- Should Not Be In Log ${blocked_write_log}
+ No Blocked Access Should Be In Log
END
Should Block Write Byte
@@ -264,6 +312,128 @@
Wait For Log Entry mockCpu0: CPU abort \[PC=0x4000\]: Trying to execute code from disabled or locked memory at 0x00004000 timeout=10
Wait For Log Entry mockCpu1: CPU abort \[PC=0x6000\]: Trying to execute code outside RAM or ROM at 0x00006000 timeout=10
+Locked MappedMemory Should Not Be Accessible From CPU
+ Create Machine With CPU And Two MappedMemory Peripherals
+ ${flash}= Set Variable mem1
+ ${ram}= Set Variable mem2
+
+ ${flash_size} ${flash_addr} ${flash_range}= Get ${flash} Size, Address And Range
+ ${ram_size} ${ram_addr} ${ram_range}= Get ${ram} Size, Address And Range
+
+ Execute Command cpu ExecutionMode SingleStep
+ Execute Command cpu PC ${ram_addr}
+ Create Log Tester 0
+
+ # With flash locked, the loads from [r3] and stores to [r3] should be blocked.
+ ${result_addr}= Evaluate hex(${flash_addr} + 0x1000)
+ Execute Command cpu SetRegisterUnsafe 3 ${result_addr}
+
+ Execute Command ${ram} WriteDoubleWord 0x00 0xe59f2028 # ldr r2, [pc, #40] // =0x11111111
+ Execute Command ${ram} WriteDoubleWord 0x04 0xe5832000 # str r2, [r3]
+ Execute Command ${ram} WriteDoubleWord 0x30 0x11111111 # this will be loaded by LDR instruction above
+
+ # Ranges have to fully contain all MappedMemory peripherals registered in the given range.
+ # Here we lock whole sysbus and then unlock ram.
+ Lock Address Range From 0x0 To ${max_32bit_addr}
+ Unlock Address Range ${ram_range}
+ Execute Command cpu Step 2
+
+ Blocked 4B Write Of 0x11111111 To ${result_addr} Should Be In Log
+
+ Execute Command ${ram} WriteDoubleWord 0x08 0xe59f2024 # ldr r2, [pc, #34] // =0x22222222
+ Execute Command ${ram} WriteDoubleWord 0x0c 0xe5832000 # str r2, [r3]
+ Execute Command ${ram} WriteDoubleWord 0x10 0xe3032333 # movw r2, #0x3333
+ Execute Command ${ram} WriteDoubleWord 0x14 0xe1c320b1 # strh r2, [r3, #1]
+ Execute Command ${ram} WriteDoubleWord 0x34 0x22222222 # this will be loaded by LDR instruction above
+
+ Unlock Address Range ${flash_range}
+ Execute Command cpu Step 4
+
+ No Blocked Access Should Be In Log
+
+ Execute Command ${ram} WriteDoubleWord 0x18 0xe3a02044 # mov r2, #0x44
+ Execute Command ${ram} WriteDoubleWord 0x1c 0xe5c32001 # strb r2, [r3, #1]
+ Execute Command ${ram} WriteDoubleWord 0x20 0xe5932000 # ldr r2, [r3]
+
+ # Lock flash and some memory around it.
+ Lock Address Range From ${flash_addr}-${flash_size} To ${flash_addr}+${flash_size}*2
+ Execute Command cpu Step 3
+
+ Blocked 1B Write Of 0x44 To ${result_addr}+1 Should Be In Log
+ Blocked 4B Read From ${result_addr} Should Be In Log
+
+ Execute Command ${ram} WriteDoubleWord 0x24 0xe3a02055 # mov r2, #0x55
+ Execute Command ${ram} WriteDoubleWord 0x28 0xe5c32002 # strb r2, [r3, #2]
+ Execute Command ${ram} WriteDoubleWord 0x2c 0xe5932000 # ldr r2, [r3]
+
+ Unlock Address Range From 0x0 To ${max_32bit_addr}
+ Execute Command cpu Step 3
+
+ No Blocked Access Should Be In Log
+
+ ${res}= Execute Command sysbus ReadDoubleWord ${result_addr}
+ Should Be True """${res}""".strip() == '0x22553322'
+
+Partial MappedMemory Locking Should Not Be Allowed With ICPUWithMappedMemory
+ # CPU is important; partial MappedMemory locking isn't allowed only with ICPUWithMappedMemory.
+ Create Machine With CPU And Two MappedMemory Peripherals
+
+ ${mem1_size} ${mem1_addr} ${mem1_range}= Get mem1 Size, Address And Range
+ ${mem2_size} ${mem2_addr} ${mem2_range}= Get mem2 Size, Address And Range
+ ${mem2_end}= Evaluate hex(${mem2_addr} + ${mem2_size} - 1)
+
+ ${error}= Set Variable Mapped peripherals registered at the given range * have to be fully included:
+ ${mem1_reg}= Set Variable \n\* machine-0.mem1 registered at ${mem1_range}
+ ${mem2_reg}= Set Variable \n\* machine-0.mem2 registered at ${mem2_range}
+
+ # Test partial locking of one or both MappedMemory peripherals.
+
+ Run Keyword And Expect Error *${error}${mem1_reg}*
+ ... Lock Address Range From 0x0 To ${mem1_addr}+0x10
+
+ Run Keyword And Expect Error *${error}${mem1_reg}*
+ ... Lock Address Range From ${mem1_addr}+0x10 To ${max_32bit_addr}
+
+ Run Keyword And Expect Error *${error}${mem2_reg}*
+ ... Lock Address Range From 0x0 To ${mem2_addr}+0x10
+
+ Run Keyword And Expect Error *${error}${mem1_reg}${mem2_reg}*
+ ... Lock Address Range From ${mem1_addr}+0x10 To ${mem2_addr}+0x10
+
+ # Make sure no range within 32-bit address space has been locked.
+ Range From 0x0 To ${max_32bit_addr} Should Be Accessible
+
+ # Lock mem1, mem2 and the address space in between.
+ Execute Command sysbus SetAddressRangeLocked <${mem1_addr}, ${mem2_end}> true
+
+ # Test partial unlocking of one or both MappedMemory peripherals.
+
+ Run Keyword And Expect Error *${error}${mem1_reg}*
+ ... Unlock Address Range From 0x0 To ${mem1_addr}+0x10
+
+ Run Keyword And Expect Error *${error}${mem1_reg}*
+ ... Unlock Address Range From ${mem1_addr}+0x10 To ${max_32bit_addr}
+
+ Run Keyword And Expect Error *${error}${mem2_reg}*
+ ... Unlock Address Range From ${mem2_addr}+0x10 To ${max_32bit_addr}
+
+ Run Keyword And Expect Error *${error}${mem1_reg}${mem2_reg}*
+ ... Unlock Address Range From ${mem1_addr}+0x10 To ${mem2_addr}+0x10
+
+ # Make sure mem1, mem2 and the address space in between are still locked. Range
+ # is considered locked if the given range contains any locked range which is why
+ # `IsAddressRangeLocked` isn't used. Let's check accessing a byte every 0x8000.
+ @{locked_range_addresses}= Evaluate
+ ... [address for address in range(${mem1_addr}, ${mem2_end}, 0x8000)]
+ FOR ${address} IN ${mem1_addr} @{locked_range_addresses}
+ Log ${address}
+ Should Block Read Byte ${address}
+ END
+
+ # Unlock mem1, mem2 and the address space in between and verify there are no locks now.
+ Unlock Address Range <${mem1_addr}, ${mem2_end}>
+ Range From ${mem1_addr} To ${mem2_end} Should Be Accessible
+
Symbols Should Be Dynamically Loaded and Unloaded On Request
${bin}= Set Variable @https://dl.antmicro.com/projects/renode/stm32l07--zephyr-shell_module.elf-s_1195760-e9474da710aca88c89c7bddd362f7adb4b0c4b70
${cpu}= Set Variable sysbus.cpu
@@ -299,4 +469,4 @@
Should Be Equal As Numbers ${main_symbol_address} ${main_address_local}
Run Keyword And Expect Error *No symbol with name `main` found*
... Execute Command sysbus GetSymbolAddress ${main_symbol_name}
-
\ No newline at end of file
+
