使用Rust在树莓派上编写操作系统 - 06 - UART的链式加载

WARNING
本文所有内容均为翻译，原文：Tutorial 06 - UART Chainloader；原项目：Operating System development tutorials in Rust on the Raspberry Pi

概述#

用SD卡上的镜像启动树莓派感觉很棒，但如果对每个新的二进制文件，都需要手动将其放在SD卡上就会非常麻烦。因此，本章我们将编写一个链式加载器。
这是我们最后一次手动拷贝镜像到SD卡上。后面的每章教程都会在Makefile中提供一个chainboot目标，以便通过UART加载内核。

注意#

请注意，若仅查看源码差异，则很难掌握本章教程中出现的一些新功能。

关键就在boot.s中，我们正在编写一段位置无关代码，代码能够自动确定固件从什么位置(0x8_0000)加载二进制文件，以及应当链接到什么位置(0x200_0000，请参阅link.ld)。然后二进制文件将自身从加载地址复制到链接地址（即“重定位”自身），再跳转到重定位版本的_start_rust()中。

由于链式加载器自己已经“让出位置”，它现在就可以从UART接收另一个内核二进制文件，并将其复制到树莓派固件的标准加载地址0x8_0000。最后，它跳转到0x8_0000再透明的执行新加载的二进制文件，仿佛该文件是从SD卡中加载似的。

请耐心等待，等我一有时间，就会将这个过程写成详尽的文档。不过目前，请参阅本章教程看做一个方便的启动器，该驱动器允许我们快速启动后续教程章节中新的内核二进制文件。

安装并测试#

我们的链式加载器叫做MiniLoad，其灵感来自raspbootin。

在本章教程中试用MiniLoad：

根据目标硬件，运行：make或者BSP=rpi4 make。
将kernel8.img复制到SD卡，并将SD卡插回到树莓派。
根据目标硬件，运行make chainboot或者BSP=rpi4 make chainboot。
连接USB串口线到宿主PC。
- 按照本项目的根README接线。
- 一定确保没有连接USB串口的电源引脚。只连接了RX/TX和GND。
为树莓派连接(USB)电源。
观察加载程序通过UART获取内核：

❗注意：make chainboot的默认串行设备名称为/dev/ttyUSB0。对于不同操作系统的宿主机，设备名称可能会有所不同。例如，在macOS上，名称可能类似于/dev/tty.usbserial-0001。这种情况下，需要明确给出名称：

1
$ DEV_SERIAL=/dev/tty.usbserial-0001 make chainboot

1
$ make chainboot
2
[...]
3
Minipush 1.0
4

5
[MP] ⏳ Waiting for /dev/ttyUSB0
6
[MP] ✅ Serial connected
7
[MP] 🔌 Please power the target now
8
 __  __ _      _ _                 _
9
|  \/  (_)_ _ (_) |   ___  __ _ __| |
10
| |\/| | | ' \| | |__/ _ \/ _` / _` |
11
|_|  |_|_|_||_|_|____\___/\__,_\__,_|
12

13
           Raspberry Pi 3
14

15
[ML] Requesting binary
16
[MP] ⏩ Pushing 6 KiB ==========================================🦀 100% 0 KiB/s Time: 00:00:00
17
[ML] Loaded! Executing the payload now
18

19
[0] mingo version 0.5.0
20
[1] Booting on: Raspberry Pi 3
21
[2] Drivers loaded:
22
      1. BCM GPIO
23
      2. BCM PL011 UART
24
[3] Chars written: 117
25
[4] Echoing input now

实验#

本章教程中的Makefile有一个额外的目标——qemuasm——可以让您更好地观察内核内核在重定位后，是如何从加载地址0x80_XXX跳转到位于0x0200_0XXX的重定位代码处的：

1
$ make qemuasm
2
[...]
3
N:
4
0x00080030:  58000140  ldr      x0, #0x80058
5
0x00080034:  9100001f  mov      sp, x0
6
0x00080038:  58000141  ldr      x1, #0x80060
7
0x0008003c:  d61f0020  br       x1
8

9
----------------
10
IN:
11
0x02000070:  9400044c  bl       #0x20011a0
12

13
----------------
14
IN:
15
0x020011a0:  90000008  adrp     x8, #0x2001000
16
0x020011a4:  90000009  adrp     x9, #0x2001000
17
0x020011a8:  f9446508  ldr      x8, [x8, #0x8c8]
18
0x020011ac:  f9446929  ldr      x9, [x9, #0x8d0]
19
0x020011b0:  eb08013f  cmp      x9, x8
20
0x020011b4:  54000109  b.ls     #0x20011d4
21
[...]

与上一章代码的区别#

1
diff -uNr 05_drivers_gpio_uart/Cargo.toml 06_uart_chainloader/Cargo.toml
2
--- 05_drivers_gpio_uart/Cargo.toml
3
+++ 06_uart_chainloader/Cargo.toml
4
@@ -1,6 +1,6 @@
5
 [package]
6
 name = "mingo"
7
-version = "0.5.0"
8
+version = "0.6.0"
9
 authors = ["Andre Richter <andre.o.richter@gmail.com>"]
10
 edition = "2021"
11

12
Binary files 05_drivers_gpio_uart/demo_payload_rpi3.img and 06_uart_chainloader/demo_payload_rpi3.img differ
13
Binary files 05_drivers_gpio_uart/demo_payload_rpi4.img and 06_uart_chainloader/demo_payload_rpi4.img differ
14

15
diff -uNr 05_drivers_gpio_uart/Makefile 06_uart_chainloader/Makefile
16
--- 05_drivers_gpio_uart/Makefile
17
+++ 06_uart_chainloader/Makefile
18
@@ -23,27 +23,29 @@
19

20
 # BSP-specific arguments.
21
 ifeq ($(BSP),rpi3)
22
-    TARGET            = aarch64-unknown-none-softfloat
23
-    KERNEL_BIN        = kernel8.img
24
-    QEMU_BINARY       = qemu-system-aarch64
25
-    QEMU_MACHINE_TYPE = raspi3
26
-    QEMU_RELEASE_ARGS = -serial stdio -display none
27
-    OBJDUMP_BINARY    = aarch64-none-elf-objdump
28
-    NM_BINARY         = aarch64-none-elf-nm
29
-    READELF_BINARY    = aarch64-none-elf-readelf
30
-    LINKER_FILE       = src/bsp/raspberrypi/link.ld
31
-    RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
32
+    TARGET                 = aarch64-unknown-none-softfloat
33
+    KERNEL_BIN             = kernel8.img
34
+    QEMU_BINARY            = qemu-system-aarch64
35
+    QEMU_MACHINE_TYPE      = raspi3
36
+    QEMU_RELEASE_ARGS      = -serial stdio -display none
37
+    OBJDUMP_BINARY         = aarch64-none-elf-objdump
38
+    NM_BINARY              = aarch64-none-elf-nm
39
+    READELF_BINARY         = aarch64-none-elf-readelf
40
+    LINKER_FILE            = src/bsp/raspberrypi/link.ld
41
+    RUSTC_MISC_ARGS        = -C target-cpu=cortex-a53
42
+    CHAINBOOT_DEMO_PAYLOAD = demo_payload_rpi3.img
43
 else ifeq ($(BSP),rpi4)
44
-    TARGET            = aarch64-unknown-none-softfloat
45
-    KERNEL_BIN        = kernel8.img
46
-    QEMU_BINARY       = qemu-system-aarch64
47
-    QEMU_MACHINE_TYPE =
48
-    QEMU_RELEASE_ARGS = -serial stdio -display none
49
-    OBJDUMP_BINARY    = aarch64-none-elf-objdump
50
-    NM_BINARY         = aarch64-none-elf-nm
51
-    READELF_BINARY    = aarch64-none-elf-readelf
52
-    LINKER_FILE       = src/bsp/raspberrypi/link.ld
53
-    RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
54
+    TARGET                 = aarch64-unknown-none-softfloat
55
+    KERNEL_BIN             = kernel8.img
56
+    QEMU_BINARY            = qemu-system-aarch64
57
+    QEMU_MACHINE_TYPE      =
58
+    QEMU_RELEASE_ARGS      = -serial stdio -display none
59
+    OBJDUMP_BINARY         = aarch64-none-elf-objdump
60
+    NM_BINARY              = aarch64-none-elf-nm
61
+    READELF_BINARY         = aarch64-none-elf-readelf
62
+    LINKER_FILE            = src/bsp/raspberrypi/link.ld
63
+    RUSTC_MISC_ARGS        = -C target-cpu=cortex-a72
64
+    CHAINBOOT_DEMO_PAYLOAD = demo_payload_rpi4.img
65
 endif
66

67
 QEMU_MISSING_STRING = "This board is not yet supported for QEMU."
68
@@ -75,8 +77,8 @@
69
     -O binary
70

71
 EXEC_QEMU          = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
72
-EXEC_TEST_DISPATCH = ruby ../common/tests/dispatch.rb
73
-EXEC_MINITERM      = ruby ../common/serial/miniterm.rb
74
+EXEC_TEST_MINIPUSH = ruby tests/chainboot_test.rb
75
+EXEC_MINIPUSH      = ruby ../common/serial/minipush.rb
76

77
 ##------------------------------------------------------------------------------
78
 ## Dockerization
79
@@ -95,7 +97,7 @@
80
 ifeq ($(shell uname -s),Linux)
81
     DOCKER_CMD_DEV = $(DOCKER_CMD_INTERACT) $(DOCKER_ARG_DEV)
82

83
-    DOCKER_MINITERM = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_COMMON) $(DOCKER_IMAGE)
84
+    DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_COMMON) $(DOCKER_IMAGE)
85
 endif
86

87

88
@@ -103,7 +105,7 @@
89
 ##--------------------------------------------------------------------------------------------------
90
 ## Targets
91
 ##--------------------------------------------------------------------------------------------------
92
-.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu miniterm clippy clean readelf objdump nm check
93
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot clippy clean readelf objdump nm check
94

95
 all: $(KERNEL_BIN)
96

97
@@ -132,7 +134,7 @@
98
 ##------------------------------------------------------------------------------
99
 ifeq ($(QEMU_MACHINE_TYPE),) # QEMU is not supported for the board.
100

101
-qemu:
102
+qemu qemuasm:
103
   $(call colorecho, "\n$(QEMU_MISSING_STRING)")
104

105
 else # QEMU is supported.
106
@@ -140,13 +142,18 @@
107
 qemu: $(KERNEL_BIN)
108
   $(call colorecho, "\nLaunching QEMU")
109
   @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
110
+
111
+qemuasm: $(KERNEL_BIN)
112
+  $(call colorecho, "\nLaunching QEMU with ASM output")
113
+  @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN) -d in_asm
114
+
115
 endif
116

117
 ##------------------------------------------------------------------------------
118
-## Connect to the target's serial
119
+## Push the kernel to the real HW target
120
 ##------------------------------------------------------------------------------
121
-miniterm:
122
-  @$(DOCKER_MINITERM) $(EXEC_MINITERM) $(DEV_SERIAL)
123
+chainboot: $(KERNEL_BIN)
124
+  @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(CHAINBOOT_DEMO_PAYLOAD)
125

126
 ##------------------------------------------------------------------------------
127
 ## Run clippy
128
@@ -210,7 +217,8 @@
129
 ##------------------------------------------------------------------------------
130
 test_boot: $(KERNEL_BIN)
131
   $(call colorecho, "\nBoot test - $(BSP)")
132
-  @$(DOCKER_TEST) $(EXEC_TEST_DISPATCH) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
133
+  @$(DOCKER_TEST) $(EXEC_TEST_MINIPUSH) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
134
+    -kernel $(KERNEL_BIN) $(CHAINBOOT_DEMO_PAYLOAD)
135

136
 test: test_boot
137

138

139
diff -uNr 05_drivers_gpio_uart/src/_arch/aarch64/cpu/boot.s 06_uart_chainloader/src/_arch/aarch64/cpu/boot.s
140
--- 05_drivers_gpio_uart/src/_arch/aarch64/cpu/boot.s
141
+++ 06_uart_chainloader/src/_arch/aarch64/cpu/boot.s
142
@@ -18,6 +18,17 @@
143
   add  \register, \register, #:lo12:\symbol
144
 .endm
145

146
+// Load the address of a symbol into a register, absolute.
147
+//
148
+// # Resources
149
+//
150
+// - https://sourceware.org/binutils/docs-2.36/as/AArch64_002dRelocations.html
151
+.macro ADR_ABS register, symbol
152
+  movz  \register, #:abs_g2:\symbol
153
+  movk  \register, #:abs_g1_nc:\symbol
154
+  movk  \register, #:abs_g0_nc:\symbol
155
+.endm
156
+
157
 .equ _core_id_mask, 0b11
158

159
 //--------------------------------------------------------------------------------------------------
160
@@ -39,23 +50,35 @@
161
   // If execution reaches here, it is the boot core.
162

163
   // Initialize DRAM.
164
-  ADR_REL  x0, __bss_start
165
-  ADR_REL x1, __bss_end_exclusive
166
+  ADR_ABS  x0, __bss_start
167
+  ADR_ABS x1, __bss_end_exclusive
168

169
 .L_bss_init_loop:
170
   cmp  x0, x1
171
-  b.eq  .L_prepare_rust
172
+  b.eq  .L_relocate_binary
173
   stp  xzr, xzr, [x0], #16
174
   b  .L_bss_init_loop
175

176
+  // Next, relocate the binary.
177
+.L_relocate_binary:
178
+  ADR_REL  x0, __binary_nonzero_start         // The address the binary got loaded to.
179
+  ADR_ABS  x1, __binary_nonzero_start         // The address the binary was linked to.
180
+  ADR_ABS  x2, __binary_nonzero_end_exclusive
181
+
182
+.L_copy_loop:
183
+  ldr  x3, [x0], #8
184
+  str  x3, [x1], #8
185
+  cmp  x1, x2
186
+  b.lo  .L_copy_loop
187
+
188
   // Prepare the jump to Rust code.
189
-.L_prepare_rust:
190
   // Set the stack pointer.
191
-  ADR_REL  x0, __boot_core_stack_end_exclusive
192
+  ADR_ABS  x0, __boot_core_stack_end_exclusive
193
   mov  sp, x0
194

195
-  // Jump to Rust code.
196
-  b  _start_rust
197
+  // Jump to the relocated Rust code.
198
+  ADR_ABS  x1, _start_rust
199
+  br  x1
200

201
   // Infinitely wait for events (aka "park the core").
202
 .L_parking_loop:
203

204
diff -uNr 05_drivers_gpio_uart/src/bsp/device_driver/bcm/bcm2xxx_gpio.rs 06_uart_chainloader/src/bsp/device_driver/bcm/bcm2xxx_gpio.rs
205
--- 05_drivers_gpio_uart/src/bsp/device_driver/bcm/bcm2xxx_gpio.rs
206
+++ 06_uart_chainloader/src/bsp/device_driver/bcm/bcm2xxx_gpio.rs
207
@@ -148,7 +148,7 @@
208
         // Make an educated guess for a good delay value (Sequence described in the BCM2837
209
         // peripherals PDF).
210
         //
211
-        // - According to Wikipedia, the fastest Pi3 clocks around 1.4 GHz.
212
+        // - According to Wikipedia, the fastest RPi4 clocks around 1.5 GHz.
213
         // - The Linux 2837 GPIO driver waits 1 µs between the steps.
214
         //
215
         // So lets try to be on the safe side and default to 2000 cycles, which would equal 1 µs
216

217
diff -uNr 05_drivers_gpio_uart/src/bsp/device_driver/bcm/bcm2xxx_pl011_uart.rs 06_uart_chainloader/src/bsp/device_driver/bcm/bcm2xxx_pl011_uart.rs
218
--- 05_drivers_gpio_uart/src/bsp/device_driver/bcm/bcm2xxx_pl011_uart.rs
219
+++ 06_uart_chainloader/src/bsp/device_driver/bcm/bcm2xxx_pl011_uart.rs
220
@@ -278,7 +278,7 @@
221
     }
222

223
     /// Retrieve a character.
224
-    fn read_char_converting(&mut self, blocking_mode: BlockingMode) -> Option<char> {
225
+    fn read_char(&mut self, blocking_mode: BlockingMode) -> Option<char> {
226
         // If RX FIFO is empty,
227
         if self.registers.FR.matches_all(FR::RXFE::SET) {
228
             // immediately return in non-blocking mode.
229
@@ -293,12 +293,7 @@
230
         }
231

232
         // Read one character.
233
-        let mut ret = self.registers.DR.get() as u8 as char;
234
-
235
-        // Convert carrige return to newline.
236
-        if ret == '\r' {
237
-            ret = '\n'
238
-        }
239
+        let ret = self.registers.DR.get() as u8 as char;
240

241
         // Update statistics.
242
         self.chars_read += 1;
243
@@ -378,14 +373,14 @@
244
 impl console::interface::Read for PL011Uart {
245
     fn read_char(&self) -> char {
246
         self.inner
247
-            .lock(|inner| inner.read_char_converting(BlockingMode::Blocking).unwrap())
248
+            .lock(|inner| inner.read_char(BlockingMode::Blocking).unwrap())
249
     }
250

251
     fn clear_rx(&self) {
252
         // Read from the RX FIFO until it is indicating empty.
253
         while self
254
             .inner
255
-            .lock(|inner| inner.read_char_converting(BlockingMode::NonBlocking))
256
+            .lock(|inner| inner.read_char(BlockingMode::NonBlocking))
257
             .is_some()
258
         {}
259
     }
260

261
diff -uNr 05_drivers_gpio_uart/src/bsp/raspberrypi/link.ld 06_uart_chainloader/src/bsp/raspberrypi/link.ld
262
--- 05_drivers_gpio_uart/src/bsp/raspberrypi/link.ld
263
+++ 06_uart_chainloader/src/bsp/raspberrypi/link.ld
264
@@ -3,8 +3,6 @@
265
  * Copyright (c) 2018-2021 Andre Richter <andre.o.richter@gmail.com>
266
  */
267

268
-__rpi_phys_dram_start_addr = 0;
269
-
270
 /* The physical address at which the the kernel binary will be loaded by the Raspberry's firmware */
271
 __rpi_phys_binary_load_addr = 0x80000;
272

273
@@ -28,7 +26,8 @@
274

275
 SECTIONS
276
 {
277
-    . =  __rpi_phys_dram_start_addr;
278
+    /* Set the link address to 32 MiB */
279
+    . = 0x2000000;
280

281
     /***********************************************************************************************
282
     * Boot Core Stack
283
@@ -45,6 +44,7 @@
284
     /***********************************************************************************************
285
     * Code + RO Data + Global Offset Table
286
     ***********************************************************************************************/
287
+    __binary_nonzero_start = .;
288
     .text :
289
     {
290
         KEEP(*(.text._start))
291
@@ -61,6 +61,10 @@
292
     ***********************************************************************************************/
293
     .data : { *(.data*) } :segment_data
294

295
+    /* Fill up to 8 byte, b/c relocating the binary is done in u64 chunks */
296
+    . = ALIGN(8);
297
+    __binary_nonzero_end_exclusive = .;
298
+
299
     /* Section is zeroed in pairs of u64. Align start and end to 16 bytes */
300
     .bss (NOLOAD) : ALIGN(16)
301
     {
302

303
diff -uNr 05_drivers_gpio_uart/src/bsp/raspberrypi/memory.rs 06_uart_chainloader/src/bsp/raspberrypi/memory.rs
304
--- 05_drivers_gpio_uart/src/bsp/raspberrypi/memory.rs
305
+++ 06_uart_chainloader/src/bsp/raspberrypi/memory.rs
306
@@ -11,9 +11,10 @@
307
 /// The board's physical memory map.
308
 #[rustfmt::skip]
309
 pub(super) mod map {
310
+    pub const BOARD_DEFAULT_LOAD_ADDRESS: usize =        0x8_0000;
311

312
-    pub const GPIO_OFFSET:         usize = 0x0020_0000;
313
-    pub const UART_OFFSET:         usize = 0x0020_1000;
314
+    pub const GPIO_OFFSET:                usize =        0x0020_0000;
315
+    pub const UART_OFFSET:                usize =        0x0020_1000;
316

317
     /// Physical devices.
318
     #[cfg(feature = "bsp_rpi3")]
319
@@ -35,3 +36,13 @@
320
         pub const PL011_UART_START: usize = START + UART_OFFSET;
321
     }
322
 }
323
+
324
+//--------------------------------------------------------------------------------------------------
325
+// Public Code
326
+//--------------------------------------------------------------------------------------------------
327
+
328
+/// The address on which the Raspberry firmware loads every binary by default.
329
+#[inline(always)]
330
+pub fn board_default_load_addr() -> *const u64 {
331
+    map::BOARD_DEFAULT_LOAD_ADDRESS as _
332
+}
333

334
diff -uNr 05_drivers_gpio_uart/src/main.rs 06_uart_chainloader/src/main.rs
335
--- 05_drivers_gpio_uart/src/main.rs
336
+++ 06_uart_chainloader/src/main.rs
337
@@ -141,38 +141,56 @@
338
     kernel_main()
339
 }
340

341
+const MINILOAD_LOGO: &str = r#"
342
+ __  __ _      _ _                 _
343
+|  \/  (_)_ _ (_) |   ___  __ _ __| |
344
+| |\/| | | ' \| | |__/ _ \/ _` / _` |
345
+|_|  |_|_|_||_|_|____\___/\__,_\__,_|
346
+"#;
347
+
348
 /// The main function running after the early init.
349
 fn kernel_main() -> ! {
350
     use bsp::console::console;
351
     use console::interface::All;
352
-    use driver::interface::DriverManager;
353

354
-    println!(
355
-        "[0] {} version {}",
356
-        env!("CARGO_PKG_NAME"),
357
-        env!("CARGO_PKG_VERSION")
358
-    );
359
-    println!("[1] Booting on: {}", bsp::board_name());
360
-
361
-    println!("[2] Drivers loaded:");
362
-    for (i, driver) in bsp::driver::driver_manager()
363
-        .all_device_drivers()
364
-        .iter()
365
-        .enumerate()
366
-    {
367
-        println!("      {}. {}", i + 1, driver.compatible());
368
+    println!("{}", MINILOAD_LOGO);
369
+    println!("{:^37}", bsp::board_name());
370
+    println!();
371
+    println!("[ML] Requesting binary");
372
+    console().flush();
373
+
374
+    // Discard any spurious received characters before starting with the loader protocol.
375
+    console().clear_rx();
376
+
377
+    // Notify `Minipush` to send the binary.
378
+    for _ in 0..3 {
379
+        console().write_char(3 as char);
380
     }
381

382
-    println!(
383
-        "[3] Chars written: {}",
384
-        bsp::console::console().chars_written()
385
-    );
386
-    println!("[4] Echoing input now");
387
+    // Read the binary's size.
388
+    let mut size: u32 = u32::from(console().read_char() as u8);
389
+    size |= u32::from(console().read_char() as u8) << 8;
390
+    size |= u32::from(console().read_char() as u8) << 16;
391
+    size |= u32::from(console().read_char() as u8) << 24;
392

393
-    // Discard any spurious received characters before going into echo mode.
394
-    console().clear_rx();
395
-    loop {
396
-        let c = bsp::console::console().read_char();
397
-        bsp::console::console().write_char(c);
398
+    // Trust it's not too big.
399
+    console().write_char('O');
400
+    console().write_char('K');
401
+
402
+    let kernel_addr: *mut u8 = bsp::memory::board_default_load_addr() as *mut u8;
403
+    unsafe {
404
+        // Read the kernel byte by byte.
405
+        for i in 0..size {
406
+            core::ptr::write_volatile(kernel_addr.offset(i as isize), console().read_char() as u8)
407
+        }
408
     }
409
+
410
+    println!("[ML] Loaded! Executing the payload now\n");
411
+    console().flush();
412
+
413
+    // Use black magic to create a function pointer.
414
+    let kernel: fn() -> ! = unsafe { core::mem::transmute(kernel_addr) };
415
+
416
+    // Jump to loaded kernel!
417
+    kernel()
418
 }
419

420
diff -uNr 05_drivers_gpio_uart/tests/boot_test_string.rb 06_uart_chainloader/tests/boot_test_string.rb
421
--- 05_drivers_gpio_uart/tests/boot_test_string.rb
422
+++ 06_uart_chainloader/tests/boot_test_string.rb
423
@@ -1,3 +0,0 @@
424
-# frozen_string_literal: true
425
-
426
-EXPECTED_PRINT = 'Echoing input now'
427

428
diff -uNr 05_drivers_gpio_uart/tests/chainboot_test.rb 06_uart_chainloader/tests/chainboot_test.rb
429
--- 05_drivers_gpio_uart/tests/chainboot_test.rb
430
+++ 06_uart_chainloader/tests/chainboot_test.rb
431
@@ -0,0 +1,80 @@
432
+# frozen_string_literal: true
433
+
434
+# SPDX-License-Identifier: MIT OR Apache-2.0
435
+#
436
+# Copyright (c) 2020-2021 Andre Richter <andre.o.richter@gmail.com>
437
+
438
+require_relative '../../common/serial/minipush'
439
+require_relative '../../common/tests/boot_test'
440
+require 'pty'
441
+
442
+# Match for the last print that 'demo_payload_rpiX.img' produces.
443
+EXPECTED_PRINT = 'Echoing input now'
444
+
445
+# Extend BootTest so that it listens on the output of a MiniPush instance, which is itself connected
446
+# to a QEMU instance instead of a real HW.
447
+class ChainbootTest < BootTest
448
+    MINIPUSH = '../common/serial/minipush.rb'
449
+    MINIPUSH_POWER_TARGET_REQUEST = 'Please power the target now'
450
+
451
+    def initialize(qemu_cmd, payload_path)
452
+        super(qemu_cmd, EXPECTED_PRINT)
453
+
454
+        @test_name = 'Boot test using Minipush'
455
+
456
+        @payload_path = payload_path
457
+    end
458
+
459
+    private
460
+
461
+    # override
462
+    def post_process_and_add_output(output)
463
+        temp = output.join.split("\r\n")
464
+
465
+        # Should a line have solo carriage returns, remove any overridden parts of the string.
466
+        temp.map! { |x| x.gsub(/.*\r/, '') }
467
+
468
+        @test_output += temp
469
+    end
470
+
471
+    def wait_for_minipush_power_request(mp_out)
472
+        output = []
473
+        Timeout.timeout(MAX_WAIT_SECS) do
474
+            loop do
475
+                output << mp_out.gets
476
+                break if output.last.include?(MINIPUSH_POWER_TARGET_REQUEST)
477
+            end
478
+        end
479
+    rescue Timeout::Error
480
+        @test_error = 'Timed out waiting for power request'
481
+    rescue StandardError => e
482
+        @test_error = e.message
483
+    ensure
484
+        post_process_and_add_output(output)
485
+    end
486
+
487
+    # override
488
+    def setup
489
+        pty_main, pty_secondary = PTY.open
490
+        mp_out, _mp_in = PTY.spawn("ruby #{MINIPUSH} #{pty_secondary.path} #{@payload_path}")
491
+
492
+        # Wait until MiniPush asks for powering the target.
493
+        wait_for_minipush_power_request(mp_out)
494
+
495
+        # Now is the time to start QEMU with the chainloader binary. QEMU's virtual tty is connected
496
+        # to the MiniPush instance spawned above, so that the two processes talk to each other.
497
+        Process.spawn(@qemu_cmd, in: pty_main, out: pty_main)
498
+
499
+        # The remainder of the test is done by the parent class' run_concrete_test, which listens on
500
+        # @qemu_serial. Hence, point it to MiniPush's output.
501
+        @qemu_serial = mp_out
502
+    end
503
+end
504
+
505
+##--------------------------------------------------------------------------------------------------
506
+## Execution starts here
507
+##--------------------------------------------------------------------------------------------------
508
+payload_path = ARGV.pop
509
+qemu_cmd = ARGV.join(' ')
510
+
511
+ChainbootTest.new(qemu_cmd, payload_path).run
512

513
diff -uNr 05_drivers_gpio_uart/update.sh 06_uart_chainloader/update.sh
514
--- 05_drivers_gpio_uart/update.sh
515
+++ 06_uart_chainloader/update.sh
516
@@ -0,0 +1,8 @@
517
+#!/usr/bin/env bash
518
+
519
+cd ../05_drivers_gpio_uart
520
+BSP=rpi4 make
521
+cp kernel8.img ../06_uart_chainloader/demo_payload_rpi4.img
522
+make
523
+cp kernel8.img ../06_uart_chainloader/demo_payload_rpi3.img
524
+rm kernel8.img