Archives
/
rust-raspberrypi-OS-tutorials
mirror of https://github.com/rust-embedded/rust-raspberrypi-OS-tutorials
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Makefiles: Docker USB passthrough in Linux only

Browse Source 
Detect if we run on Linux. If so, dockerize Makefile targets that need access to
USB devices. If we run on anything else, attempt to execute natively.

This will enable non-Linux Unixes like macOS to run the chainboot target, given
they install the needed Ruby dependencies.
pull/54/head
Andre Richter 4 years ago
parent 3a794448ad
commit 089565762a
No known key found for this signature in database
GPG Key ID: 2116C1AB102F615E
20 changed files with 524 additions and 458 deletions
Show Stats Download Patch File Download Diff File

21
01_wait_forever/Makefile
Unescape Escape View File

@ -38,27 +38,28 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
.PHONY: all doc qemu clippy clean readelf objdump nm .PHONY: all doc qemu clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -70,9 +71,7 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
clippy: clippy:

21
02_runtime_init/Makefile
Unescape Escape View File

@ -38,27 +38,28 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
.PHONY: all doc qemu clippy clean readelf objdump nm .PHONY: all doc qemu clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -70,9 +71,7 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
clippy: clippy:

21
03_hacky_hello_world/Makefile
Unescape Escape View File

@ -38,27 +38,28 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
.PHONY: all doc qemu clippy clean readelf objdump nm .PHONY: all doc qemu clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -70,9 +71,7 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
clippy: clippy:

21
04_zero_overhead_abstraction/Makefile
Unescape Escape View File

@ -38,27 +38,28 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
.PHONY: all doc qemu clippy clean readelf objdump nm .PHONY: all doc qemu clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -70,9 +71,7 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
clippy: clippy:

21
05_safe_globals/Makefile
Unescape Escape View File

@ -38,27 +38,28 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
.PHONY: all doc qemu clippy clean readelf objdump nm .PHONY: all doc qemu clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -70,9 +71,7 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
clippy: clippy:

21
06_drivers_gpio_uart/Makefile
Unescape Escape View File

@ -38,27 +38,28 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
.PHONY: all doc qemu clippy clean readelf objdump nm .PHONY: all doc qemu clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -70,9 +71,7 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
clippy: clippy:

47
07_uart_chainloader/Makefile
Unescape Escape View File

@ -7,11 +7,14 @@ ifndef BSP
BSP = rpi3 BSP = rpi3
endif endif
# Default to /dev/ttyUSB0 # Default to a serial device name that is common in Linux.
ifndef DEV_SERIAL ifndef DEV_SERIAL
DEV_SERIAL = /dev/ttyUSB0 DEV_SERIAL = /dev/ttyUSB0
endif endif
# Query the host system's kernel name
UNAME_S := $(shell uname -s)
# BSP-specific arguments # BSP-specific arguments
ifeq ($(BSP),rpi3) ifeq ($(BSP),rpi3)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
@ -45,30 +48,38 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DEV = --privileged -v /dev:/dev
DOCKER_ARG_TTY = --privileged -v /dev:/dev
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
DOCKER_CMD_DEV = $(DOCKER_CMD) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
endif
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
.PHONY: all doc qemu qemuasm chainboot clippy clean readelf objdump nm .PHONY: all doc qemu qemuasm chainboot clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -83,20 +94,14 @@ qemuasm:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
qemuasm: all qemuasm: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT) -d in_asm
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT) -d in_asm
endif endif
chainboot: chainboot:
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(CHAINBOOT_DEMO_PAYLOAD)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
$(CHAINBOOT_DEMO_PAYLOAD)
clippy: clippy:
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)

49
07_uart_chainloader/README.md
Unescape Escape View File

@ -88,19 +88,22 @@ Binary files 06_drivers_gpio_uart/demo_payload_rpi4.img and 07_uart_chainloader/
diff -uNr 06_drivers_gpio_uart/Makefile 07_uart_chainloader/Makefile diff -uNr 06_drivers_gpio_uart/Makefile 07_uart_chainloader/Makefile
--- 06_drivers_gpio_uart/Makefile --- 06_drivers_gpio_uart/Makefile
+++ 07_uart_chainloader/Makefile +++ 07_uart_chainloader/Makefile
@@ -7,6 +7,11 @@ @@ -7,6 +7,14 @@
BSP = rpi3 BSP = rpi3
endif endif
+# Default to /dev/ttyUSB0 +# Default to a serial device name that is common in Linux.
+ifndef DEV_SERIAL +ifndef DEV_SERIAL
+ DEV_SERIAL = /dev/ttyUSB0 + DEV_SERIAL = /dev/ttyUSB0
+endif +endif
+
+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
+ +
# BSP-specific arguments # BSP-specific arguments
ifeq ($(BSP),rpi3) ifeq ($(BSP),rpi3)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
@@ -15,7 +20,8 @@ @@ -15,7 +23,8 @@
QEMU_MACHINE_TYPE = raspi3 QEMU_MACHINE_TYPE = raspi3
QEMU_RELEASE_ARGS = -serial stdio -display none QEMU_RELEASE_ARGS = -serial stdio -display none
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
@ -110,7 +113,7 @@ diff -uNr 06_drivers_gpio_uart/Makefile 07_uart_chainloader/Makefile
else ifeq ($(BSP),rpi4) else ifeq ($(BSP),rpi4)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
OUTPUT = kernel8.img OUTPUT = kernel8.img
@@ -23,7 +29,8 @@ @@ -23,7 +32,8 @@
# QEMU_MACHINE_TYPE = # QEMU_MACHINE_TYPE =
# QEMU_RELEASE_ARGS = -serial stdio -display none # QEMU_RELEASE_ARGS = -serial stdio -display none
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
@ -120,21 +123,31 @@ diff -uNr 06_drivers_gpio_uart/Makefile 07_uart_chainloader/Makefile
endif endif
SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld) SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld)
@@ -49,9 +56,12 @@ @@ -47,12 +57,22 @@
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work +DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils +DOCKER_ARG_DEV = --privileged -v /dev:/dev
+DOCKER_ARG_TTY = --privileged -v /dev:/dev
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
+DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb
+# Dockerize commands that require USB device passthrough only on Linux
+ifeq ($(UNAME_S),Linux)
+DOCKER_CMD_DEV = $(DOCKER_CMD) $(DOCKER_ARG_DEV)
+
+DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
+endif
+
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
+EXEC_MINIPUSH = ruby ../utils/minipush.rb
-.PHONY: all doc qemu clippy clean readelf objdump nm -.PHONY: all doc qemu clippy clean readelf objdump nm
+.PHONY: all doc qemu qemuasm chainboot clippy clean readelf objdump nm +.PHONY: all doc qemu qemuasm chainboot clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
@@ -68,13 +78,26 @@ @@ -69,11 +89,20 @@
ifeq ($(QEMU_MACHINE_TYPE),) ifeq ($(QEMU_MACHINE_TYPE),)
qemu: qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
@ -143,20 +156,14 @@ diff -uNr 06_drivers_gpio_uart/Makefile 07_uart_chainloader/Makefile
+ @echo "This board is not yet supported for QEMU." + @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
+ +
+qemuasm: all +qemuasm: all
+ @$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ + @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT) -d in_asm
+ $(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
+ -kernel $(OUTPUT) -d in_asm
endif endif
+chainboot: +chainboot:
+ @$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ + @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(CHAINBOOT_DEMO_PAYLOAD)
+ $(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
+ $(CHAINBOOT_DEMO_PAYLOAD)
+ +
clippy: clippy:
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)

43
08_timestamps/Makefile
Unescape Escape View File

@ -7,11 +7,14 @@ ifndef BSP
BSP = rpi3 BSP = rpi3
endif endif
# Default to /dev/ttyUSB0 # Default to a serial device name that is common in Linux.
ifndef DEV_SERIAL ifndef DEV_SERIAL
DEV_SERIAL = /dev/ttyUSB0 DEV_SERIAL = /dev/ttyUSB0
endif endif
# Query the host system's kernel name
UNAME_S := $(shell uname -s)
# BSP-specific arguments # BSP-specific arguments
ifeq ($(BSP),rpi3) ifeq ($(BSP),rpi3)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
@ -43,30 +46,38 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DEV = --privileged -v /dev:/dev
DOCKER_ARG_TTY = --privileged -v /dev:/dev
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
DOCKER_CMD_DEV = $(DOCKER_CMD) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
endif
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
.PHONY: all doc qemu chainboot clippy clean readelf objdump nm .PHONY: all doc qemu chainboot clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -78,15 +89,11 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
chainboot: all chainboot: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
$(OUTPUT)
clippy: clippy:
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)

26
08_timestamps/README.md
Unescape Escape View File

@ -46,7 +46,7 @@ Binary files 07_uart_chainloader/demo_payload_rpi4.img and 08_timestamps/demo_pa
diff -uNr 07_uart_chainloader/Makefile 08_timestamps/Makefile diff -uNr 07_uart_chainloader/Makefile 08_timestamps/Makefile
--- 07_uart_chainloader/Makefile --- 07_uart_chainloader/Makefile
+++ 08_timestamps/Makefile +++ 08_timestamps/Makefile
@@ -20,8 +20,7 @@ @@ -23,8 +23,7 @@
QEMU_MACHINE_TYPE = raspi3 QEMU_MACHINE_TYPE = raspi3
QEMU_RELEASE_ARGS = -serial stdio -display none QEMU_RELEASE_ARGS = -serial stdio -display none
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
@ -56,7 +56,7 @@ diff -uNr 07_uart_chainloader/Makefile 08_timestamps/Makefile
else ifeq ($(BSP),rpi4) else ifeq ($(BSP),rpi4)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
OUTPUT = kernel8.img OUTPUT = kernel8.img
@@ -29,8 +28,7 @@ @@ -32,8 +31,7 @@
# QEMU_MACHINE_TYPE = # QEMU_MACHINE_TYPE =
# QEMU_RELEASE_ARGS = -serial stdio -display none # QEMU_RELEASE_ARGS = -serial stdio -display none
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
@ -66,16 +66,16 @@ diff -uNr 07_uart_chainloader/Makefile 08_timestamps/Makefile
endif endif
SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld) SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld)
@@ -61,7 +59,7 @@ @@ -72,7 +70,7 @@
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb EXEC_MINIPUSH = ruby ../utils/minipush.rb
-.PHONY: all doc qemu qemuasm chainboot clippy clean readelf objdump nm -.PHONY: all doc qemu qemuasm chainboot clippy clean readelf objdump nm
+.PHONY: all doc qemu chainboot clippy clean readelf objdump nm +.PHONY: all doc qemu chainboot clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
@@ -78,25 +76,17 @@ @@ -89,19 +87,13 @@
ifeq ($(QEMU_MACHINE_TYPE),) ifeq ($(QEMU_MACHINE_TYPE),)
qemu: qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
@ -84,22 +84,16 @@ diff -uNr 07_uart_chainloader/Makefile 08_timestamps/Makefile
- @echo "This board is not yet supported for QEMU." - @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
- -
-qemuasm: all -qemuasm: all
- @$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ - @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT) -d in_asm
- $(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
- -kernel $(OUTPUT) -d in_asm
endif endif
-chainboot: -chainboot:
- @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(CHAINBOOT_DEMO_PAYLOAD)
+chainboot: all +chainboot: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ + @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
- $(CHAINBOOT_DEMO_PAYLOAD)
+ $(OUTPUT)
clippy: clippy:
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)

66
09_hw_debug_JTAG/Makefile
Unescape Escape View File

@ -7,11 +7,14 @@ ifndef BSP
BSP = rpi3 BSP = rpi3
endif endif
# Default to /dev/ttyUSB0 # Default to a serial device name that is common in Linux.
ifndef DEV_SERIAL ifndef DEV_SERIAL
DEV_SERIAL = /dev/ttyUSB0 DEV_SERIAL = /dev/ttyUSB0
endif endif
# Query the host system's kernel name
UNAME_S := $(shell uname -s)
# BSP-specific arguments # BSP-specific arguments
ifeq ($(BSP),rpi3) ifeq ($(BSP),rpi3)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
@ -20,7 +23,7 @@ ifeq ($(BSP),rpi3)
QEMU_MACHINE_TYPE = raspi3 QEMU_MACHINE_TYPE = raspi3
QEMU_RELEASE_ARGS = -serial stdio -display none QEMU_RELEASE_ARGS = -serial stdio -display none
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi3.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi3.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a53 RUSTC_MISC_ARGS = -C target-cpu=cortex-a53
else ifeq ($(BSP),rpi4) else ifeq ($(BSP),rpi4)
@ -30,7 +33,7 @@ else ifeq ($(BSP),rpi4)
# QEMU_MACHINE_TYPE = # QEMU_MACHINE_TYPE =
# QEMU_RELEASE_ARGS = -serial stdio -display none # QEMU_RELEASE_ARGS = -serial stdio -display none
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi4.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi4.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a72 RUSTC_MISC_ARGS = -C target-cpu=cortex-a72
endif endif
@ -47,32 +50,45 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/jtag DOCKER_ARG_DEV = --privileged -v /dev:/dev
DOCKER_ARG_TTY = --privileged -v /dev:/dev
DOCKER_ARG_NET = --network host DOCKER_ARG_NET = --network host
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
DOCKER_GDB = $(DOCKER_CMD) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
DOCKER_CMD_DEV = $(DOCKER_CMD) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
DOCKER_JTAGBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_IMAGE)
DOCKER_OPENOCD = $(DOCKER_CMD_DEV) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
else
DOCKER_OPENOCD = echo "Not yet supported on non-Linux systems."; \#
endif
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm .PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -84,30 +100,22 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
chainboot: all chainboot: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
$(OUTPUT)
jtagboot: jtagboot:
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
/jtag/$(JTAG_BOOT_IMAGE)
openocd: openocd:
@$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
openocd $(OPENOCD_ARG)
define gen_gdb define gen_gdb
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
cp $(CARGO_OUTPUT) kernel_for_jtag cp $(KERNEL_ELF) kernel_for_jtag
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
gdb-multiarch -q kernel_for_jtag
endef endef
gdb: clean $(SOURCES) gdb: clean $(SOURCES)

57
09_hw_debug_JTAG/README.md
Unescape Escape View File

@ -305,57 +305,68 @@ Thanks to [@naotaco](https://github.com/naotaco) for laying the groundwork for t
diff -uNr 08_timestamps/Makefile 09_hw_debug_JTAG/Makefile diff -uNr 08_timestamps/Makefile 09_hw_debug_JTAG/Makefile
--- 08_timestamps/Makefile --- 08_timestamps/Makefile
+++ 09_hw_debug_JTAG/Makefile +++ 09_hw_debug_JTAG/Makefile
@@ -19,6 +19,8 @@ @@ -22,6 +22,8 @@
QEMU_BINARY = qemu-system-aarch64 QEMU_BINARY = qemu-system-aarch64
QEMU_MACHINE_TYPE = raspi3 QEMU_MACHINE_TYPE = raspi3
QEMU_RELEASE_ARGS = -serial stdio -display none QEMU_RELEASE_ARGS = -serial stdio -display none
+ OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg + OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg
+ JTAG_BOOT_IMAGE = jtag_boot_rpi3.img + JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi3.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a53 RUSTC_MISC_ARGS = -C target-cpu=cortex-a53
else ifeq ($(BSP),rpi4) else ifeq ($(BSP),rpi4)
@@ -27,6 +29,8 @@ @@ -30,6 +32,8 @@
# QEMU_BINARY = qemu-system-aarch64 # QEMU_BINARY = qemu-system-aarch64
# QEMU_MACHINE_TYPE = # QEMU_MACHINE_TYPE =
# QEMU_RELEASE_ARGS = -serial stdio -display none # QEMU_RELEASE_ARGS = -serial stdio -display none
+ OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg + OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg
+ JTAG_BOOT_IMAGE = jtag_boot_rpi4.img + JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi4.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a72 RUSTC_MISC_ARGS = -C target-cpu=cortex-a72
endif endif
@@ -55,11 +59,13 @@ @@ -56,21 +60,28 @@
DOCKER_CMD = docker run -it --rm DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/jtag +DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
DOCKER_ARG_TTY = --privileged -v /dev:/dev DOCKER_ARG_DEV = --privileged -v /dev:/dev
+DOCKER_ARG_NET = --network host +DOCKER_ARG_NET = --network host
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
+DOCKER_GDB = $(DOCKER_CMD) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
DOCKER_CMD_DEV = $(DOCKER_CMD) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
+DOCKER_JTAGBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_IMAGE)
+DOCKER_OPENOCD = $(DOCKER_CMD_DEV) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
+else
+DOCKER_OPENOCD = echo "Not yet supported on non-Linux systems."; \#
endif
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
-.PHONY: all doc qemu chainboot clippy clean readelf objdump nm -.PHONY: all doc qemu chainboot clippy clean readelf objdump nm
+.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm +.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
@@ -88,6 +94,28 @@ @@ -95,6 +106,24 @@
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \ chainboot: all
$(OUTPUT) @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
+jtagboot: +jtagboot:
+ @$(DOCKER_CMD) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ + @$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
+ $(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
+ /jtag/$(JTAG_BOOT_IMAGE)
+ +
+openocd: +openocd:
+ @$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ + @$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
+ openocd $(OPENOCD_ARG)
+ +
+define gen_gdb +define gen_gdb
+ RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD) + RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
+ cp $(CARGO_OUTPUT) kernel_for_jtag + cp $(KERNEL_ELF) kernel_for_jtag
+ @$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ + @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
+ gdb-multiarch -q kernel_for_jtag
+endef +endef
+ +
+gdb: clean $(SOURCES) +gdb: clean $(SOURCES)

66
10_privilege_level/Makefile
Unescape Escape View File

@ -7,11 +7,14 @@ ifndef BSP
BSP = rpi3 BSP = rpi3
endif endif
# Default to /dev/ttyUSB0 # Default to a serial device name that is common in Linux.
ifndef DEV_SERIAL ifndef DEV_SERIAL
DEV_SERIAL = /dev/ttyUSB0 DEV_SERIAL = /dev/ttyUSB0
endif endif
# Query the host system's kernel name
UNAME_S := $(shell uname -s)
# BSP-specific arguments # BSP-specific arguments
ifeq ($(BSP),rpi3) ifeq ($(BSP),rpi3)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
@ -20,7 +23,7 @@ ifeq ($(BSP),rpi3)
QEMU_MACHINE_TYPE = raspi3 QEMU_MACHINE_TYPE = raspi3
QEMU_RELEASE_ARGS = -serial stdio -display none QEMU_RELEASE_ARGS = -serial stdio -display none
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi3.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi3.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a53 RUSTC_MISC_ARGS = -C target-cpu=cortex-a53
else ifeq ($(BSP),rpi4) else ifeq ($(BSP),rpi4)
@ -30,7 +33,7 @@ else ifeq ($(BSP),rpi4)
# QEMU_MACHINE_TYPE = # QEMU_MACHINE_TYPE =
# QEMU_RELEASE_ARGS = -serial stdio -display none # QEMU_RELEASE_ARGS = -serial stdio -display none
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi4.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi4.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a72 RUSTC_MISC_ARGS = -C target-cpu=cortex-a72
endif endif
@ -47,32 +50,45 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/jtag DOCKER_ARG_DEV = --privileged -v /dev:/dev
DOCKER_ARG_TTY = --privileged -v /dev:/dev
DOCKER_ARG_NET = --network host DOCKER_ARG_NET = --network host
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
DOCKER_GDB = $(DOCKER_CMD) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
DOCKER_CMD_DEV = $(DOCKER_CMD) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
DOCKER_JTAGBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_IMAGE)
DOCKER_OPENOCD = $(DOCKER_CMD_DEV) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
else
DOCKER_OPENOCD = echo "Not yet supported on non-Linux systems."; \#
endif
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm .PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -84,30 +100,22 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
chainboot: all chainboot: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
$(OUTPUT)
jtagboot: jtagboot:
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
/jtag/$(JTAG_BOOT_IMAGE)
openocd: openocd:
@$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
openocd $(OPENOCD_ARG)
define gen_gdb define gen_gdb
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
cp $(CARGO_OUTPUT) kernel_for_jtag cp $(KERNEL_ELF) kernel_for_jtag
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
gdb-multiarch -q kernel_for_jtag
endef endef
gdb: clean $(SOURCES) gdb: clean $(SOURCES)

66
11_virtual_memory/Makefile
Unescape Escape View File

@ -7,11 +7,14 @@ ifndef BSP
BSP = rpi3 BSP = rpi3
endif endif
# Default to /dev/ttyUSB0 # Default to a serial device name that is common in Linux.
ifndef DEV_SERIAL ifndef DEV_SERIAL
DEV_SERIAL = /dev/ttyUSB0 DEV_SERIAL = /dev/ttyUSB0
endif endif
# Query the host system's kernel name
UNAME_S := $(shell uname -s)
# BSP-specific arguments # BSP-specific arguments
ifeq ($(BSP),rpi3) ifeq ($(BSP),rpi3)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
@ -20,7 +23,7 @@ ifeq ($(BSP),rpi3)
QEMU_MACHINE_TYPE = raspi3 QEMU_MACHINE_TYPE = raspi3
QEMU_RELEASE_ARGS = -serial stdio -display none QEMU_RELEASE_ARGS = -serial stdio -display none
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi3.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi3.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a53 RUSTC_MISC_ARGS = -C target-cpu=cortex-a53
else ifeq ($(BSP),rpi4) else ifeq ($(BSP),rpi4)
@ -30,7 +33,7 @@ else ifeq ($(BSP),rpi4)
# QEMU_MACHINE_TYPE = # QEMU_MACHINE_TYPE =
# QEMU_RELEASE_ARGS = -serial stdio -display none # QEMU_RELEASE_ARGS = -serial stdio -display none
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi4.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi4.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a72 RUSTC_MISC_ARGS = -C target-cpu=cortex-a72
endif endif
@ -47,32 +50,45 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/jtag DOCKER_ARG_DEV = --privileged -v /dev:/dev
DOCKER_ARG_TTY = --privileged -v /dev:/dev
DOCKER_ARG_NET = --network host DOCKER_ARG_NET = --network host
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
DOCKER_GDB = $(DOCKER_CMD) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
DOCKER_CMD_DEV = $(DOCKER_CMD) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
DOCKER_JTAGBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_IMAGE)
DOCKER_OPENOCD = $(DOCKER_CMD_DEV) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
else
DOCKER_OPENOCD = echo "Not yet supported on non-Linux systems."; \#
endif
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm .PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -84,30 +100,22 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
chainboot: all chainboot: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
$(OUTPUT)
jtagboot: jtagboot:
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
/jtag/$(JTAG_BOOT_IMAGE)
openocd: openocd:
@$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
openocd $(OPENOCD_ARG)
define gen_gdb define gen_gdb
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
cp $(CARGO_OUTPUT) kernel_for_jtag cp $(KERNEL_ELF) kernel_for_jtag
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
gdb-multiarch -q kernel_for_jtag
endef endef
gdb: clean $(SOURCES) gdb: clean $(SOURCES)

66
12_exceptions_part1_groundwork/Makefile
Unescape Escape View File

@ -7,11 +7,14 @@ ifndef BSP
BSP = rpi3 BSP = rpi3
endif endif
# Default to /dev/ttyUSB0 # Default to a serial device name that is common in Linux.
ifndef DEV_SERIAL ifndef DEV_SERIAL
DEV_SERIAL = /dev/ttyUSB0 DEV_SERIAL = /dev/ttyUSB0
endif endif
# Query the host system's kernel name
UNAME_S := $(shell uname -s)
# BSP-specific arguments # BSP-specific arguments
ifeq ($(BSP),rpi3) ifeq ($(BSP),rpi3)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
@ -20,7 +23,7 @@ ifeq ($(BSP),rpi3)
QEMU_MACHINE_TYPE = raspi3 QEMU_MACHINE_TYPE = raspi3
QEMU_RELEASE_ARGS = -serial stdio -display none QEMU_RELEASE_ARGS = -serial stdio -display none
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi3.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi3.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a53 RUSTC_MISC_ARGS = -C target-cpu=cortex-a53
else ifeq ($(BSP),rpi4) else ifeq ($(BSP),rpi4)
@ -30,7 +33,7 @@ else ifeq ($(BSP),rpi4)
# QEMU_MACHINE_TYPE = # QEMU_MACHINE_TYPE =
# QEMU_RELEASE_ARGS = -serial stdio -display none # QEMU_RELEASE_ARGS = -serial stdio -display none
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi4.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi4.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a72 RUSTC_MISC_ARGS = -C target-cpu=cortex-a72
endif endif
@ -47,32 +50,45 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/jtag DOCKER_ARG_DEV = --privileged -v /dev:/dev
DOCKER_ARG_TTY = --privileged -v /dev:/dev
DOCKER_ARG_NET = --network host DOCKER_ARG_NET = --network host
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
DOCKER_GDB = $(DOCKER_CMD) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
DOCKER_CMD_DEV = $(DOCKER_CMD) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
DOCKER_JTAGBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_IMAGE)
DOCKER_OPENOCD = $(DOCKER_CMD_DEV) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
else
DOCKER_OPENOCD = echo "Not yet supported on non-Linux systems."; \#
endif
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm .PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -84,30 +100,22 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
chainboot: all chainboot: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
$(OUTPUT)
jtagboot: jtagboot:
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
/jtag/$(JTAG_BOOT_IMAGE)
openocd: openocd:
@$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
openocd $(OPENOCD_ARG)
define gen_gdb define gen_gdb
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
cp $(CARGO_OUTPUT) kernel_for_jtag cp $(KERNEL_ELF) kernel_for_jtag
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
gdb-multiarch -q kernel_for_jtag
endef endef
gdb: clean $(SOURCES) gdb: clean $(SOURCES)

70
13_integrated_testing/Makefile
Unescape Escape View File

@ -7,11 +7,14 @@ ifndef BSP
BSP = rpi3 BSP = rpi3
endif endif
# Default to /dev/ttyUSB0 # Default to a serial device name that is common in Linux.
ifndef DEV_SERIAL ifndef DEV_SERIAL
DEV_SERIAL = /dev/ttyUSB0 DEV_SERIAL = /dev/ttyUSB0
endif endif
# Query the host system's kernel name
UNAME_S := $(shell uname -s)
# BSP-specific arguments # BSP-specific arguments
ifeq ($(BSP),rpi3) ifeq ($(BSP),rpi3)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
@ -21,7 +24,7 @@ ifeq ($(BSP),rpi3)
QEMU_RELEASE_ARGS = -serial stdio -display none QEMU_RELEASE_ARGS = -serial stdio -display none
QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi3.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi3.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a53 RUSTC_MISC_ARGS = -C target-cpu=cortex-a53
else ifeq ($(BSP),rpi4) else ifeq ($(BSP),rpi4)
@ -32,7 +35,7 @@ else ifeq ($(BSP),rpi4)
# QEMU_RELEASE_ARGS = -serial stdio -display none # QEMU_RELEASE_ARGS = -serial stdio -display none
# QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting # QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi4.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi4.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a72 RUSTC_MISC_ARGS = -C target-cpu=cortex-a72
endif endif
@ -61,33 +64,47 @@ RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
TEST_CMD = cargo test $(COMPILER_ARGS) TEST_CMD = cargo test $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD_TEST = docker run -i --rm DOCKER_CMD_TEST = docker run -i --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_CMD_USER = $(DOCKER_CMD_TEST) -t DOCKER_CMD_USER = $(DOCKER_CMD_TEST) -t
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/jtag DOCKER_ARG_DEV = --privileged -v /dev:/dev
DOCKER_ARG_TTY = --privileged -v /dev:/dev
DOCKER_ARG_NET = --network host DOCKER_ARG_NET = --network host
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb DOCKER_QEMU = $(DOCKER_CMD_USER) $(DOCKER_IMAGE)
DOCKER_GDB = $(DOCKER_CMD_USER) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
DOCKER_TEST = $(DOCKER_CMD_TEST) $(DOCKER_IMAGE)
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
DOCKER_CMD_DEV = $(DOCKER_CMD_USER) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
DOCKER_JTAGBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_IMAGE)
DOCKER_OPENOCD = $(DOCKER_CMD_DEV) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
else
DOCKER_OPENOCD = echo "Not yet supported on non-Linux systems."; \#
endif
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm test .PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm test
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -102,17 +119,14 @@ test:
@echo $(QEMU_MISSING_STRING) @echo $(QEMU_MISSING_STRING)
else else
qemu: all qemu: all
@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
define KERNEL_TEST_RUNNER define KERNEL_TEST_RUNNER
#!/usr/bin/env bash #!/usr/bin/env bash
$(OBJCOPY_CMD) $$1 $$1.img $(OBJCOPY_CMD) $$1 $$1.img
TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g') TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g')
$(DOCKER_CMD_TEST) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ $(DOCKER_TEST) ruby tests/runner.rb $(EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
ruby tests/runner.rb $(DOCKER_EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
endef endef
export KERNEL_TEST_RUNNER export KERNEL_TEST_RUNNER
@ -124,24 +138,18 @@ test: $(SOURCES)
endif endif
chainboot: all chainboot: all
@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
$(OUTPUT)
jtagboot: jtagboot:
@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
/jtag/$(JTAG_BOOT_IMAGE)
openocd: openocd:
@$(DOCKER_CMD_USER) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
openocd $(OPENOCD_ARG)
define gen_gdb define gen_gdb
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
cp $(CARGO_OUTPUT) kernel_for_jtag cp $(KERNEL_ELF) kernel_for_jtag
@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
gdb-multiarch -q kernel_for_jtag
endef endef
gdb: clean $(SOURCES) gdb: clean $(SOURCES)

93
13_integrated_testing/README.md
Unescape Escape View File

@ -350,8 +350,7 @@ define KERNEL_TEST_RUNNER
$(OBJCOPY_CMD) $$1 $$1.img $(OBJCOPY_CMD) $$1 $$1.img
TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g') TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g')
$(DOCKER_CMD_TEST) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ $(DOCKER_TEST) ruby tests/runner.rb $(EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
ruby tests/runner.rb $(DOCKER_EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
endef endef
export KERNEL_TEST_RUNNER export KERNEL_TEST_RUNNER
@ -368,7 +367,7 @@ provided to it by `cargo`, and finally compiles a `docker` command to execute th
reference, here it is fully resolved for an `RPi3 BSP`: reference, here it is fully resolved for an `RPi3 BSP`:
```bash ```bash
docker run -it --rm -v /opt/rust-raspi3-OS-tutorials/13_integrated_testing:/work -w /work rustembedded/osdev-utils ruby tests/runner.rb qemu-system-aarch64 -M raspi3 -serial stdio -display none -semihosting -kernel $TEST_BINARY docker run -i --rm -v /opt/rust-raspberrypi-OS-tutorials/13_integrated_testing:/work/tutorial -w /work/tutorial rustembedded/osdev-utils ruby tests/runner.rb qemu-system-aarch64 -M raspi3 -serial stdio -display none -semihosting -kernel $TEST_BINARY
``` ```
We're still not done with all the redirections. Spotted the `ruby tests/runner.rb` part that gets We're still not done with all the redirections. Spotted the `ruby tests/runner.rb` part that gets
@ -820,21 +819,21 @@ diff -uNr 12_exceptions_part1_groundwork/Cargo.toml 13_integrated_testing/Cargo.
diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile
--- 12_exceptions_part1_groundwork/Makefile --- 12_exceptions_part1_groundwork/Makefile
+++ 13_integrated_testing/Makefile +++ 13_integrated_testing/Makefile
@@ -19,6 +19,7 @@ @@ -22,6 +22,7 @@
QEMU_BINARY = qemu-system-aarch64 QEMU_BINARY = qemu-system-aarch64
QEMU_MACHINE_TYPE = raspi3 QEMU_MACHINE_TYPE = raspi3
QEMU_RELEASE_ARGS = -serial stdio -display none QEMU_RELEASE_ARGS = -serial stdio -display none
+ QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting + QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi3.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi3.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
@@ -29,12 +30,24 @@ @@ -32,12 +33,24 @@
# QEMU_BINARY = qemu-system-aarch64 # QEMU_BINARY = qemu-system-aarch64
# QEMU_MACHINE_TYPE = # QEMU_MACHINE_TYPE =
# QEMU_RELEASE_ARGS = -serial stdio -display none # QEMU_RELEASE_ARGS = -serial stdio -display none
+ # QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting + # QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi4.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi4.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a72 RUSTC_MISC_ARGS = -C target-cpu=cortex-a72
endif endif
@ -853,34 +852,49 @@ diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile
SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld) SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld)
RUSTFLAGS = -C link-arg=-T$(LINKER_FILE) $(RUSTC_MISC_ARGS) RUSTFLAGS = -C link-arg=-T$(LINKER_FILE) $(RUSTC_MISC_ARGS)
@@ -47,6 +60,7 @@ @@ -50,6 +63,7 @@
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
+TEST_CMD = cargo test $(COMPILER_ARGS) +TEST_CMD = cargo test $(COMPILER_ARGS)
OBJCOPY_CMD = cargo objcopy \
CARGO_OUTPUT = target/$(TARGET)/release/kernel -- \
--strip-all \
@@ -56,7 +70,8 @@ @@ -58,18 +72,20 @@
-O binary KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
-DOCKER_CMD = docker run -it --rm -DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_CMD_TEST = docker run -i --rm +DOCKER_CMD_TEST = docker run -i --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_CMD_USER = $(DOCKER_CMD_TEST) -t +DOCKER_CMD_USER = $(DOCKER_CMD_TEST) -t
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/jtag DOCKER_ARG_DEV = --privileged -v /dev:/dev
@@ -65,7 +80,7 @@ DOCKER_ARG_NET = --network host
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb -DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
-DOCKER_GDB = $(DOCKER_CMD) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
+DOCKER_QEMU = $(DOCKER_CMD_USER) $(DOCKER_IMAGE)
+DOCKER_GDB = $(DOCKER_CMD_USER) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
+DOCKER_TEST = $(DOCKER_CMD_TEST) $(DOCKER_IMAGE)
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
-DOCKER_CMD_DEV = $(DOCKER_CMD) $(DOCKER_ARG_DEV)
+DOCKER_CMD_DEV = $(DOCKER_CMD_USER) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
DOCKER_JTAGBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_IMAGE)
@@ -81,7 +97,7 @@
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
-.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm -.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm
+.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm test +.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm test
all: clean $(OUTPUT) all: clean $(OUTPUT)
@@ -81,32 +96,51 @@ @@ -97,10 +113,28 @@
ifeq ($(QEMU_MACHINE_TYPE),) ifeq ($(QEMU_MACHINE_TYPE),)
qemu: qemu:
@ -891,19 +905,14 @@ diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile
+ @echo $(QEMU_MISSING_STRING) + @echo $(QEMU_MISSING_STRING)
else else
qemu: all qemu: all
- @$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
- $(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
+ @$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
+ $(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
+ +
+define KERNEL_TEST_RUNNER +define KERNEL_TEST_RUNNER
+ #!/usr/bin/env bash + #!/usr/bin/env bash
+ +
+ $(OBJCOPY_CMD) $$1 $$1.img + $(OBJCOPY_CMD) $$1 $$1.img
+ TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g') + TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g')
+ $(DOCKER_CMD_TEST) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ + $(DOCKER_TEST) ruby tests/runner.rb $(EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
+ ruby tests/runner.rb $(DOCKER_EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
+endef +endef
+ +
+export KERNEL_TEST_RUNNER +export KERNEL_TEST_RUNNER
@ -915,32 +924,6 @@ diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile
endif endif
chainboot: all chainboot: all
- @$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
- $(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
+ @$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
+ $(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
$(OUTPUT)
jtagboot:
- @$(DOCKER_CMD) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
- $(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
+ @$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
+ $(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
/jtag/$(JTAG_BOOT_IMAGE)
openocd:
- @$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
+ @$(DOCKER_CMD_USER) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
openocd $(OPENOCD_ARG)
define gen_gdb
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
cp $(CARGO_OUTPUT) kernel_for_jtag
- @$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
+ @$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
gdb-multiarch -q kernel_for_jtag
endef
diff -uNr 12_exceptions_part1_groundwork/src/_arch/aarch64/cpu.rs 13_integrated_testing/src/_arch/aarch64/cpu.rs diff -uNr 12_exceptions_part1_groundwork/src/_arch/aarch64/cpu.rs 13_integrated_testing/src/_arch/aarch64/cpu.rs
--- 12_exceptions_part1_groundwork/src/_arch/aarch64/cpu.rs --- 12_exceptions_part1_groundwork/src/_arch/aarch64/cpu.rs

72
14_exceptions_part2_peripheral_IRQs/Makefile
Unescape Escape View File

@ -7,11 +7,14 @@ ifndef BSP
BSP = rpi3 BSP = rpi3
endif endif
# Default to /dev/ttyUSB0 # Default to a serial device name that is common in Linux.
ifndef DEV_SERIAL ifndef DEV_SERIAL
DEV_SERIAL = /dev/ttyUSB0 DEV_SERIAL = /dev/ttyUSB0
endif endif
# Query the host system's kernel name
UNAME_S := $(shell uname -s)
# BSP-specific arguments # BSP-specific arguments
ifeq ($(BSP),rpi3) ifeq ($(BSP),rpi3)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
@ -21,7 +24,7 @@ ifeq ($(BSP),rpi3)
QEMU_RELEASE_ARGS = -serial stdio -display none QEMU_RELEASE_ARGS = -serial stdio -display none
QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi3.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi3.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi3.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a53 RUSTC_MISC_ARGS = -C target-cpu=cortex-a53
else ifeq ($(BSP),rpi4) else ifeq ($(BSP),rpi4)
@ -32,7 +35,7 @@ else ifeq ($(BSP),rpi4)
# QEMU_RELEASE_ARGS = -serial stdio -display none # QEMU_RELEASE_ARGS = -serial stdio -display none
# QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting # QEMU_TEST_ARGS = $(QEMU_RELEASE_ARGS) -semihosting
OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg OPENOCD_ARG = -f /openocd/tcl/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /openocd/rpi4.cfg
JTAG_BOOT_IMAGE = jtag_boot_rpi4.img JTAG_BOOT_IMAGE = ../X1_JTAG_boot/jtag_boot_rpi4.img
LINKER_FILE = src/bsp/raspberrypi/link.ld LINKER_FILE = src/bsp/raspberrypi/link.ld
RUSTC_MISC_ARGS = -C target-cpu=cortex-a72 RUSTC_MISC_ARGS = -C target-cpu=cortex-a72
endif endif
@ -52,8 +55,8 @@ SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld)
RUSTFLAGS = -C link-arg=-T$(LINKER_FILE) $(RUSTC_MISC_ARGS) RUSTFLAGS = -C link-arg=-T$(LINKER_FILE) $(RUSTC_MISC_ARGS)
RUSTFLAGS_PEDANTIC = $(RUSTFLAGS) -D warnings -D missing_docs RUSTFLAGS_PEDANTIC = $(RUSTFLAGS) -D warnings -D missing_docs
FEATURES = bsp_$(BSP)
FEATURES = bsp_$(BSP)
COMPILER_ARGS = --target=$(TARGET) \ COMPILER_ARGS = --target=$(TARGET) \
--features $(FEATURES) \ --features $(FEATURES) \
--release --release
@ -62,33 +65,47 @@ RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
TEST_CMD = cargo test $(COMPILER_ARGS) TEST_CMD = cargo test $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD_TEST = docker run -i --rm DOCKER_CMD_TEST = docker run -i --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_CMD_USER = $(DOCKER_CMD_TEST) -t DOCKER_CMD_USER = $(DOCKER_CMD_TEST) -t
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
DOCKER_ARG_DIR_JTAG = -v $(shell pwd)/../X1_JTAG_boot:/jtag DOCKER_ARG_DEV = --privileged -v /dev:/dev
DOCKER_ARG_TTY = --privileged -v /dev:/dev
DOCKER_ARG_NET = --network host DOCKER_ARG_NET = --network host
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb DOCKER_QEMU = $(DOCKER_CMD_USER) $(DOCKER_IMAGE)
DOCKER_GDB = $(DOCKER_CMD_USER) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
DOCKER_TEST = $(DOCKER_CMD_TEST) $(DOCKER_IMAGE)
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
DOCKER_CMD_DEV = $(DOCKER_CMD_USER) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
DOCKER_JTAGBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_IMAGE)
DOCKER_OPENOCD = $(DOCKER_CMD_DEV) $(DOCKER_ARG_NET) $(DOCKER_IMAGE)
else
DOCKER_OPENOCD = echo "Not yet supported on non-Linux systems."; \#
endif
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm test .PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm test
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -104,17 +121,14 @@ test:
@echo $(QEMU_MISSING_STRING) @echo $(QEMU_MISSING_STRING)
else else
qemu: all qemu: all
@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
define KERNEL_TEST_RUNNER define KERNEL_TEST_RUNNER
#!/usr/bin/env bash #!/usr/bin/env bash
$(OBJCOPY_CMD) $$1 $$1.img $(OBJCOPY_CMD) $$1 $$1.img
TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g') TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g')
$(DOCKER_CMD_TEST) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ $(DOCKER_TEST) ruby tests/runner.rb $(EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
ruby tests/runner.rb $(DOCKER_EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
endef endef
export KERNEL_TEST_RUNNER export KERNEL_TEST_RUNNER
@ -127,24 +141,18 @@ test: $(SOURCES)
endif endif
chainboot: all chainboot: all
@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
$(OUTPUT)
jtagboot: jtagboot:
@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
/jtag/$(JTAG_BOOT_IMAGE)
openocd: openocd:
@$(DOCKER_CMD_USER) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
openocd $(OPENOCD_ARG)
define gen_gdb define gen_gdb
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
cp $(CARGO_OUTPUT) kernel_for_jtag cp $(KERNEL_ELF) kernel_for_jtag
@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \ @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
gdb-multiarch -q kernel_for_jtag
endef endef
gdb: clean $(SOURCES) gdb: clean $(SOURCES)

20
14_exceptions_part2_peripheral_IRQs/README.md
Unescape Escape View File

@ -762,19 +762,29 @@ diff -uNr 13_integrated_testing/Cargo.toml 14_exceptions_part2_peripheral_IRQs/C
diff -uNr 13_integrated_testing/Makefile 14_exceptions_part2_peripheral_IRQs/Makefile diff -uNr 13_integrated_testing/Makefile 14_exceptions_part2_peripheral_IRQs/Makefile
--- 13_integrated_testing/Makefile --- 13_integrated_testing/Makefile
+++ 14_exceptions_part2_peripheral_IRQs/Makefile +++ 14_exceptions_part2_peripheral_IRQs/Makefile
@@ -52,9 +52,10 @@ @@ -56,8 +56,9 @@
RUSTFLAGS = -C link-arg=-T$(LINKER_FILE) $(RUSTC_MISC_ARGS) RUSTFLAGS = -C link-arg=-T$(LINKER_FILE) $(RUSTC_MISC_ARGS)
RUSTFLAGS_PEDANTIC = $(RUSTFLAGS) -D warnings -D missing_docs RUSTFLAGS_PEDANTIC = $(RUSTFLAGS) -D warnings -D missing_docs
+FEATURES = bsp_$(BSP)
+FEATURES = bsp_$(BSP)
COMPILER_ARGS = --target=$(TARGET) \ COMPILER_ARGS = --target=$(TARGET) \
- --features bsp_$(BSP) \ - --features bsp_$(BSP) \
+ --features $(FEATURES) \ + --features $(FEATURES) \
--release --release
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
@@ -94,6 +95,7 @@ @@ -94,8 +95,8 @@
DOCKER_OPENOCD = echo "Not yet supported on non-Linux systems."; \#
endif
-EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
-EXEC_MINIPUSH = ruby ../utils/minipush.rb
+EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
+EXEC_MINIPUSH = ruby ../utils/minipush.rb
.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm test
@@ -111,6 +112,7 @@
doc: doc:
$(DOC_CMD) --document-private-items --open $(DOC_CMD) --document-private-items --open
@ -782,7 +792,7 @@ diff -uNr 13_integrated_testing/Makefile 14_exceptions_part2_peripheral_IRQs/Mak
ifeq ($(QEMU_MACHINE_TYPE),) ifeq ($(QEMU_MACHINE_TYPE),)
qemu: qemu:
@echo $(QEMU_MISSING_STRING) @echo $(QEMU_MISSING_STRING)
@@ -116,6 +118,7 @@ @@ -130,6 +132,7 @@
endef endef
export KERNEL_TEST_RUNNER export KERNEL_TEST_RUNNER

43
X1_JTAG_boot/Makefile
Unescape Escape View File

@ -7,11 +7,14 @@ ifndef BSP
BSP = rpi3 BSP = rpi3
endif endif
# Default to /dev/ttyUSB0 # Default to a serial device name that is common in Linux.
ifndef DEV_SERIAL ifndef DEV_SERIAL
DEV_SERIAL = /dev/ttyUSB0 DEV_SERIAL = /dev/ttyUSB0
endif endif
# Query the host system's kernel name
UNAME_S := $(shell uname -s)
# BSP-specific arguments # BSP-specific arguments
ifeq ($(BSP),rpi3) ifeq ($(BSP),rpi3)
TARGET = aarch64-unknown-none-softfloat TARGET = aarch64-unknown-none-softfloat
@ -43,30 +46,38 @@ COMPILER_ARGS = --target=$(TARGET) \
RUSTC_CMD = cargo rustc $(COMPILER_ARGS) RUSTC_CMD = cargo rustc $(COMPILER_ARGS)
DOC_CMD = cargo doc $(COMPILER_ARGS) DOC_CMD = cargo doc $(COMPILER_ARGS)
CLIPPY_CMD = cargo clippy $(COMPILER_ARGS) CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
CARGO_OUTPUT = target/$(TARGET)/release/kernel
OBJCOPY_CMD = cargo objcopy \ OBJCOPY_CMD = cargo objcopy \
-- \ -- \
--strip-all \ --strip-all \
-O binary -O binary
KERNEL_ELF = target/$(TARGET)/release/kernel
DOCKER_IMAGE = rustembedded/osdev-utils DOCKER_IMAGE = rustembedded/osdev-utils
DOCKER_CMD = docker run -it --rm DOCKER_CMD = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
DOCKER_ARG_DIR_TUT = -v $(shell pwd):/work -w /work DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils DOCKER_ARG_DEV = --privileged -v /dev:/dev
DOCKER_ARG_TTY = --privileged -v /dev:/dev
DOCKER_EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb
# Dockerize commands that require USB device passthrough only on Linux
ifeq ($(UNAME_S),Linux)
DOCKER_CMD_DEV = $(DOCKER_CMD) $(DOCKER_ARG_DEV)
DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
endif
EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
EXEC_MINIPUSH = ruby ../utils/minipush.rb
.PHONY: all doc qemu chainboot clippy clean readelf objdump nm .PHONY: all doc qemu chainboot clippy clean readelf objdump nm
all: clean $(OUTPUT) all: clean $(OUTPUT)
$(CARGO_OUTPUT): $(SOURCES) $(KERNEL_ELF): $(SOURCES)
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
$(OUTPUT): $(CARGO_OUTPUT) $(OUTPUT): $(KERNEL_ELF)
cp $< . cp $< .
$(OBJCOPY_CMD) $< $(OUTPUT) $(OBJCOPY_CMD) $< $(OUTPUT)
@ -78,15 +89,11 @@ qemu:
@echo "This board is not yet supported for QEMU." @echo "This board is not yet supported for QEMU."
else else
qemu: all qemu: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \ @$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS) \
-kernel $(OUTPUT)
endif endif
chainboot: all chainboot: all
@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \ @$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL) \
$(OUTPUT)
clippy: clippy:
RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD) RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)

Write Preview
Loading…
Cancel
Save